drivers/usb/wusbcore/cbaf.c

   1 /*
   2  * Wireless USB - Cable Based Association
   3  *
   4  *
   5  * Copyright (C) 2006 Intel Corporation
   6  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   7  * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License version
  11  * 2 as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21  * 02110-1301, USA.
  22  *
  23  *
  24  * WUSB devices have to be paired (associated in WUSB lingo) so
  25  * that they can connect to the system.
  26  *
  27  * One way of pairing is using CBA-Cable Based Association. First
  28  * time you plug the device with a cable, association is done between
  29  * host and device and subsequent times, you can connect wirelessly
  30  * without having to associate again. That's the idea.
  31  *
  32  * This driver does nothing Earth shattering. It just provides an
  33  * interface to chat with the wire-connected device so we can get a
  34  * CDID (device ID) that might have been previously associated to a
  35  * CHID (host ID) and to set up a new <CHID,CDID,CK> triplet
  36  * (connection context), with the CK being the secret, or connection
  37  * key. This is the pairing data.
  38  *
  39  * When a device with the CBA capability connects, the probe routine
  40  * just creates a bunch of sysfs files that a user space enumeration
  41  * manager uses to allow it to connect wirelessly to the system or not.
  42  *
  43  * The process goes like this:
  44  *
  45  * 1. Device plugs, cbaf is loaded, notifications happen.
  46  *
  47  * 2. The connection manager (CM) sees a device with CBAF capability
  48  *    (the wusb_chid etc. files in /sys/devices/blah/OURDEVICE).
  49  *
  50  * 3. The CM writes the host name, supported band groups, and the CHID
  51  *    (host ID) into the wusb_host_name, wusb_host_band_groups and
  52  *    wusb_chid files. These get sent to the device and the CDID (if
  53  *    any) for this host is requested.
  54  *
  55  * 4. The CM can verify that the device's supported band groups
  56  *    (wusb_device_band_groups) are compatible with the host.
  57  *
  58  * 5. The CM reads the wusb_cdid file.
  59  *
  60  * 6. The CM looks up its database
  61  *
  62  * 6.1 If it has a matching CHID,CDID entry, the device has been
  63  *     authorized before (paired) and nothing further needs to be
  64  *     done.
  65  *
  66  * 6.2 If the CDID is zero (or the CM doesn't find a matching CDID in
  67  *     its database), the device is assumed to be not known.  The CM
  68  *     may associate the host with device by: writing a randomly
  69  *     generated CDID to wusb_cdid and then a random CK to wusb_ck
  70  *     (this uploads the new CC to the device).
  71  *
  72  *     CMD may choose to prompt the user before associating with a new
  73  *     device.
  74  *
  75  * 7. Device is unplugged.
  76  *
  77  * When the device tries to connect wirelessly, it will present its
  78  * CDID to the WUSB host controller.  The CM will query the
  79  * database. If the CHID/CDID pair found, it will (with a 4-way
  80  * handshake) challenge the device to demonstrate it has the CK secret
  81  * key (from our database) without actually exchanging it. Once
  82  * satisfied, crypto keys are derived from the CK, the device is
  83  * connected and all communication is encrypted.
  84  *
  85  * References:
  86  *   [WUSB-AM] Association Models Supplement to the Certified Wireless
  87  *             Universal Serial Bus Specification, version 1.0.
  88  */
  89 #include <linux/module.h>
  90 #include <linux/ctype.h>
  91 #include <linux/usb.h>
  92 #include <linux/interrupt.h>
  93 #include <linux/delay.h>
  94 #include <linux/random.h>
  95 #include <linux/slab.h>
  96 #include <linux/mutex.h>
  97 #include <linux/uwb.h>
  98 #include <linux/usb/wusb.h>
  99 #include <linux/usb/association.h>
 100
 101 #define CBA_NAME_LEN 0x40 /* [WUSB-AM] table 4-7 */
 102
 103 /* An instance of a Cable-Based-Association-Framework device */
 104 struct cbaf {
 105         struct usb_device *usb_dev;
 106         struct usb_interface *usb_iface;
 107         void *buffer;
 108         size_t buffer_size;
 109
 110         struct wusb_ckhdid chid;
 111         char host_name[CBA_NAME_LEN];
 112         u16 host_band_groups;
 113
 114         struct wusb_ckhdid cdid;
 115         char device_name[CBA_NAME_LEN];
 116         u16 device_band_groups;
 117
 118         struct wusb_ckhdid ck;
 119 };
 120
 121 /*
 122  * Verify that a CBAF USB-interface has what we need
 123  *
 124  * According to [WUSB-AM], CBA devices should provide at least two
 125  * interfaces:
 126  *  - RETRIEVE_HOST_INFO
 127  *  - ASSOCIATE
 128  *
 129  * If the device doesn't provide these interfaces, we do not know how
 130  * to deal with it.
 131  */
 132 static int cbaf_check(struct cbaf *cbaf)
 133 {
 134         int result;
 135         struct device *dev = &cbaf->usb_iface->dev;
 136         struct wusb_cbaf_assoc_info *assoc_info;
 137         struct wusb_cbaf_assoc_request *assoc_request;
 138         size_t assoc_size;
 139         void *itr, *top;
 140         int ar_rhi = 0, ar_assoc = 0;
 141
 142         result = usb_control_msg(
 143                 cbaf->usb_dev, usb_rcvctrlpipe(cbaf->usb_dev, 0),
 144                 CBAF_REQ_GET_ASSOCIATION_INFORMATION,
 145                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 146                 0, cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
 147                 cbaf->buffer, cbaf->buffer_size, USB_CTRL_GET_TIMEOUT);
 148         if (result < 0) {
 149                 dev_err(dev, "Cannot get available association types: %d\n",
 150                         result);
 151                 return result;
 152         }
 153
 154         assoc_info = cbaf->buffer;
 155         if (result < sizeof(*assoc_info)) {
 156                 dev_err(dev, "Not enough data to decode association info "
 157                         "header (%zu vs %zu bytes required)\n",
 158                         (size_t)result, sizeof(*assoc_info));
 159                 return result;
 160         }
 161
 162         assoc_size = le16_to_cpu(assoc_info->Length);
 163         if (result < assoc_size) {
 164                 dev_err(dev, "Not enough data to decode association info "
 165                         "(%zu vs %zu bytes required)\n",
 166                         (size_t)assoc_size, sizeof(*assoc_info));
 167                 return result;
 168         }
 169         /*
 170          * From now on, we just verify, but won't error out unless we
 171          * don't find the AR_TYPE_WUSB_{RETRIEVE_HOST_INFO,ASSOCIATE}
 172          * types.
 173          */
 174         itr = cbaf->buffer + sizeof(*assoc_info);
 175         top = cbaf->buffer + assoc_size;
 176         dev_dbg(dev, "Found %u association requests (%zu bytes)\n",
 177                  assoc_info->NumAssociationRequests, assoc_size);
 178
 179         while (itr < top) {
 180                 u16 ar_type, ar_subtype;
 181                 u32 ar_size;
 182                 const char *ar_name;
 183
 184                 assoc_request = itr;
 185
 186                 if (top - itr < sizeof(*assoc_request)) {
 187                         dev_err(dev, "Not enough data to decode association "
 188                                 "request (%zu vs %zu bytes needed)\n",
 189                                 top - itr, sizeof(*assoc_request));
 190                         break;
 191                 }
 192
 193                 ar_type = le16_to_cpu(assoc_request->AssociationTypeId);
 194                 ar_subtype = le16_to_cpu(assoc_request->AssociationSubTypeId);
 195                 ar_size = le32_to_cpu(assoc_request->AssociationTypeInfoSize);
 196                 ar_name = "unknown";
 197
 198                 switch (ar_type) {
 199                 case AR_TYPE_WUSB:
 200                         /* Verify we have what is mandated by [WUSB-AM]. */
 201                         switch (ar_subtype) {
 202                         case AR_TYPE_WUSB_RETRIEVE_HOST_INFO:
 203                                 ar_name = "RETRIEVE_HOST_INFO";
 204                                 ar_rhi = 1;
 205                                 break;
 206                         case AR_TYPE_WUSB_ASSOCIATE:
 207                                 /* send assoc data */
 208                                 ar_name = "ASSOCIATE";
 209                                 ar_assoc = 1;
 210                                 break;
 211                         }
 212                         break;
 213                 }
 214
 215                 dev_dbg(dev, "Association request #%02u: 0x%04x/%04x "
 216                          "(%zu bytes): %s\n",
 217                          assoc_request->AssociationDataIndex, ar_type,
 218                          ar_subtype, (size_t)ar_size, ar_name);
 219
 220                 itr += sizeof(*assoc_request);
 221         }
 222
 223         if (!ar_rhi) {
 224                 dev_err(dev, "Missing RETRIEVE_HOST_INFO association "
 225                         "request\n");
 226                 return -EINVAL;
 227         }
 228         if (!ar_assoc) {
 229                 dev_err(dev, "Missing ASSOCIATE association request\n");
 230                 return -EINVAL;
 231         }
 232
 233         return 0;
 234 }
 235
 236 static const struct wusb_cbaf_host_info cbaf_host_info_defaults = {
 237         .AssociationTypeId_hdr    = WUSB_AR_AssociationTypeId,
 238         .AssociationTypeId        = cpu_to_le16(AR_TYPE_WUSB),
 239         .AssociationSubTypeId_hdr = WUSB_AR_AssociationSubTypeId,
 240         .AssociationSubTypeId = cpu_to_le16(AR_TYPE_WUSB_RETRIEVE_HOST_INFO),
 241         .CHID_hdr                 = WUSB_AR_CHID,
 242         .LangID_hdr               = WUSB_AR_LangID,
 243         .HostFriendlyName_hdr     = WUSB_AR_HostFriendlyName,
 244 };
 245
 246 /* Send WUSB host information (CHID and name) to a CBAF device */
 247 static int cbaf_send_host_info(struct cbaf *cbaf)
 248 {
 249         struct wusb_cbaf_host_info *hi;
 250         size_t name_len;
 251         size_t hi_size;
 252
 253         hi = cbaf->buffer;
 254         memset(hi, 0, sizeof(*hi));
 255         *hi = cbaf_host_info_defaults;
 256         hi->CHID = cbaf->chid;
 257         hi->LangID = 0; /* FIXME: I guess... */
 258         strlcpy(hi->HostFriendlyName, cbaf->host_name, CBA_NAME_LEN);
 259         name_len = strlen(cbaf->host_name);
 260         hi->HostFriendlyName_hdr.len = cpu_to_le16(name_len);
 261         hi_size = sizeof(*hi) + name_len;
 262
 263         return usb_control_msg(cbaf->usb_dev,
 264                         usb_sndctrlpipe(cbaf->usb_dev, 0),
 265                         CBAF_REQ_SET_ASSOCIATION_RESPONSE,
 266                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 267                         0x0101,
 268                         cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
 269                         hi, hi_size, USB_CTRL_SET_TIMEOUT);
 270 }
 271
 272 /*
 273  * Get device's information (CDID) associated to CHID
 274  *
 275  * The device will return it's information (CDID, name, bandgroups)
 276  * associated to the CHID we have set before, or 0 CDID and default
 277  * name and bandgroup if no CHID set or unknown.
 278  */
 279 static int cbaf_cdid_get(struct cbaf *cbaf)
 280 {
 281         int result;
 282         struct device *dev = &cbaf->usb_iface->dev;
 283         struct wusb_cbaf_device_info *di;
 284         size_t needed;
 285
 286         di = cbaf->buffer;
 287         result = usb_control_msg(
 288                 cbaf->usb_dev, usb_rcvctrlpipe(cbaf->usb_dev, 0),
 289                 CBAF_REQ_GET_ASSOCIATION_REQUEST,
 290                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 291                 0x0200, cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
 292                 di, cbaf->buffer_size, USB_CTRL_GET_TIMEOUT);
 293         if (result < 0) {
 294                 dev_err(dev, "Cannot request device information: %d\n",
 295                         result);
 296                 return result;
 297         }
 298
 299         needed = result < sizeof(*di) ? sizeof(*di) : le32_to_cpu(di->Length);
 300         if (result < needed) {
 301                 dev_err(dev, "Not enough data in DEVICE_INFO reply (%zu vs "
 302                         "%zu bytes needed)\n", (size_t)result, needed);
 303                 return -ENOENT;
 304         }
 305
 306         strlcpy(cbaf->device_name, di->DeviceFriendlyName, CBA_NAME_LEN);
 307         cbaf->cdid = di->CDID;
 308         cbaf->device_band_groups = le16_to_cpu(di->BandGroups);
 309
 310         return 0;
 311 }
 312
 313 static ssize_t cbaf_wusb_chid_show(struct device *dev,
 314                                         struct device_attribute *attr,
 315                                         char *buf)
 316 {
 317         struct usb_interface *iface = to_usb_interface(dev);
 318         struct cbaf *cbaf = usb_get_intfdata(iface);
 319         char pr_chid[WUSB_CKHDID_STRSIZE];
 320
 321         ckhdid_printf(pr_chid, sizeof(pr_chid), &cbaf->chid);
 322         return scnprintf(buf, PAGE_SIZE, "%s\n", pr_chid);
 323 }
 324
 325 static ssize_t cbaf_wusb_chid_store(struct device *dev,
 326                                          struct device_attribute *attr,
 327                                          const char *buf, size_t size)
 328 {
 329         ssize_t result;
 330         struct usb_interface *iface = to_usb_interface(dev);
 331         struct cbaf *cbaf = usb_get_intfdata(iface);
 332
 333         result = sscanf(buf,
 334                         "%02hhx %02hhx %02hhx %02hhx "
 335                         "%02hhx %02hhx %02hhx %02hhx "
 336                         "%02hhx %02hhx %02hhx %02hhx "
 337                         "%02hhx %02hhx %02hhx %02hhx",
 338                         &cbaf->chid.data[0] , &cbaf->chid.data[1],
 339                         &cbaf->chid.data[2] , &cbaf->chid.data[3],
 340                         &cbaf->chid.data[4] , &cbaf->chid.data[5],
 341                         &cbaf->chid.data[6] , &cbaf->chid.data[7],
 342                         &cbaf->chid.data[8] , &cbaf->chid.data[9],
 343                         &cbaf->chid.data[10], &cbaf->chid.data[11],
 344                         &cbaf->chid.data[12], &cbaf->chid.data[13],
 345                         &cbaf->chid.data[14], &cbaf->chid.data[15]);
 346
 347         if (result != 16)
 348                 return -EINVAL;
 349
 350         result = cbaf_send_host_info(cbaf);
 351         if (result < 0)
 352                 return result;
 353         result = cbaf_cdid_get(cbaf);
 354         if (result < 0)
 355                 return result;
 356         return size;
 357 }
 358 static DEVICE_ATTR(wusb_chid, 0600, cbaf_wusb_chid_show, cbaf_wusb_chid_store);
 359
 360 static ssize_t cbaf_wusb_host_name_show(struct device *dev,
 361                                         struct device_attribute *attr,
 362                                         char *buf)
 363 {
 364         struct usb_interface *iface = to_usb_interface(dev);
 365         struct cbaf *cbaf = usb_get_intfdata(iface);
 366
 367         return scnprintf(buf, PAGE_SIZE, "%s\n", cbaf->host_name);
 368 }
 369
 370 static ssize_t cbaf_wusb_host_name_store(struct device *dev,
 371                                          struct device_attribute *attr,
 372                                          const char *buf, size_t size)
 373 {
 374         ssize_t result;
 375         struct usb_interface *iface = to_usb_interface(dev);
 376         struct cbaf *cbaf = usb_get_intfdata(iface);
 377
 378         result = sscanf(buf, "%63s", cbaf->host_name);
 379         if (result != 1)
 380                 return -EINVAL;
 381
 382         return size;
 383 }
 384 static DEVICE_ATTR(wusb_host_name, 0600, cbaf_wusb_host_name_show,
 385                                          cbaf_wusb_host_name_store);
 386
 387 static ssize_t cbaf_wusb_host_band_groups_show(struct device *dev,
 388                                                struct device_attribute *attr,
 389                                                char *buf)
 390 {
 391         struct usb_interface *iface = to_usb_interface(dev);
 392         struct cbaf *cbaf = usb_get_intfdata(iface);
 393
 394         return scnprintf(buf, PAGE_SIZE, "0x%04x\n", cbaf->host_band_groups);
 395 }
 396
 397 static ssize_t cbaf_wusb_host_band_groups_store(struct device *dev,
 398                                                 struct device_attribute *attr,
 399                                                 const char *buf, size_t size)
 400 {
 401         ssize_t result;
 402         struct usb_interface *iface = to_usb_interface(dev);
 403         struct cbaf *cbaf = usb_get_intfdata(iface);
 404         u16 band_groups = 0;
 405
 406         result = sscanf(buf, "%04hx", &band_groups);
 407         if (result != 1)
 408                 return -EINVAL;
 409
 410         cbaf->host_band_groups = band_groups;
 411
 412         return size;
 413 }
 414
 415 static DEVICE_ATTR(wusb_host_band_groups, 0600,
 416                    cbaf_wusb_host_band_groups_show,
 417                    cbaf_wusb_host_band_groups_store);
 418
 419 static const struct wusb_cbaf_device_info cbaf_device_info_defaults = {
 420         .Length_hdr               = WUSB_AR_Length,
 421         .CDID_hdr                 = WUSB_AR_CDID,
 422         .BandGroups_hdr           = WUSB_AR_BandGroups,
 423         .LangID_hdr               = WUSB_AR_LangID,
 424         .DeviceFriendlyName_hdr   = WUSB_AR_DeviceFriendlyName,
 425 };
 426
 427 static ssize_t cbaf_wusb_cdid_show(struct device *dev,
 428                                    struct device_attribute *attr, char *buf)
 429 {
 430         struct usb_interface *iface = to_usb_interface(dev);
 431         struct cbaf *cbaf = usb_get_intfdata(iface);
 432         char pr_cdid[WUSB_CKHDID_STRSIZE];
 433
 434         ckhdid_printf(pr_cdid, sizeof(pr_cdid), &cbaf->cdid);
 435         return scnprintf(buf, PAGE_SIZE, "%s\n", pr_cdid);
 436 }
 437
 438 static ssize_t cbaf_wusb_cdid_store(struct device *dev,
 439                                 struct device_attribute *attr,
 440                                 const char *buf, size_t size)
 441 {
 442         ssize_t result;
 443         struct usb_interface *iface = to_usb_interface(dev);
 444         struct cbaf *cbaf = usb_get_intfdata(iface);
 445         struct wusb_ckhdid cdid;
 446
 447         result = sscanf(buf,
 448                         "%02hhx %02hhx %02hhx %02hhx "
 449                         "%02hhx %02hhx %02hhx %02hhx "
 450                         "%02hhx %02hhx %02hhx %02hhx "
 451                         "%02hhx %02hhx %02hhx %02hhx",
 452                         &cdid.data[0] , &cdid.data[1],
 453                         &cdid.data[2] , &cdid.data[3],
 454                         &cdid.data[4] , &cdid.data[5],
 455                         &cdid.data[6] , &cdid.data[7],
 456                         &cdid.data[8] , &cdid.data[9],
 457                         &cdid.data[10], &cdid.data[11],
 458                         &cdid.data[12], &cdid.data[13],
 459                         &cdid.data[14], &cdid.data[15]);
 460         if (result != 16)
 461                 return -EINVAL;
 462
 463         cbaf->cdid = cdid;
 464
 465         return size;
 466 }
 467 static DEVICE_ATTR(wusb_cdid, 0600, cbaf_wusb_cdid_show, cbaf_wusb_cdid_store);
 468
 469 static ssize_t cbaf_wusb_device_band_groups_show(struct device *dev,
 470                                                  struct device_attribute *attr,
 471                                                  char *buf)
 472 {
 473         struct usb_interface *iface = to_usb_interface(dev);
 474         struct cbaf *cbaf = usb_get_intfdata(iface);
 475
 476         return scnprintf(buf, PAGE_SIZE, "0x%04x\n", cbaf->device_band_groups);
 477 }
 478
 479 static DEVICE_ATTR(wusb_device_band_groups, 0600,
 480                    cbaf_wusb_device_band_groups_show,
 481                    NULL);
 482
 483 static ssize_t cbaf_wusb_device_name_show(struct device *dev,
 484                                         struct device_attribute *attr,
 485                                         char *buf)
 486 {
 487         struct usb_interface *iface = to_usb_interface(dev);
 488         struct cbaf *cbaf = usb_get_intfdata(iface);
 489
 490         return scnprintf(buf, PAGE_SIZE, "%s\n", cbaf->device_name);
 491 }
 492 static DEVICE_ATTR(wusb_device_name, 0600, cbaf_wusb_device_name_show, NULL);
 493
 494 static const struct wusb_cbaf_cc_data cbaf_cc_data_defaults = {
 495         .AssociationTypeId_hdr    = WUSB_AR_AssociationTypeId,
 496         .AssociationTypeId        = cpu_to_le16(AR_TYPE_WUSB),
 497         .AssociationSubTypeId_hdr = WUSB_AR_AssociationSubTypeId,
 498         .AssociationSubTypeId     = cpu_to_le16(AR_TYPE_WUSB_ASSOCIATE),
 499         .Length_hdr               = WUSB_AR_Length,
 500         .Length         = cpu_to_le32(sizeof(struct wusb_cbaf_cc_data)),
 501         .ConnectionContext_hdr    = WUSB_AR_ConnectionContext,
 502         .BandGroups_hdr           = WUSB_AR_BandGroups,
 503 };
 504
 505 static const struct wusb_cbaf_cc_data_fail cbaf_cc_data_fail_defaults = {
 506         .AssociationTypeId_hdr    = WUSB_AR_AssociationTypeId,
 507         .AssociationSubTypeId_hdr = WUSB_AR_AssociationSubTypeId,
 508         .Length_hdr               = WUSB_AR_Length,
 509         .AssociationStatus_hdr    = WUSB_AR_AssociationStatus,
 510 };
 511
 512 /*
 513  * Send a new CC to the device.
 514  */
 515 static int cbaf_cc_upload(struct cbaf *cbaf)
 516 {
 517         int result;
 518         struct device *dev = &cbaf->usb_iface->dev;
 519         struct wusb_cbaf_cc_data *ccd;
 520         char pr_cdid[WUSB_CKHDID_STRSIZE];
 521
 522         ccd =  cbaf->buffer;
 523         *ccd = cbaf_cc_data_defaults;
 524         ccd->CHID = cbaf->chid;
 525         ccd->CDID = cbaf->cdid;
 526         ccd->CK = cbaf->ck;
 527         ccd->BandGroups = cpu_to_le16(cbaf->host_band_groups);
 528
 529         dev_dbg(dev, "Trying to upload CC:\n");
 530         ckhdid_printf(pr_cdid, sizeof(pr_cdid), &ccd->CHID);
 531         dev_dbg(dev, "  CHID       %s\n", pr_cdid);
 532         ckhdid_printf(pr_cdid, sizeof(pr_cdid), &ccd->CDID);
 533         dev_dbg(dev, "  CDID       %s\n", pr_cdid);
 534         dev_dbg(dev, "  Bandgroups 0x%04x\n", cbaf->host_band_groups);
 535
 536         result = usb_control_msg(
 537                 cbaf->usb_dev, usb_sndctrlpipe(cbaf->usb_dev, 0),
 538                 CBAF_REQ_SET_ASSOCIATION_RESPONSE,
 539                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 540                 0x0201, cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
 541                 ccd, sizeof(*ccd), USB_CTRL_SET_TIMEOUT);
 542
 543         return result;
 544 }
 545
 546 static ssize_t cbaf_wusb_ck_store(struct device *dev,
 547                                   struct device_attribute *attr,
 548                                   const char *buf, size_t size)
 549 {
 550         ssize_t result;
 551         struct usb_interface *iface = to_usb_interface(dev);
 552         struct cbaf *cbaf = usb_get_intfdata(iface);
 553
 554         result = sscanf(buf,
 555                         "%02hhx %02hhx %02hhx %02hhx "
 556                         "%02hhx %02hhx %02hhx %02hhx "
 557                         "%02hhx %02hhx %02hhx %02hhx "
 558                         "%02hhx %02hhx %02hhx %02hhx",
 559                         &cbaf->ck.data[0] , &cbaf->ck.data[1],
 560                         &cbaf->ck.data[2] , &cbaf->ck.data[3],
 561                         &cbaf->ck.data[4] , &cbaf->ck.data[5],
 562                         &cbaf->ck.data[6] , &cbaf->ck.data[7],
 563                         &cbaf->ck.data[8] , &cbaf->ck.data[9],
 564                         &cbaf->ck.data[10], &cbaf->ck.data[11],
 565                         &cbaf->ck.data[12], &cbaf->ck.data[13],
 566                         &cbaf->ck.data[14], &cbaf->ck.data[15]);
 567         if (result != 16)
 568                 return -EINVAL;
 569
 570         result = cbaf_cc_upload(cbaf);
 571         if (result < 0)
 572                 return result;
 573
 574         return size;
 575 }
 576 static DEVICE_ATTR(wusb_ck, 0600, NULL, cbaf_wusb_ck_store);
 577
 578 static struct attribute *cbaf_dev_attrs[] = {
 579         &dev_attr_wusb_host_name.attr,
 580         &dev_attr_wusb_host_band_groups.attr,
 581         &dev_attr_wusb_chid.attr,
 582         &dev_attr_wusb_cdid.attr,
 583         &dev_attr_wusb_device_name.attr,
 584         &dev_attr_wusb_device_band_groups.attr,
 585         &dev_attr_wusb_ck.attr,
 586         NULL,
 587 };
 588
 589 static struct attribute_group cbaf_dev_attr_group = {
 590         .name = NULL,   /* we want them in the same directory */
 591         .attrs = cbaf_dev_attrs,
 592 };
 593
 594 static int cbaf_probe(struct usb_interface *iface,
 595                       const struct usb_device_id *id)
 596 {
 597         struct cbaf *cbaf;
 598         struct device *dev = &iface->dev;
 599         int result = -ENOMEM;
 600
 601         cbaf = kzalloc(sizeof(*cbaf), GFP_KERNEL);
 602         if (cbaf == NULL)
 603                 goto error_kzalloc;
 604         cbaf->buffer = kmalloc(512, GFP_KERNEL);
 605         if (cbaf->buffer == NULL)
 606                 goto error_kmalloc_buffer;
 607
 608         cbaf->buffer_size = 512;
 609         cbaf->usb_dev = usb_get_dev(interface_to_usbdev(iface));
 610         cbaf->usb_iface = usb_get_intf(iface);
 611         result = cbaf_check(cbaf);
 612         if (result < 0) {
 613                 dev_err(dev, "This device is not WUSB-CBAF compliant"
 614                         "and is not supported yet.\n");
 615                 goto error_check;
 616         }
 617
 618         result = sysfs_create_group(&dev->kobj, &cbaf_dev_attr_group);
 619         if (result < 0) {
 620                 dev_err(dev, "Can't register sysfs attr group: %d\n", result);
 621                 goto error_create_group;
 622         }
 623         usb_set_intfdata(iface, cbaf);
 624         return 0;
 625
 626 error_create_group:
 627 error_check:
 628         usb_put_intf(iface);
 629         usb_put_dev(cbaf->usb_dev);
 630         kfree(cbaf->buffer);
 631 error_kmalloc_buffer:
 632         kfree(cbaf);
 633 error_kzalloc:
 634         return result;
 635 }
 636
 637 static void cbaf_disconnect(struct usb_interface *iface)
 638 {
 639         struct cbaf *cbaf = usb_get_intfdata(iface);
 640         struct device *dev = &iface->dev;
 641         sysfs_remove_group(&dev->kobj, &cbaf_dev_attr_group);
 642         usb_set_intfdata(iface, NULL);
 643         usb_put_intf(iface);
 644         usb_put_dev(cbaf->usb_dev);
 645         kfree(cbaf->buffer);
 646         /* paranoia: clean up crypto keys */
 647         kzfree(cbaf);
 648 }
 649
 650 static const struct usb_device_id cbaf_id_table[] = {
 651         { USB_INTERFACE_INFO(0xef, 0x03, 0x01), },
 652         { },
 653 };
 654 MODULE_DEVICE_TABLE(usb, cbaf_id_table);
 655
 656 static struct usb_driver cbaf_driver = {
 657         .name =         "wusb-cbaf",
 658         .id_table =     cbaf_id_table,
 659         .probe =        cbaf_probe,
 660         .disconnect =   cbaf_disconnect,
 661 };
 662
 663 module_usb_driver(cbaf_driver);
 664
 665 MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>");
 666 MODULE_DESCRIPTION("Wireless USB Cable Based Association");
 667 MODULE_LICENSE("GPL");