diff options
Diffstat (limited to 'drivers/uwb/uwb-internal.h')
-rw-r--r-- | drivers/uwb/uwb-internal.h | 305 |
1 files changed, 305 insertions, 0 deletions
diff --git a/drivers/uwb/uwb-internal.h b/drivers/uwb/uwb-internal.h new file mode 100644 index 000000000000..2ad307d12961 --- /dev/null +++ b/drivers/uwb/uwb-internal.h | |||
@@ -0,0 +1,305 @@ | |||
1 | /* | ||
2 | * Ultra Wide Band | ||
3 | * UWB internal API | ||
4 | * | ||
5 | * Copyright (C) 2005-2006 Intel Corporation | ||
6 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or | ||
9 | * modify it under the terms of the GNU General Public License version | ||
10 | * 2 as published by the Free Software Foundation. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | ||
20 | * 02110-1301, USA. | ||
21 | * | ||
22 | * This contains most of the internal API for UWB. This is stuff used | ||
23 | * across the stack that of course, is of no interest to the rest. | ||
24 | * | ||
25 | * Some parts might end up going public (like uwb_rc_*())... | ||
26 | */ | ||
27 | |||
28 | #ifndef __UWB_INTERNAL_H__ | ||
29 | #define __UWB_INTERNAL_H__ | ||
30 | |||
31 | #include <linux/version.h> | ||
32 | #include <linux/kernel.h> | ||
33 | #include <linux/device.h> | ||
34 | #include <linux/uwb.h> | ||
35 | #include <linux/mutex.h> | ||
36 | |||
37 | struct uwb_beca_e; | ||
38 | |||
39 | /* General device API */ | ||
40 | extern void uwb_dev_init(struct uwb_dev *uwb_dev); | ||
41 | extern int __uwb_dev_offair(struct uwb_dev *, struct uwb_rc *); | ||
42 | extern int uwb_dev_add(struct uwb_dev *uwb_dev, struct device *parent_dev, | ||
43 | struct uwb_rc *parent_rc); | ||
44 | extern void uwb_dev_rm(struct uwb_dev *uwb_dev); | ||
45 | extern void uwbd_dev_onair(struct uwb_rc *, struct uwb_beca_e *); | ||
46 | extern void uwbd_dev_offair(struct uwb_beca_e *); | ||
47 | void uwb_notify(struct uwb_rc *rc, struct uwb_dev *uwb_dev, enum uwb_notifs event); | ||
48 | |||
49 | /* General UWB Radio Controller Internal API */ | ||
50 | extern struct uwb_rc *__uwb_rc_try_get(struct uwb_rc *); | ||
51 | static inline struct uwb_rc *__uwb_rc_get(struct uwb_rc *rc) | ||
52 | { | ||
53 | uwb_dev_get(&rc->uwb_dev); | ||
54 | return rc; | ||
55 | } | ||
56 | |||
57 | static inline void __uwb_rc_put(struct uwb_rc *rc) | ||
58 | { | ||
59 | uwb_dev_put(&rc->uwb_dev); | ||
60 | } | ||
61 | |||
62 | extern int uwb_rc_reset(struct uwb_rc *rc); | ||
63 | extern int uwb_rc_beacon(struct uwb_rc *rc, | ||
64 | int channel, unsigned bpst_offset); | ||
65 | extern int uwb_rc_scan(struct uwb_rc *rc, | ||
66 | unsigned channel, enum uwb_scan_type type, | ||
67 | unsigned bpst_offset); | ||
68 | extern int uwb_rc_send_all_drp_ie(struct uwb_rc *rc); | ||
69 | extern ssize_t uwb_rc_print_IEs(struct uwb_rc *rc, char *, size_t); | ||
70 | extern void uwb_rc_ie_init(struct uwb_rc *); | ||
71 | extern void uwb_rc_ie_init(struct uwb_rc *); | ||
72 | extern ssize_t uwb_rc_ie_setup(struct uwb_rc *); | ||
73 | extern void uwb_rc_ie_release(struct uwb_rc *); | ||
74 | extern int uwb_rc_ie_add(struct uwb_rc *, | ||
75 | const struct uwb_ie_hdr *, size_t); | ||
76 | extern int uwb_rc_ie_rm(struct uwb_rc *, enum uwb_ie); | ||
77 | |||
78 | extern const char *uwb_rc_strerror(unsigned code); | ||
79 | |||
80 | /* | ||
81 | * Time to wait for a response to an RC command. | ||
82 | * | ||
83 | * Some commands can take a long time to response. e.g., START_BEACON | ||
84 | * may scan for several superframes before joining an existing beacon | ||
85 | * group and this can take around 600 ms. | ||
86 | */ | ||
87 | #define UWB_RC_CMD_TIMEOUT_MS 1000 /* ms */ | ||
88 | |||
89 | /* | ||
90 | * Notification/Event Handlers | ||
91 | */ | ||
92 | |||
93 | struct uwb_rc_neh; | ||
94 | |||
95 | void uwb_rc_neh_create(struct uwb_rc *rc); | ||
96 | void uwb_rc_neh_destroy(struct uwb_rc *rc); | ||
97 | |||
98 | struct uwb_rc_neh *uwb_rc_neh_add(struct uwb_rc *rc, struct uwb_rccb *cmd, | ||
99 | u8 expected_type, u16 expected_event, | ||
100 | uwb_rc_cmd_cb_f cb, void *arg); | ||
101 | void uwb_rc_neh_rm(struct uwb_rc *rc, struct uwb_rc_neh *neh); | ||
102 | void uwb_rc_neh_arm(struct uwb_rc *rc, struct uwb_rc_neh *neh); | ||
103 | void uwb_rc_neh_put(struct uwb_rc_neh *neh); | ||
104 | |||
105 | /* Event size tables */ | ||
106 | extern int uwb_est_create(void); | ||
107 | extern void uwb_est_destroy(void); | ||
108 | |||
109 | |||
110 | /* | ||
111 | * UWB Events & management daemon | ||
112 | */ | ||
113 | |||
114 | /** | ||
115 | * enum uwb_event_type - types of UWB management daemon events | ||
116 | * | ||
117 | * The UWB management daemon (uwbd) can receive two types of events: | ||
118 | * UWB_EVT_TYPE_NOTIF - notification from the radio controller. | ||
119 | * UWB_EVT_TYPE_MSG - a simple message. | ||
120 | */ | ||
121 | enum uwb_event_type { | ||
122 | UWB_EVT_TYPE_NOTIF, | ||
123 | UWB_EVT_TYPE_MSG, | ||
124 | }; | ||
125 | |||
126 | /** | ||
127 | * struct uwb_event_notif - an event for a radio controller notification | ||
128 | * @size: Size of the buffer (ie: Guaranteed to contain at least | ||
129 | * a full 'struct uwb_rceb') | ||
130 | * @rceb: Pointer to a kmalloced() event payload | ||
131 | */ | ||
132 | struct uwb_event_notif { | ||
133 | size_t size; | ||
134 | struct uwb_rceb *rceb; | ||
135 | }; | ||
136 | |||
137 | /** | ||
138 | * enum uwb_event_message - an event for a message for asynchronous processing | ||
139 | * | ||
140 | * UWB_EVT_MSG_RESET - reset the radio controller and all PAL hardware. | ||
141 | */ | ||
142 | enum uwb_event_message { | ||
143 | UWB_EVT_MSG_RESET, | ||
144 | }; | ||
145 | |||
146 | /** | ||
147 | * UWB Event | ||
148 | * @rc: Radio controller that emitted the event (referenced) | ||
149 | * @ts_jiffies: Timestamp, when was it received | ||
150 | * @type: This event's type. | ||
151 | */ | ||
152 | struct uwb_event { | ||
153 | struct list_head list_node; | ||
154 | struct uwb_rc *rc; | ||
155 | unsigned long ts_jiffies; | ||
156 | enum uwb_event_type type; | ||
157 | union { | ||
158 | struct uwb_event_notif notif; | ||
159 | enum uwb_event_message message; | ||
160 | }; | ||
161 | }; | ||
162 | |||
163 | extern void uwbd_start(void); | ||
164 | extern void uwbd_stop(void); | ||
165 | extern struct uwb_event *uwb_event_alloc(size_t, gfp_t gfp_mask); | ||
166 | extern void uwbd_event_queue(struct uwb_event *); | ||
167 | void uwbd_flush(struct uwb_rc *rc); | ||
168 | |||
169 | /* UWB event handlers */ | ||
170 | extern int uwbd_evt_handle_rc_beacon(struct uwb_event *); | ||
171 | extern int uwbd_evt_handle_rc_beacon_size(struct uwb_event *); | ||
172 | extern int uwbd_evt_handle_rc_bpoie_change(struct uwb_event *); | ||
173 | extern int uwbd_evt_handle_rc_bp_slot_change(struct uwb_event *); | ||
174 | extern int uwbd_evt_handle_rc_drp(struct uwb_event *); | ||
175 | extern int uwbd_evt_handle_rc_drp_avail(struct uwb_event *); | ||
176 | |||
177 | int uwbd_msg_handle_reset(struct uwb_event *evt); | ||
178 | |||
179 | |||
180 | /* | ||
181 | * Address management | ||
182 | */ | ||
183 | int uwb_rc_dev_addr_assign(struct uwb_rc *rc); | ||
184 | int uwbd_evt_handle_rc_dev_addr_conflict(struct uwb_event *evt); | ||
185 | |||
186 | /* | ||
187 | * UWB Beacon Cache | ||
188 | * | ||
189 | * Each beacon we received is kept in a cache--when we receive that | ||
190 | * beacon consistently, that means there is a new device that we have | ||
191 | * to add to the system. | ||
192 | */ | ||
193 | |||
194 | extern unsigned long beacon_timeout_ms; | ||
195 | |||
196 | /** Beacon cache list */ | ||
197 | struct uwb_beca { | ||
198 | struct list_head list; | ||
199 | size_t entries; | ||
200 | struct mutex mutex; | ||
201 | }; | ||
202 | |||
203 | extern struct uwb_beca uwb_beca; | ||
204 | |||
205 | /** | ||
206 | * Beacon cache entry | ||
207 | * | ||
208 | * @jiffies_refresh: last time a beacon was received that refreshed | ||
209 | * this cache entry. | ||
210 | * @uwb_dev: device connected to this beacon. This pointer is not | ||
211 | * safe, you need to get it with uwb_dev_try_get() | ||
212 | * | ||
213 | * @hits: how many time we have seen this beacon since last time we | ||
214 | * cleared it | ||
215 | */ | ||
216 | struct uwb_beca_e { | ||
217 | struct mutex mutex; | ||
218 | struct kref refcnt; | ||
219 | struct list_head node; | ||
220 | struct uwb_mac_addr *mac_addr; | ||
221 | struct uwb_dev_addr dev_addr; | ||
222 | u8 hits; | ||
223 | unsigned long ts_jiffies; | ||
224 | struct uwb_dev *uwb_dev; | ||
225 | struct uwb_rc_evt_beacon *be; | ||
226 | struct stats lqe_stats, rssi_stats; /* radio statistics */ | ||
227 | }; | ||
228 | struct uwb_beacon_frame; | ||
229 | extern ssize_t uwb_bce_print_IEs(struct uwb_dev *, struct uwb_beca_e *, | ||
230 | char *, size_t); | ||
231 | extern struct uwb_beca_e *__uwb_beca_add(struct uwb_rc_evt_beacon *, | ||
232 | struct uwb_beacon_frame *, | ||
233 | unsigned long); | ||
234 | |||
235 | extern void uwb_bce_kfree(struct kref *_bce); | ||
236 | static inline void uwb_bce_get(struct uwb_beca_e *bce) | ||
237 | { | ||
238 | kref_get(&bce->refcnt); | ||
239 | } | ||
240 | static inline void uwb_bce_put(struct uwb_beca_e *bce) | ||
241 | { | ||
242 | kref_put(&bce->refcnt, uwb_bce_kfree); | ||
243 | } | ||
244 | extern void uwb_beca_purge(void); | ||
245 | extern void uwb_beca_release(void); | ||
246 | |||
247 | struct uwb_dev *uwb_dev_get_by_devaddr(struct uwb_rc *rc, | ||
248 | const struct uwb_dev_addr *devaddr); | ||
249 | struct uwb_dev *uwb_dev_get_by_macaddr(struct uwb_rc *rc, | ||
250 | const struct uwb_mac_addr *macaddr); | ||
251 | |||
252 | /* -- UWB Sysfs representation */ | ||
253 | extern struct class uwb_rc_class; | ||
254 | extern struct device_attribute dev_attr_mac_address; | ||
255 | extern struct device_attribute dev_attr_beacon; | ||
256 | extern struct device_attribute dev_attr_scan; | ||
257 | |||
258 | /* -- DRP Bandwidth allocator: bandwidth allocations, reservations, DRP */ | ||
259 | void uwb_rsv_init(struct uwb_rc *rc); | ||
260 | int uwb_rsv_setup(struct uwb_rc *rc); | ||
261 | void uwb_rsv_cleanup(struct uwb_rc *rc); | ||
262 | |||
263 | void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state); | ||
264 | void uwb_rsv_remove(struct uwb_rsv *rsv); | ||
265 | struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src, | ||
266 | struct uwb_ie_drp *drp_ie); | ||
267 | void uwb_rsv_sched_update(struct uwb_rc *rc); | ||
268 | |||
269 | void uwb_drp_handle_timeout(struct uwb_rsv *rsv); | ||
270 | int uwb_drp_ie_update(struct uwb_rsv *rsv); | ||
271 | void uwb_drp_ie_to_bm(struct uwb_mas_bm *bm, const struct uwb_ie_drp *drp_ie); | ||
272 | |||
273 | void uwb_drp_avail_init(struct uwb_rc *rc); | ||
274 | int uwb_drp_avail_reserve_pending(struct uwb_rc *rc, struct uwb_mas_bm *mas); | ||
275 | void uwb_drp_avail_reserve(struct uwb_rc *rc, struct uwb_mas_bm *mas); | ||
276 | void uwb_drp_avail_release(struct uwb_rc *rc, struct uwb_mas_bm *mas); | ||
277 | void uwb_drp_avail_ie_update(struct uwb_rc *rc); | ||
278 | |||
279 | /* -- PAL support */ | ||
280 | void uwb_rc_pal_init(struct uwb_rc *rc); | ||
281 | |||
282 | /* -- Misc */ | ||
283 | |||
284 | extern ssize_t uwb_mac_frame_hdr_print(char *, size_t, | ||
285 | const struct uwb_mac_frame_hdr *); | ||
286 | |||
287 | /* -- Debug interface */ | ||
288 | void uwb_dbg_init(void); | ||
289 | void uwb_dbg_exit(void); | ||
290 | void uwb_dbg_add_rc(struct uwb_rc *rc); | ||
291 | void uwb_dbg_del_rc(struct uwb_rc *rc); | ||
292 | |||
293 | /* Workarounds for version specific stuff */ | ||
294 | |||
295 | static inline void uwb_dev_lock(struct uwb_dev *uwb_dev) | ||
296 | { | ||
297 | down(&uwb_dev->dev.sem); | ||
298 | } | ||
299 | |||
300 | static inline void uwb_dev_unlock(struct uwb_dev *uwb_dev) | ||
301 | { | ||
302 | up(&uwb_dev->dev.sem); | ||
303 | } | ||
304 | |||
305 | #endif /* #ifndef __UWB_INTERNAL_H__ */ | ||