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