Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us