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 */ 104struct 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 */ 132static 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 236static 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 */ 247static 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 */ 279static 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 313static 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 325static 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} 358static DEVICE_ATTR(wusb_chid, 0600, cbaf_wusb_chid_show, cbaf_wusb_chid_store); 359 360static 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 370static 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} 384static DEVICE_ATTR(wusb_host_name, 0600, cbaf_wusb_host_name_show, 385 cbaf_wusb_host_name_store); 386 387static 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 397static 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 415static DEVICE_ATTR(wusb_host_band_groups, 0600, 416 cbaf_wusb_host_band_groups_show, 417 cbaf_wusb_host_band_groups_store); 418 419static 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 427static 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 438static 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} 467static DEVICE_ATTR(wusb_cdid, 0600, cbaf_wusb_cdid_show, cbaf_wusb_cdid_store); 468 469static 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 479static DEVICE_ATTR(wusb_device_band_groups, 0600, 480 cbaf_wusb_device_band_groups_show, 481 NULL); 482 483static 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} 492static DEVICE_ATTR(wusb_device_name, 0600, cbaf_wusb_device_name_show, NULL); 493 494static 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 505static 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 */ 515static 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 546static 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} 576static DEVICE_ATTR(wusb_ck, 0600, NULL, cbaf_wusb_ck_store); 577 578static 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 589static struct attribute_group cbaf_dev_attr_group = { 590 .name = NULL, /* we want them in the same directory */ 591 .attrs = cbaf_dev_attrs, 592}; 593 594static 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 626error_create_group: 627error_check: 628 usb_put_intf(iface); 629 usb_put_dev(cbaf->usb_dev); 630 kfree(cbaf->buffer); 631error_kmalloc_buffer: 632 kfree(cbaf); 633error_kzalloc: 634 return result; 635} 636 637static 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 650static const struct usb_device_id cbaf_id_table[] = { 651 { USB_INTERFACE_INFO(0xef, 0x03, 0x01), }, 652 { }, 653}; 654MODULE_DEVICE_TABLE(usb, cbaf_id_table); 655 656static 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 663module_usb_driver(cbaf_driver); 664 665MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>"); 666MODULE_DESCRIPTION("Wireless USB Cable Based Association"); 667MODULE_LICENSE("GPL"); 668