wusb: remove unused #include <version.h>
[linux-2.6.git] / drivers / usb / host / hwa-hc.c
1 /*
2  * Host Wire Adapter:
3  * Driver glue, HWA-specific functions, bridges to WAHC and WUSBHC
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  *
23  * The HWA driver is a simple layer that forwards requests to the WAHC
24  * (Wire Adater Host Controller) or WUSBHC (Wireless USB Host
25  * Controller) layers.
26  *
27  * Host Wire Adapter is the 'WUSB 1.0 standard' name for Wireless-USB
28  * Host Controller that is connected to your system via USB (a USB
29  * dongle that implements a USB host...). There is also a Device Wired
30  * Adaptor, DWA (Wireless USB hub) that uses the same mechanism for
31  * transferring data (it is after all a USB host connected via
32  * Wireless USB), we have a common layer called Wire Adapter Host
33  * Controller that does all the hard work. The WUSBHC (Wireless USB
34  * Host Controller) is the part common to WUSB Host Controllers, the
35  * HWA and the PCI-based one, that is implemented following the WHCI
36  * spec. All these layers are implemented in ../wusbcore.
37  *
38  * The main functions are hwahc_op_urb_{en,de}queue(), that pass the
39  * job of converting a URB to a Wire Adapter
40  *
41  * Entry points:
42  *
43  *   hwahc_driver_*()   Driver initialization, registration and
44  *                      teardown.
45  *
46  *   hwahc_probe()      New device came up, create an instance for
47  *                      it [from device enumeration].
48  *
49  *   hwahc_disconnect() Remove device instance [from device
50  *                      enumeration].
51  *
52  *   [__]hwahc_op_*()   Host-Wire-Adaptor specific functions for
53  *                      starting/stopping/etc (some might be made also
54  *                      DWA).
55  */
56 #include <linux/kernel.h>
57 #include <linux/init.h>
58 #include <linux/module.h>
59 #include <linux/workqueue.h>
60 #include <linux/wait.h>
61 #include <linux/completion.h>
62 #include "../wusbcore/wa-hc.h"
63 #include "../wusbcore/wusbhc.h"
64
65 #define D_LOCAL 0
66 #include <linux/uwb/debug.h>
67
68 struct hwahc {
69         struct wusbhc wusbhc;   /* has to be 1st */
70         struct wahc wa;
71         u8 buffer[16];          /* for misc usb transactions */
72 };
73
74 /**
75  * FIXME should be wusbhc
76  *
77  * NOTE: we need to cache the Cluster ID because later...there is no
78  *       way to get it :)
79  */
80 static int __hwahc_set_cluster_id(struct hwahc *hwahc, u8 cluster_id)
81 {
82         int result;
83         struct wusbhc *wusbhc = &hwahc->wusbhc;
84         struct wahc *wa = &hwahc->wa;
85         struct device *dev = &wa->usb_iface->dev;
86
87         result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
88                         WUSB_REQ_SET_CLUSTER_ID,
89                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
90                         cluster_id,
91                         wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
92                         NULL, 0, 1000 /* FIXME: arbitrary */);
93         if (result < 0)
94                 dev_err(dev, "Cannot set WUSB Cluster ID to 0x%02x: %d\n",
95                         cluster_id, result);
96         else
97                 wusbhc->cluster_id = cluster_id;
98         dev_info(dev, "Wireless USB Cluster ID set to 0x%02x\n", cluster_id);
99         return result;
100 }
101
102 static int __hwahc_op_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots)
103 {
104         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
105         struct wahc *wa = &hwahc->wa;
106
107         return usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
108                         WUSB_REQ_SET_NUM_DNTS,
109                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
110                         interval << 8 | slots,
111                         wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
112                         NULL, 0, 1000 /* FIXME: arbitrary */);
113 }
114
115 /*
116  * Reset a WUSB host controller and wait for it to complete doing it.
117  *
118  * @usb_hcd:    Pointer to WUSB Host Controller instance.
119  *
120  */
121 static int hwahc_op_reset(struct usb_hcd *usb_hcd)
122 {
123         int result;
124         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
125         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
126         struct device *dev = &hwahc->wa.usb_iface->dev;
127
128         d_fnstart(4, dev, "(hwahc %p)\n", hwahc);
129         mutex_lock(&wusbhc->mutex);
130         wa_nep_disarm(&hwahc->wa);
131         result = __wa_set_feature(&hwahc->wa, WA_RESET);
132         if (result < 0) {
133                 dev_err(dev, "error commanding HC to reset: %d\n", result);
134                 goto error_unlock;
135         }
136         d_printf(3, dev, "reset: waiting for device to change state\n");
137         result = __wa_wait_status(&hwahc->wa, WA_STATUS_RESETTING, 0);
138         if (result < 0) {
139                 dev_err(dev, "error waiting for HC to reset: %d\n", result);
140                 goto error_unlock;
141         }
142 error_unlock:
143         mutex_unlock(&wusbhc->mutex);
144         d_fnend(4, dev, "(hwahc %p) = %d\n", hwahc, result);
145         return result;
146 }
147
148 /*
149  * FIXME: break this function up
150  */
151 static int hwahc_op_start(struct usb_hcd *usb_hcd)
152 {
153         u8 addr;
154         int result;
155         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
156         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
157         struct device *dev = &hwahc->wa.usb_iface->dev;
158
159         /* Set up a Host Info WUSB Information Element */
160         d_fnstart(4, dev, "(hwahc %p)\n", hwahc);
161         result = -ENOSPC;
162         mutex_lock(&wusbhc->mutex);
163         /* Start the numbering from the top so that the bottom
164          * range of the unauth addr space is used for devices,
165          * the top for HCs; use 0xfe - RC# */
166         addr = wusb_cluster_id_get();
167         if (addr == 0)
168                 goto error_cluster_id_get;
169         result = __hwahc_set_cluster_id(hwahc, addr);
170         if (result < 0)
171                 goto error_set_cluster_id;
172
173         usb_hcd->uses_new_polling = 1;
174         usb_hcd->poll_rh = 1;
175         usb_hcd->state = HC_STATE_RUNNING;
176         result = 0;
177 out:
178         mutex_unlock(&wusbhc->mutex);
179         d_fnend(4, dev, "(hwahc %p) = %d\n", hwahc, result);
180         return result;
181
182 error_set_cluster_id:
183         wusb_cluster_id_put(wusbhc->cluster_id);
184 error_cluster_id_get:
185         goto out;
186
187 }
188
189 static int hwahc_op_suspend(struct usb_hcd *usb_hcd, pm_message_t msg)
190 {
191         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
192         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
193         dev_err(wusbhc->dev, "%s (%p [%p], 0x%lx) UNIMPLEMENTED\n", __func__,
194                 usb_hcd, hwahc, *(unsigned long *) &msg);
195         return -ENOSYS;
196 }
197
198 static int hwahc_op_resume(struct usb_hcd *usb_hcd)
199 {
200         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
201         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
202
203         dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
204                 usb_hcd, hwahc);
205         return -ENOSYS;
206 }
207
208 /*
209  * No need to abort pipes, as when this is called, all the children
210  * has been disconnected and that has done it [through
211  * usb_disable_interface() -> usb_disable_endpoint() ->
212  * hwahc_op_ep_disable() - >rpipe_ep_disable()].
213  */
214 static void hwahc_op_stop(struct usb_hcd *usb_hcd)
215 {
216         int result;
217         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
218         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
219         struct wahc *wa = &hwahc->wa;
220         struct device *dev = &wa->usb_iface->dev;
221
222         d_fnstart(4, dev, "(hwahc %p)\n", hwahc);
223         mutex_lock(&wusbhc->mutex);
224         wusbhc_stop(wusbhc);
225         wusb_cluster_id_put(wusbhc->cluster_id);
226         mutex_unlock(&wusbhc->mutex);
227         d_fnend(4, dev, "(hwahc %p) = %d\n", hwahc, result);
228         return;
229 }
230
231 static int hwahc_op_get_frame_number(struct usb_hcd *usb_hcd)
232 {
233         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
234         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
235
236         dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
237                 usb_hcd, hwahc);
238         return -ENOSYS;
239 }
240
241 static int hwahc_op_urb_enqueue(struct usb_hcd *usb_hcd, struct urb *urb,
242                                 gfp_t gfp)
243 {
244         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
245         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
246
247         return wa_urb_enqueue(&hwahc->wa, urb->ep, urb, gfp);
248 }
249
250 static int hwahc_op_urb_dequeue(struct usb_hcd *usb_hcd, struct urb *urb,
251                                 int status)
252 {
253         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
254         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
255
256         return wa_urb_dequeue(&hwahc->wa, urb);
257 }
258
259 /*
260  * Release resources allocated for an endpoint
261  *
262  * If there is an associated rpipe to this endpoint, go ahead and put it.
263  */
264 static void hwahc_op_endpoint_disable(struct usb_hcd *usb_hcd,
265                                       struct usb_host_endpoint *ep)
266 {
267         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
268         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
269
270         rpipe_ep_disable(&hwahc->wa, ep);
271 }
272
273 static int __hwahc_op_wusbhc_start(struct wusbhc *wusbhc)
274 {
275         int result;
276         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
277         struct device *dev = &hwahc->wa.usb_iface->dev;
278
279         result = __wa_set_feature(&hwahc->wa, WA_ENABLE);
280         if (result < 0) {
281                 dev_err(dev, "error commanding HC to start: %d\n", result);
282                 goto error_stop;
283         }
284         result = __wa_wait_status(&hwahc->wa, WA_ENABLE, WA_ENABLE);
285         if (result < 0) {
286                 dev_err(dev, "error waiting for HC to start: %d\n", result);
287                 goto error_stop;
288         }
289         result = wa_nep_arm(&hwahc->wa, GFP_KERNEL);
290         if (result < 0) {
291                 dev_err(dev, "cannot listen to notifications: %d\n", result);
292                 goto error_stop;
293         }
294         return result;
295
296 error_stop:
297         __wa_clear_feature(&hwahc->wa, WA_ENABLE);
298         return result;
299 }
300
301 static void __hwahc_op_wusbhc_stop(struct wusbhc *wusbhc, int delay)
302 {
303         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
304         struct wahc *wa = &hwahc->wa;
305         u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber;
306         int ret;
307
308         ret = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
309                               WUSB_REQ_CHAN_STOP,
310                               USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
311                               delay * 1000,
312                               iface_no,
313                               NULL, 0, 1000 /* FIXME: arbitrary */);
314         if (ret == 0)
315                 msleep(delay);
316
317         wa_nep_disarm(&hwahc->wa);
318         __wa_stop(&hwahc->wa);
319 }
320
321 /*
322  * Set the UWB MAS allocation for the WUSB cluster
323  *
324  * @stream_index: stream to use (-1 for cancelling the allocation)
325  * @mas: mas bitmap to use
326  */
327 static int __hwahc_op_bwa_set(struct wusbhc *wusbhc, s8 stream_index,
328                               const struct uwb_mas_bm *mas)
329 {
330         int result;
331         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
332         struct wahc *wa = &hwahc->wa;
333         struct device *dev = &wa->usb_iface->dev;
334         u8 mas_le[UWB_NUM_MAS/8];
335
336         /* Set the stream index */
337         result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
338                         WUSB_REQ_SET_STREAM_IDX,
339                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
340                         stream_index,
341                         wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
342                         NULL, 0, 1000 /* FIXME: arbitrary */);
343         if (result < 0) {
344                 dev_err(dev, "Cannot set WUSB stream index: %d\n", result);
345                 goto out;
346         }
347         uwb_mas_bm_copy_le(mas_le, mas);
348         /* Set the MAS allocation */
349         result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
350                         WUSB_REQ_SET_WUSB_MAS,
351                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
352                         0, wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
353                         mas_le, 32, 1000 /* FIXME: arbitrary */);
354         if (result < 0)
355                 dev_err(dev, "Cannot set WUSB MAS allocation: %d\n", result);
356 out:
357         return result;
358 }
359
360 /*
361  * Add an IE to the host's MMC
362  *
363  * @interval:    See WUSB1.0[8.5.3.1]
364  * @repeat_cnt:  See WUSB1.0[8.5.3.1]
365  * @handle:      See WUSB1.0[8.5.3.1]
366  * @wuie:        Pointer to the header of the WUSB IE data to add.
367  *               MUST BE allocated in a kmalloc buffer (no stack or
368  *               vmalloc).
369  *
370  * NOTE: the format of the WUSB IEs for MMCs are different to the
371  *       normal MBOA MAC IEs (IE Id + Length in MBOA MAC vs. Length +
372  *       Id in WUSB IEs). Standards...you gotta love'em.
373  */
374 static int __hwahc_op_mmcie_add(struct wusbhc *wusbhc, u8 interval,
375                                 u8 repeat_cnt, u8 handle,
376                                 struct wuie_hdr *wuie)
377 {
378         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
379         struct wahc *wa = &hwahc->wa;
380         u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber;
381
382         return usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
383                         WUSB_REQ_ADD_MMC_IE,
384                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
385                         interval << 8 | repeat_cnt,
386                         handle << 8 | iface_no,
387                         wuie, wuie->bLength, 1000 /* FIXME: arbitrary */);
388 }
389
390 /*
391  * Remove an IE to the host's MMC
392  *
393  * @handle:      See WUSB1.0[8.5.3.1]
394  */
395 static int __hwahc_op_mmcie_rm(struct wusbhc *wusbhc, u8 handle)
396 {
397         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
398         struct wahc *wa = &hwahc->wa;
399         u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber;
400         return usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
401                         WUSB_REQ_REMOVE_MMC_IE,
402                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
403                         0, handle << 8 | iface_no,
404                         NULL, 0, 1000 /* FIXME: arbitrary */);
405 }
406
407 /*
408  * Update device information for a given fake port
409  *
410  * @port_idx: Fake port to which device is connected (wusbhc index, not
411  *            USB port number).
412  */
413 static int __hwahc_op_dev_info_set(struct wusbhc *wusbhc,
414                                    struct wusb_dev *wusb_dev)
415 {
416         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
417         struct wahc *wa = &hwahc->wa;
418         u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber;
419         struct hwa_dev_info *dev_info;
420         int ret;
421
422         /* fill out the Device Info buffer and send it */
423         dev_info = kzalloc(sizeof(struct hwa_dev_info), GFP_KERNEL);
424         if (!dev_info)
425                 return -ENOMEM;
426         uwb_mas_bm_copy_le(dev_info->bmDeviceAvailability,
427                            &wusb_dev->availability);
428         dev_info->bDeviceAddress = wusb_dev->addr;
429
430         /*
431          * If the descriptors haven't been read yet, use a default PHY
432          * rate of 53.3 Mbit/s only.  The correct value will be used
433          * when this will be called again as part of the
434          * authentication process (which occurs after the descriptors
435          * have been read).
436          */
437         if (wusb_dev->wusb_cap_descr)
438                 dev_info->wPHYRates = wusb_dev->wusb_cap_descr->wPHYRates;
439         else
440                 dev_info->wPHYRates = cpu_to_le16(USB_WIRELESS_PHY_53);
441
442         ret = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
443                         WUSB_REQ_SET_DEV_INFO,
444                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
445                         0, wusb_dev->port_idx << 8 | iface_no,
446                         dev_info, sizeof(struct hwa_dev_info),
447                         1000 /* FIXME: arbitrary */);
448         kfree(dev_info);
449         return ret;
450 }
451
452 /*
453  * Set host's idea of which encryption (and key) method to use when
454  * talking to ad evice on a given port.
455  *
456  * If key is NULL, it means disable encryption for that "virtual port"
457  * (used when we disconnect).
458  */
459 static int __hwahc_dev_set_key(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
460                                const void *key, size_t key_size,
461                                u8 key_idx)
462 {
463         int result = -ENOMEM;
464         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
465         struct wahc *wa = &hwahc->wa;
466         u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber;
467         struct usb_key_descriptor *keyd;
468         size_t keyd_len;
469
470         keyd_len = sizeof(*keyd) + key_size;
471         keyd = kzalloc(keyd_len, GFP_KERNEL);
472         if (keyd == NULL)
473                 return -ENOMEM;
474
475         keyd->bLength = keyd_len;
476         keyd->bDescriptorType = USB_DT_KEY;
477         keyd->tTKID[0] = (tkid >>  0) & 0xff;
478         keyd->tTKID[1] = (tkid >>  8) & 0xff;
479         keyd->tTKID[2] = (tkid >> 16) & 0xff;
480         memcpy(keyd->bKeyData, key, key_size);
481
482         result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
483                         USB_REQ_SET_DESCRIPTOR,
484                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
485                         USB_DT_KEY << 8 | key_idx,
486                         port_idx << 8 | iface_no,
487                         keyd, keyd_len, 1000 /* FIXME: arbitrary */);
488
489         memset(keyd, 0, sizeof(*keyd)); /* clear keys etc. */
490         kfree(keyd);
491         return result;
492 }
493
494 /*
495  * Set host's idea of which encryption (and key) method to use when
496  * talking to ad evice on a given port.
497  *
498  * If key is NULL, it means disable encryption for that "virtual port"
499  * (used when we disconnect).
500  */
501 static int __hwahc_op_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
502                               const void *key, size_t key_size)
503 {
504         int result = -ENOMEM;
505         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
506         struct wahc *wa = &hwahc->wa;
507         u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber;
508         u8 encryption_value;
509
510         /* Tell the host which key to use to talk to the device */
511         if (key) {
512                 u8 key_idx = wusb_key_index(0, WUSB_KEY_INDEX_TYPE_PTK,
513                                             WUSB_KEY_INDEX_ORIGINATOR_HOST);
514
515                 result = __hwahc_dev_set_key(wusbhc, port_idx, tkid,
516                                              key, key_size, key_idx);
517                 if (result < 0)
518                         goto error_set_key;
519                 encryption_value = wusbhc->ccm1_etd->bEncryptionValue;
520         } else {
521                 /* FIXME: this should come from wusbhc->etd[UNSECURE].value */
522                 encryption_value = 0;
523         }
524
525         /* Set the encryption type for commmunicating with the device */
526         result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
527                         USB_REQ_SET_ENCRYPTION,
528                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
529                         encryption_value, port_idx << 8 | iface_no,
530                         NULL, 0, 1000 /* FIXME: arbitrary */);
531         if (result < 0)
532                 dev_err(wusbhc->dev, "Can't set host's WUSB encryption for "
533                         "port index %u to %s (value %d): %d\n", port_idx,
534                         wusb_et_name(wusbhc->ccm1_etd->bEncryptionType),
535                         wusbhc->ccm1_etd->bEncryptionValue, result);
536 error_set_key:
537         return result;
538 }
539
540 /*
541  * Set host's GTK key
542  */
543 static int __hwahc_op_set_gtk(struct wusbhc *wusbhc, u32 tkid,
544                               const void *key, size_t key_size)
545 {
546         u8 key_idx = wusb_key_index(0, WUSB_KEY_INDEX_TYPE_GTK,
547                                     WUSB_KEY_INDEX_ORIGINATOR_HOST);
548
549         return __hwahc_dev_set_key(wusbhc, 0, tkid, key, key_size, key_idx);
550 }
551
552 /*
553  * Get the Wire Adapter class-specific descriptor
554  *
555  * NOTE: this descriptor comes with the big bundled configuration
556  *       descriptor that includes the interfaces' and endpoints', so
557  *       we just look for it in the cached copy kept by the USB stack.
558  *
559  * NOTE2: We convert LE fields to CPU order.
560  */
561 static int wa_fill_descr(struct wahc *wa)
562 {
563         int result;
564         struct device *dev = &wa->usb_iface->dev;
565         char *itr;
566         struct usb_device *usb_dev = wa->usb_dev;
567         struct usb_descriptor_header *hdr;
568         struct usb_wa_descriptor *wa_descr;
569         size_t itr_size, actconfig_idx;
570
571         actconfig_idx = (usb_dev->actconfig - usb_dev->config) /
572                         sizeof(usb_dev->config[0]);
573         itr = usb_dev->rawdescriptors[actconfig_idx];
574         itr_size = le16_to_cpu(usb_dev->actconfig->desc.wTotalLength);
575         while (itr_size >= sizeof(*hdr)) {
576                 hdr = (struct usb_descriptor_header *) itr;
577                 d_printf(3, dev, "Extra device descriptor: "
578                          "type %02x/%u bytes @ %zu (%zu left)\n",
579                          hdr->bDescriptorType, hdr->bLength,
580                          (itr - usb_dev->rawdescriptors[actconfig_idx]),
581                          itr_size);
582                 if (hdr->bDescriptorType == USB_DT_WIRE_ADAPTER)
583                         goto found;
584                 itr += hdr->bLength;
585                 itr_size -= hdr->bLength;
586         }
587         dev_err(dev, "cannot find Wire Adapter Class descriptor\n");
588         return -ENODEV;
589
590 found:
591         result = -EINVAL;
592         if (hdr->bLength > itr_size) {  /* is it available? */
593                 dev_err(dev, "incomplete Wire Adapter Class descriptor "
594                         "(%zu bytes left, %u needed)\n",
595                         itr_size, hdr->bLength);
596                 goto error;
597         }
598         if (hdr->bLength < sizeof(*wa->wa_descr)) {
599                 dev_err(dev, "short Wire Adapter Class descriptor\n");
600                 goto error;
601         }
602         wa->wa_descr = wa_descr = (struct usb_wa_descriptor *) hdr;
603         /* Make LE fields CPU order */
604         wa_descr->bcdWAVersion = le16_to_cpu(wa_descr->bcdWAVersion);
605         wa_descr->wNumRPipes = le16_to_cpu(wa_descr->wNumRPipes);
606         wa_descr->wRPipeMaxBlock = le16_to_cpu(wa_descr->wRPipeMaxBlock);
607         if (wa_descr->bcdWAVersion > 0x0100)
608                 dev_warn(dev, "Wire Adapter v%d.%d newer than groked v1.0\n",
609                          wa_descr->bcdWAVersion & 0xff00 >> 8,
610                          wa_descr->bcdWAVersion & 0x00ff);
611         result = 0;
612 error:
613         return result;
614 }
615
616 static struct hc_driver hwahc_hc_driver = {
617         .description = "hwa-hcd",
618         .product_desc = "Wireless USB HWA host controller",
619         .hcd_priv_size = sizeof(struct hwahc) - sizeof(struct usb_hcd),
620         .irq = NULL,                    /* FIXME */
621         .flags = HCD_USB2,              /* FIXME */
622         .reset = hwahc_op_reset,
623         .start = hwahc_op_start,
624         .pci_suspend = hwahc_op_suspend,
625         .pci_resume = hwahc_op_resume,
626         .stop = hwahc_op_stop,
627         .get_frame_number = hwahc_op_get_frame_number,
628         .urb_enqueue = hwahc_op_urb_enqueue,
629         .urb_dequeue = hwahc_op_urb_dequeue,
630         .endpoint_disable = hwahc_op_endpoint_disable,
631
632         .hub_status_data = wusbhc_rh_status_data,
633         .hub_control = wusbhc_rh_control,
634         .bus_suspend = wusbhc_rh_suspend,
635         .bus_resume = wusbhc_rh_resume,
636         .start_port_reset = wusbhc_rh_start_port_reset,
637 };
638
639 static int hwahc_security_create(struct hwahc *hwahc)
640 {
641         int result;
642         struct wusbhc *wusbhc = &hwahc->wusbhc;
643         struct usb_device *usb_dev = hwahc->wa.usb_dev;
644         struct device *dev = &usb_dev->dev;
645         struct usb_security_descriptor *secd;
646         struct usb_encryption_descriptor *etd;
647         void *itr, *top;
648         size_t itr_size, needed, bytes;
649         u8 index;
650         char buf[64];
651
652         /* Find the host's security descriptors in the config descr bundle */
653         index = (usb_dev->actconfig - usb_dev->config) /
654                 sizeof(usb_dev->config[0]);
655         itr = usb_dev->rawdescriptors[index];
656         itr_size = le16_to_cpu(usb_dev->actconfig->desc.wTotalLength);
657         top = itr + itr_size;
658         result = __usb_get_extra_descriptor(usb_dev->rawdescriptors[index],
659                         le16_to_cpu(usb_dev->actconfig->desc.wTotalLength),
660                         USB_DT_SECURITY, (void **) &secd);
661         if (result == -1) {
662                 dev_warn(dev, "BUG? WUSB host has no security descriptors\n");
663                 return 0;
664         }
665         needed = sizeof(*secd);
666         if (top - (void *)secd < needed) {
667                 dev_err(dev, "BUG? Not enough data to process security "
668                         "descriptor header (%zu bytes left vs %zu needed)\n",
669                         top - (void *) secd, needed);
670                 return 0;
671         }
672         needed = le16_to_cpu(secd->wTotalLength);
673         if (top - (void *)secd < needed) {
674                 dev_err(dev, "BUG? Not enough data to process security "
675                         "descriptors (%zu bytes left vs %zu needed)\n",
676                         top - (void *) secd, needed);
677                 return 0;
678         }
679         /* Walk over the sec descriptors and store CCM1's on wusbhc */
680         itr = (void *) secd + sizeof(*secd);
681         top = (void *) secd + le16_to_cpu(secd->wTotalLength);
682         index = 0;
683         bytes = 0;
684         while (itr < top) {
685                 etd = itr;
686                 if (top - itr < sizeof(*etd)) {
687                         dev_err(dev, "BUG: bad host security descriptor; "
688                                 "not enough data (%zu vs %zu left)\n",
689                                 top - itr, sizeof(*etd));
690                         break;
691                 }
692                 if (etd->bLength < sizeof(*etd)) {
693                         dev_err(dev, "BUG: bad host encryption descriptor; "
694                                 "descriptor is too short "
695                                 "(%zu vs %zu needed)\n",
696                                 (size_t)etd->bLength, sizeof(*etd));
697                         break;
698                 }
699                 itr += etd->bLength;
700                 bytes += snprintf(buf + bytes, sizeof(buf) - bytes,
701                                   "%s (0x%02x) ",
702                                   wusb_et_name(etd->bEncryptionType),
703                                   etd->bEncryptionValue);
704                 wusbhc->ccm1_etd = etd;
705         }
706         dev_info(dev, "supported encryption types: %s\n", buf);
707         if (wusbhc->ccm1_etd == NULL) {
708                 dev_err(dev, "E: host doesn't support CCM-1 crypto\n");
709                 return 0;
710         }
711         /* Pretty print what we support */
712         return 0;
713 }
714
715 static void hwahc_security_release(struct hwahc *hwahc)
716 {
717         /* nothing to do here so far... */
718 }
719
720 static int hwahc_create(struct hwahc *hwahc, struct usb_interface *iface)
721 {
722         int result;
723         struct device *dev = &iface->dev;
724         struct wusbhc *wusbhc = &hwahc->wusbhc;
725         struct wahc *wa = &hwahc->wa;
726         struct usb_device *usb_dev = interface_to_usbdev(iface);
727
728         wa->usb_dev = usb_get_dev(usb_dev);     /* bind the USB device */
729         wa->usb_iface = usb_get_intf(iface);
730         wusbhc->dev = dev;
731         wusbhc->uwb_rc = uwb_rc_get_by_grandpa(iface->dev.parent);
732         if (wusbhc->uwb_rc == NULL) {
733                 result = -ENODEV;
734                 dev_err(dev, "Cannot get associated UWB Host Controller\n");
735                 goto error_rc_get;
736         }
737         result = wa_fill_descr(wa);     /* Get the device descriptor */
738         if (result < 0)
739                 goto error_fill_descriptor;
740         if (wa->wa_descr->bNumPorts > USB_MAXCHILDREN) {
741                 dev_err(dev, "FIXME: USB_MAXCHILDREN too low for WUSB "
742                         "adapter (%u ports)\n", wa->wa_descr->bNumPorts);
743                 wusbhc->ports_max = USB_MAXCHILDREN;
744         } else {
745                 wusbhc->ports_max = wa->wa_descr->bNumPorts;
746         }
747         wusbhc->mmcies_max = wa->wa_descr->bNumMMCIEs;
748         wusbhc->start = __hwahc_op_wusbhc_start;
749         wusbhc->stop = __hwahc_op_wusbhc_stop;
750         wusbhc->mmcie_add = __hwahc_op_mmcie_add;
751         wusbhc->mmcie_rm = __hwahc_op_mmcie_rm;
752         wusbhc->dev_info_set = __hwahc_op_dev_info_set;
753         wusbhc->bwa_set = __hwahc_op_bwa_set;
754         wusbhc->set_num_dnts = __hwahc_op_set_num_dnts;
755         wusbhc->set_ptk = __hwahc_op_set_ptk;
756         wusbhc->set_gtk = __hwahc_op_set_gtk;
757         result = hwahc_security_create(hwahc);
758         if (result < 0) {
759                 dev_err(dev, "Can't initialize security: %d\n", result);
760                 goto error_security_create;
761         }
762         wa->wusb = wusbhc;      /* FIXME: ugly, need to fix */
763         result = wusbhc_create(&hwahc->wusbhc);
764         if (result < 0) {
765                 dev_err(dev, "Can't create WUSB HC structures: %d\n", result);
766                 goto error_wusbhc_create;
767         }
768         result = wa_create(&hwahc->wa, iface);
769         if (result < 0)
770                 goto error_wa_create;
771         return 0;
772
773 error_wa_create:
774         wusbhc_destroy(&hwahc->wusbhc);
775 error_wusbhc_create:
776         /* WA Descr fill allocs no resources */
777 error_security_create:
778 error_fill_descriptor:
779         uwb_rc_put(wusbhc->uwb_rc);
780 error_rc_get:
781         usb_put_intf(iface);
782         usb_put_dev(usb_dev);
783         return result;
784 }
785
786 static void hwahc_destroy(struct hwahc *hwahc)
787 {
788         struct wusbhc *wusbhc = &hwahc->wusbhc;
789
790         d_fnstart(1, NULL, "(hwahc %p)\n", hwahc);
791         mutex_lock(&wusbhc->mutex);
792         __wa_destroy(&hwahc->wa);
793         wusbhc_destroy(&hwahc->wusbhc);
794         hwahc_security_release(hwahc);
795         hwahc->wusbhc.dev = NULL;
796         uwb_rc_put(wusbhc->uwb_rc);
797         usb_put_intf(hwahc->wa.usb_iface);
798         usb_put_dev(hwahc->wa.usb_dev);
799         mutex_unlock(&wusbhc->mutex);
800         d_fnend(1, NULL, "(hwahc %p) = void\n", hwahc);
801 }
802
803 static void hwahc_init(struct hwahc *hwahc)
804 {
805         wa_init(&hwahc->wa);
806 }
807
808 static int hwahc_probe(struct usb_interface *usb_iface,
809                        const struct usb_device_id *id)
810 {
811         int result;
812         struct usb_hcd *usb_hcd;
813         struct wusbhc *wusbhc;
814         struct hwahc *hwahc;
815         struct device *dev = &usb_iface->dev;
816
817         d_fnstart(4, dev, "(%p, %p)\n", usb_iface, id);
818         result = -ENOMEM;
819         usb_hcd = usb_create_hcd(&hwahc_hc_driver, &usb_iface->dev, "wusb-hwa");
820         if (usb_hcd == NULL) {
821                 dev_err(dev, "unable to allocate instance\n");
822                 goto error_alloc;
823         }
824         usb_hcd->wireless = 1;
825         usb_hcd->flags |= HCD_FLAG_SAW_IRQ;
826         wusbhc = usb_hcd_to_wusbhc(usb_hcd);
827         hwahc = container_of(wusbhc, struct hwahc, wusbhc);
828         hwahc_init(hwahc);
829         result = hwahc_create(hwahc, usb_iface);
830         if (result < 0) {
831                 dev_err(dev, "Cannot initialize internals: %d\n", result);
832                 goto error_hwahc_create;
833         }
834         result = usb_add_hcd(usb_hcd, 0, 0);
835         if (result < 0) {
836                 dev_err(dev, "Cannot add HCD: %d\n", result);
837                 goto error_add_hcd;
838         }
839         result = wusbhc_b_create(&hwahc->wusbhc);
840         if (result < 0) {
841                 dev_err(dev, "Cannot setup phase B of WUSBHC: %d\n", result);
842                 goto error_wusbhc_b_create;
843         }
844         d_fnend(4, dev, "(%p, %p) = 0\n", usb_iface, id);
845         return 0;
846
847 error_wusbhc_b_create:
848         usb_remove_hcd(usb_hcd);
849 error_add_hcd:
850         hwahc_destroy(hwahc);
851 error_hwahc_create:
852         usb_put_hcd(usb_hcd);
853 error_alloc:
854         d_fnend(4, dev, "(%p, %p) = %d\n", usb_iface, id, result);
855         return result;
856 }
857
858 static void hwahc_disconnect(struct usb_interface *usb_iface)
859 {
860         struct usb_hcd *usb_hcd;
861         struct wusbhc *wusbhc;
862         struct hwahc *hwahc;
863
864         usb_hcd = usb_get_intfdata(usb_iface);
865         wusbhc = usb_hcd_to_wusbhc(usb_hcd);
866         hwahc = container_of(wusbhc, struct hwahc, wusbhc);
867
868         d_fnstart(1, NULL, "(hwahc %p [usb_iface %p])\n", hwahc, usb_iface);
869         wusbhc_b_destroy(&hwahc->wusbhc);
870         usb_remove_hcd(usb_hcd);
871         hwahc_destroy(hwahc);
872         usb_put_hcd(usb_hcd);
873         d_fnend(1, NULL, "(hwahc %p [usb_iface %p]) = void\n", hwahc,
874                 usb_iface);
875 }
876
877 /** USB device ID's that we handle */
878 static struct usb_device_id hwahc_id_table[] = {
879         /* FIXME: use class labels for this */
880         { USB_INTERFACE_INFO(0xe0, 0x02, 0x01), },
881         {},
882 };
883 MODULE_DEVICE_TABLE(usb, hwahc_id_table);
884
885 static struct usb_driver hwahc_driver = {
886         .name =         "hwa-hc",
887         .probe =        hwahc_probe,
888         .disconnect =   hwahc_disconnect,
889         .id_table =     hwahc_id_table,
890 };
891
892 static int __init hwahc_driver_init(void)
893 {
894         int result;
895         result = usb_register(&hwahc_driver);
896         if (result < 0) {
897                 printk(KERN_ERR "WA-CDS: Cannot register USB driver: %d\n",
898                        result);
899                 goto error_usb_register;
900         }
901         return 0;
902
903 error_usb_register:
904         return result;
905
906 }
907 module_init(hwahc_driver_init);
908
909 static void __exit hwahc_driver_exit(void)
910 {
911         usb_deregister(&hwahc_driver);
912 }
913 module_exit(hwahc_driver_exit);
914
915
916 MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>");
917 MODULE_DESCRIPTION("Host Wired Adapter USB Host Control Driver");
918 MODULE_LICENSE("GPL");