1 /*
2 * Wireless USB Host Controller
3 * Common infrastructure for WHCI and HWA WUSB-HC drivers
4 *
5 *
6 * Copyright (C) 2005-2006 Intel Corporation
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 * 02110-1301, USA.
22 *
23 *
24 * This driver implements parts common to all Wireless USB Host
25 * Controllers (struct wusbhc, embedding a struct usb_hcd) and is used
26 * by:
27 *
28 * - hwahc: HWA, USB-dongle that implements a Wireless USB host
29 * controller, (Wireless USB 1.0 Host-Wire-Adapter specification).
30 *
31 * - whci: WHCI, a PCI card with a wireless host controller
32 * (Wireless Host Controller Interface 1.0 specification).
33 *
34 * Check out the Design-overview.txt file in the source documentation
35 * for other details on the implementation.
36 *
37 * Main blocks:
38 *
39 * rh Root Hub emulation (part of the HCD glue)
40 *
41 * devconnect Handle all the issues related to device connection,
42 * authentication, disconnection, timeout, reseting,
43 * keepalives, etc.
44 *
45 * mmc MMC IE broadcasting handling
46 *
47 * A host controller driver just initializes its stuff and as part of
48 * that, creates a 'struct wusbhc' instance that handles all the
49 * common WUSB mechanisms. Links in the function ops that are specific
50 * to it and then registers the host controller. Ready to run.
51 */
52
53 #ifndef __WUSBHC_H__
54 #define __WUSBHC_H__
55
56 #include <linux/usb.h>
57 #include <linux/list.h>
58 #include <linux/mutex.h>
59 #include <linux/kref.h>
60 #include <linux/workqueue.h>
61 #include <linux/usb/hcd.h>
62 #include <linux/uwb.h>
63 #include <linux/usb/wusb.h>
64
65 /*
66 * Time from a WUSB channel stop request to the last transmitted MMC.
67 *
68 * This needs to be > 4.096 ms in case no MMCs can be transmitted in
69 * zone 0.
70 */
71 #define WUSB_CHANNEL_STOP_DELAY_MS 8
72 #define WUSB_RETRY_COUNT_MAX 15
73 #define WUSB_RETRY_COUNT_INFINITE 0
74
75 /**
76 * Wireless USB device
77 *
78 * Describe a WUSB device connected to the cluster. This struct
79 * belongs to the 'struct wusb_port' it is attached to and it is
80 * responsible for putting and clearing the pointer to it.
81 *
82 * Note this "complements" the 'struct usb_device' that the usb_hcd
83 * keeps for each connected USB device. However, it extends some
84 * information that is not available (there is no hcpriv ptr in it!)
85 * *and* most importantly, it's life cycle is different. It is created
86 * as soon as we get a DN_Connect (connect request notification) from
87 * the device through the WUSB host controller; the USB stack doesn't
88 * create the device until we authenticate it. FIXME: this will
89 * change.
90 *
91 * @bos: This is allocated when the BOS descriptors are read from
92 * the device and freed upon the wusb_dev struct dying.
93 * @wusb_cap_descr: points into @bos, and has been verified to be size
94 * safe.
95 */
96 struct wusb_dev {
97 struct kref refcnt;
98 struct wusbhc *wusbhc;
99 struct list_head cack_node; /* Connect-Ack list */
100 struct list_head rekey_node; /* GTK rekey list */
101 u8 port_idx;
102 u8 addr;
103 u8 beacon_type:4;
104 struct usb_encryption_descriptor ccm1_etd;
105 struct wusb_ckhdid cdid;
106 unsigned long entry_ts;
107 struct usb_bos_descriptor *bos;
108 struct usb_wireless_cap_descriptor *wusb_cap_descr;
109 struct uwb_mas_bm availability;
110 struct work_struct devconnect_acked_work;
111 struct usb_device *usb_dev;
112 };
113
114 #define WUSB_DEV_ADDR_UNAUTH 0x80
115
wusb_dev_init(struct wusb_dev * wusb_dev)116 static inline void wusb_dev_init(struct wusb_dev *wusb_dev)
117 {
118 kref_init(&wusb_dev->refcnt);
119 /* no need to init the cack_node */
120 }
121
122 extern void wusb_dev_destroy(struct kref *_wusb_dev);
123
wusb_dev_get(struct wusb_dev * wusb_dev)124 static inline struct wusb_dev *wusb_dev_get(struct wusb_dev *wusb_dev)
125 {
126 kref_get(&wusb_dev->refcnt);
127 return wusb_dev;
128 }
129
wusb_dev_put(struct wusb_dev * wusb_dev)130 static inline void wusb_dev_put(struct wusb_dev *wusb_dev)
131 {
132 kref_put(&wusb_dev->refcnt, wusb_dev_destroy);
133 }
134
135 /**
136 * Wireless USB Host Controller root hub "fake" ports
137 * (state and device information)
138 *
139 * Wireless USB is wireless, so there are no ports; but we
140 * fake'em. Each RC can connect a max of devices at the same time
141 * (given in the Wireless Adapter descriptor, bNumPorts or WHCI's
142 * caps), referred to in wusbhc->ports_max.
143 *
144 * See rh.c for more information.
145 *
146 * The @status and @change use the same bits as in USB2.0[11.24.2.7],
147 * so we don't have to do much when getting the port's status.
148 *
149 * WUSB1.0[7.1], USB2.0[11.24.2.7.1,fig 11-10],
150 * include/linux/usb_ch9.h (#define USB_PORT_STAT_*)
151 */
152 struct wusb_port {
153 u16 status;
154 u16 change;
155 struct wusb_dev *wusb_dev; /* connected device's info */
156 u32 ptk_tkid;
157 };
158
159 /**
160 * WUSB Host Controller specifics
161 *
162 * All fields that are common to all Wireless USB controller types
163 * (HWA and WHCI) are grouped here. Host Controller
164 * functions/operations that only deal with general Wireless USB HC
165 * issues use this data type to refer to the host.
166 *
167 * @usb_hcd Instantiation of a USB host controller
168 * (initialized by upper layer [HWA=HC or WHCI].
169 *
170 * @dev Device that implements this; initialized by the
171 * upper layer (HWA-HC, WHCI...); this device should
172 * have a refcount.
173 *
174 * @trust_timeout After this time without hearing for device
175 * activity, we consider the device gone and we have to
176 * re-authenticate.
177 *
178 * Can be accessed w/o locking--however, read to a
179 * local variable then use.
180 *
181 * @chid WUSB Cluster Host ID: this is supposed to be a
182 * unique value that doesn't change across reboots (so
183 * that your devices do not require re-association).
184 *
185 * Read/Write protected by @mutex
186 *
187 * @dev_info This array has ports_max elements. It is used to
188 * give the HC information about the WUSB devices (see
189 * 'struct wusb_dev_info').
190 *
191 * For HWA we need to allocate it in heap; for WHCI it
192 * needs to be permanently mapped, so we keep it for
193 * both and make it easy. Call wusbhc->dev_info_set()
194 * to update an entry.
195 *
196 * @ports_max Number of simultaneous device connections (fake
197 * ports) this HC will take. Read-only.
198 *
199 * @port Array of port status for each fake root port. Guaranteed to
200 * always be the same length during device existence
201 * [this allows for some unlocked but referenced reading].
202 *
203 * @mmcies_max Max number of Information Elements this HC can send
204 * in its MMC. Read-only.
205 *
206 * @start Start the WUSB channel.
207 *
208 * @stop Stop the WUSB channel after the specified number of
209 * milliseconds. Channel Stop IEs should be transmitted
210 * as required by [WUSB] 4.16.2.1.
211 *
212 * @mmcie_add HC specific operation (WHCI or HWA) for adding an
213 * MMCIE.
214 *
215 * @mmcie_rm HC specific operation (WHCI or HWA) for removing an
216 * MMCIE.
217 *
218 * @set_ptk: Set the PTK and enable encryption for a device. Or, if
219 * the supplied key is NULL, disable encryption for that
220 * device.
221 *
222 * @set_gtk: Set the GTK to be used for all future broadcast packets
223 * (i.e., MMCs). With some hardware, setting the GTK may start
224 * MMC transmission.
225 *
226 * NOTE:
227 *
228 * - If wusb_dev->usb_dev is not NULL, then usb_dev is valid
229 * (wusb_dev has a refcount on it). Likewise, if usb_dev->wusb_dev
230 * is not NULL, usb_dev->wusb_dev is valid (usb_dev keeps a
231 * refcount on it).
232 *
233 * Most of the times when you need to use it, it will be non-NULL,
234 * so there is no real need to check for it (wusb_dev will
235 * disappear before usb_dev).
236 *
237 * - The following fields need to be filled out before calling
238 * wusbhc_create(): ports_max, mmcies_max, mmcie_{add,rm}.
239 *
240 * - there is no wusbhc_init() method, we do everything in
241 * wusbhc_create().
242 *
243 * - Creation is done in two phases, wusbhc_create() and
244 * wusbhc_create_b(); b are the parts that need to be called after
245 * calling usb_hcd_add(&wusbhc->usb_hcd).
246 */
247 struct wusbhc {
248 struct usb_hcd usb_hcd; /* HAS TO BE 1st */
249 struct device *dev;
250 struct uwb_rc *uwb_rc;
251 struct uwb_pal pal;
252
253 unsigned trust_timeout; /* in jiffies */
254 struct wusb_ckhdid chid;
255 uint8_t phy_rate;
256 uint8_t dnts_num_slots;
257 uint8_t dnts_interval;
258 uint8_t retry_count;
259 struct wuie_host_info *wuie_host_info;
260
261 struct mutex mutex; /* locks everything else */
262 u16 cluster_id; /* Wireless USB Cluster ID */
263 struct wusb_port *port; /* Fake port status handling */
264 struct wusb_dev_info *dev_info; /* for Set Device Info mgmt */
265 u8 ports_max;
266 unsigned active:1; /* currently xmit'ing MMCs */
267 struct wuie_keep_alive keep_alive_ie; /* protected by mutex */
268 struct delayed_work keep_alive_timer;
269 struct list_head cack_list; /* Connect acknowledging */
270 size_t cack_count; /* protected by 'mutex' */
271 struct wuie_connect_ack cack_ie;
272 struct uwb_rsv *rsv; /* cluster bandwidth reservation */
273
274 struct mutex mmcie_mutex; /* MMC WUIE handling */
275 struct wuie_hdr **mmcie; /* WUIE array */
276 u8 mmcies_max;
277 /* FIXME: make wusbhc_ops? */
278 int (*start)(struct wusbhc *wusbhc);
279 void (*stop)(struct wusbhc *wusbhc, int delay);
280 int (*mmcie_add)(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
281 u8 handle, struct wuie_hdr *wuie);
282 int (*mmcie_rm)(struct wusbhc *wusbhc, u8 handle);
283 int (*dev_info_set)(struct wusbhc *, struct wusb_dev *wusb_dev);
284 int (*bwa_set)(struct wusbhc *wusbhc, s8 stream_index,
285 const struct uwb_mas_bm *);
286 int (*set_ptk)(struct wusbhc *wusbhc, u8 port_idx,
287 u32 tkid, const void *key, size_t key_size);
288 int (*set_gtk)(struct wusbhc *wusbhc,
289 u32 tkid, const void *key, size_t key_size);
290 int (*set_num_dnts)(struct wusbhc *wusbhc, u8 interval, u8 slots);
291
292 struct {
293 struct usb_key_descriptor descr;
294 u8 data[16]; /* GTK key data */
295 } __attribute__((packed)) gtk;
296 u8 gtk_index;
297 u32 gtk_tkid;
298
299 /* workqueue for WUSB security related tasks. */
300 struct workqueue_struct *wq_security;
301 struct work_struct gtk_rekey_work;
302
303 struct usb_encryption_descriptor *ccm1_etd;
304 };
305
306 #define usb_hcd_to_wusbhc(u) container_of((u), struct wusbhc, usb_hcd)
307
308
309 extern int wusbhc_create(struct wusbhc *);
310 extern int wusbhc_b_create(struct wusbhc *);
311 extern void wusbhc_b_destroy(struct wusbhc *);
312 extern void wusbhc_destroy(struct wusbhc *);
313 extern int wusb_dev_sysfs_add(struct wusbhc *, struct usb_device *,
314 struct wusb_dev *);
315 extern void wusb_dev_sysfs_rm(struct wusb_dev *);
316 extern int wusbhc_sec_create(struct wusbhc *);
317 extern int wusbhc_sec_start(struct wusbhc *);
318 extern void wusbhc_sec_stop(struct wusbhc *);
319 extern void wusbhc_sec_destroy(struct wusbhc *);
320 extern void wusbhc_giveback_urb(struct wusbhc *wusbhc, struct urb *urb,
321 int status);
322 void wusbhc_reset_all(struct wusbhc *wusbhc);
323
324 int wusbhc_pal_register(struct wusbhc *wusbhc);
325 void wusbhc_pal_unregister(struct wusbhc *wusbhc);
326
327 /*
328 * Return @usb_dev's @usb_hcd (properly referenced) or NULL if gone
329 *
330 * @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr)
331 *
332 * This is a safe assumption as @usb_dev->bus is referenced all the
333 * time during the @usb_dev life cycle.
334 */
335 static inline
usb_hcd_get_by_usb_dev(struct usb_device * usb_dev)336 struct usb_hcd *usb_hcd_get_by_usb_dev(struct usb_device *usb_dev)
337 {
338 struct usb_hcd *usb_hcd;
339 usb_hcd = container_of(usb_dev->bus, struct usb_hcd, self);
340 return usb_get_hcd(usb_hcd);
341 }
342
343 /*
344 * Increment the reference count on a wusbhc.
345 *
346 * @wusbhc's life cycle is identical to that of the underlying usb_hcd.
347 */
wusbhc_get(struct wusbhc * wusbhc)348 static inline struct wusbhc *wusbhc_get(struct wusbhc *wusbhc)
349 {
350 return usb_get_hcd(&wusbhc->usb_hcd) ? wusbhc : NULL;
351 }
352
353 /*
354 * Return the wusbhc associated to a @usb_dev
355 *
356 * @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr)
357 *
358 * @returns: wusbhc for @usb_dev; NULL if the @usb_dev is being torn down.
359 * WARNING: referenced at the usb_hcd level, unlocked
360 *
361 * FIXME: move offline
362 */
wusbhc_get_by_usb_dev(struct usb_device * usb_dev)363 static inline struct wusbhc *wusbhc_get_by_usb_dev(struct usb_device *usb_dev)
364 {
365 struct wusbhc *wusbhc = NULL;
366 struct usb_hcd *usb_hcd;
367 if (usb_dev->devnum > 1 && !usb_dev->wusb) {
368 /* but root hubs */
369 dev_err(&usb_dev->dev, "devnum %d wusb %d\n", usb_dev->devnum,
370 usb_dev->wusb);
371 BUG_ON(usb_dev->devnum > 1 && !usb_dev->wusb);
372 }
373 usb_hcd = usb_hcd_get_by_usb_dev(usb_dev);
374 if (usb_hcd == NULL)
375 return NULL;
376 BUG_ON(usb_hcd->wireless == 0);
377 return wusbhc = usb_hcd_to_wusbhc(usb_hcd);
378 }
379
380
wusbhc_put(struct wusbhc * wusbhc)381 static inline void wusbhc_put(struct wusbhc *wusbhc)
382 {
383 usb_put_hcd(&wusbhc->usb_hcd);
384 }
385
386 int wusbhc_start(struct wusbhc *wusbhc);
387 void wusbhc_stop(struct wusbhc *wusbhc);
388 extern int wusbhc_chid_set(struct wusbhc *, const struct wusb_ckhdid *);
389
390 /* Device connect handling */
391 extern int wusbhc_devconnect_create(struct wusbhc *);
392 extern void wusbhc_devconnect_destroy(struct wusbhc *);
393 extern int wusbhc_devconnect_start(struct wusbhc *wusbhc);
394 extern void wusbhc_devconnect_stop(struct wusbhc *wusbhc);
395 extern void wusbhc_handle_dn(struct wusbhc *, u8 srcaddr,
396 struct wusb_dn_hdr *dn_hdr, size_t size);
397 extern void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port);
398 extern int wusb_usb_ncb(struct notifier_block *nb, unsigned long val,
399 void *priv);
400 extern int wusb_set_dev_addr(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
401 u8 addr);
402
403 /* Wireless USB fake Root Hub methods */
404 extern int wusbhc_rh_create(struct wusbhc *);
405 extern void wusbhc_rh_destroy(struct wusbhc *);
406
407 extern int wusbhc_rh_status_data(struct usb_hcd *, char *);
408 extern int wusbhc_rh_control(struct usb_hcd *, u16, u16, u16, char *, u16);
409 extern int wusbhc_rh_start_port_reset(struct usb_hcd *, unsigned);
410
411 /* MMC handling */
412 extern int wusbhc_mmcie_create(struct wusbhc *);
413 extern void wusbhc_mmcie_destroy(struct wusbhc *);
414 extern int wusbhc_mmcie_set(struct wusbhc *, u8 interval, u8 repeat_cnt,
415 struct wuie_hdr *);
416 extern void wusbhc_mmcie_rm(struct wusbhc *, struct wuie_hdr *);
417
418 /* Bandwidth reservation */
419 int wusbhc_rsv_establish(struct wusbhc *wusbhc);
420 void wusbhc_rsv_terminate(struct wusbhc *wusbhc);
421
422 /*
423 * I've always said
424 * I wanted a wedding in a church...
425 *
426 * but lately I've been thinking about
427 * the Botanical Gardens.
428 *
429 * We could do it by the tulips.
430 * It'll be beautiful
431 *
432 * --Security!
433 */
434 extern int wusb_dev_sec_add(struct wusbhc *, struct usb_device *,
435 struct wusb_dev *);
436 extern void wusb_dev_sec_rm(struct wusb_dev *) ;
437 extern int wusb_dev_4way_handshake(struct wusbhc *, struct wusb_dev *,
438 struct wusb_ckhdid *ck);
439 void wusbhc_gtk_rekey(struct wusbhc *wusbhc);
440 int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev);
441
442
443 /* WUSB Cluster ID handling */
444 extern u8 wusb_cluster_id_get(void);
445 extern void wusb_cluster_id_put(u8);
446
447 /*
448 * wusb_port_by_idx - return the port associated to a zero-based port index
449 *
450 * NOTE: valid without locking as long as wusbhc is referenced (as the
451 * number of ports doesn't change). The data pointed to has to
452 * be verified though :)
453 */
wusb_port_by_idx(struct wusbhc * wusbhc,u8 port_idx)454 static inline struct wusb_port *wusb_port_by_idx(struct wusbhc *wusbhc,
455 u8 port_idx)
456 {
457 return &wusbhc->port[port_idx];
458 }
459
460 /*
461 * wusb_port_no_to_idx - Convert port number (per usb_dev->portnum) to
462 * a port_idx.
463 *
464 * USB stack USB ports are 1 based!!
465 *
466 * NOTE: only valid for WUSB devices!!!
467 */
wusb_port_no_to_idx(u8 port_no)468 static inline u8 wusb_port_no_to_idx(u8 port_no)
469 {
470 return port_no - 1;
471 }
472
473 extern struct wusb_dev *__wusb_dev_get_by_usb_dev(struct wusbhc *,
474 struct usb_device *);
475
476 /*
477 * Return a referenced wusb_dev given a @usb_dev
478 *
479 * Returns NULL if the usb_dev is being torn down.
480 *
481 * FIXME: move offline
482 */
483 static inline
wusb_dev_get_by_usb_dev(struct usb_device * usb_dev)484 struct wusb_dev *wusb_dev_get_by_usb_dev(struct usb_device *usb_dev)
485 {
486 struct wusbhc *wusbhc;
487 struct wusb_dev *wusb_dev;
488 wusbhc = wusbhc_get_by_usb_dev(usb_dev);
489 if (wusbhc == NULL)
490 return NULL;
491 mutex_lock(&wusbhc->mutex);
492 wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, usb_dev);
493 mutex_unlock(&wusbhc->mutex);
494 wusbhc_put(wusbhc);
495 return wusb_dev;
496 }
497
498 /* Misc */
499
500 extern struct workqueue_struct *wusbd;
501 #endif /* #ifndef __WUSBHC_H__ */
502