kernel/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");