Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 1 | /* |
| 2 | * WUSB Host Wire Adapter: Radio Control Interface (WUSB[8.6]) |
| 3 | * Radio Control command/event transport |
| 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 | * Initialize the Radio Control interface Driver. |
| 24 | * |
| 25 | * For each device probed, creates an 'struct hwarc' which contains |
| 26 | * just the representation of the UWB Radio Controller, and the logic |
| 27 | * for reading notifications and passing them to the UWB Core. |
| 28 | * |
| 29 | * So we initialize all of those, register the UWB Radio Controller |
| 30 | * and setup the notification/event handle to pipe the notifications |
| 31 | * to the UWB management Daemon. |
| 32 | * |
| 33 | * Command and event filtering. |
| 34 | * |
| 35 | * This is the driver for the Radio Control Interface described in WUSB |
| 36 | * 1.0. The core UWB module assumes that all drivers are compliant to the |
| 37 | * WHCI 0.95 specification. We thus create a filter that parses all |
| 38 | * incoming messages from the (WUSB 1.0) device and manipulate them to |
| 39 | * conform to the WHCI 0.95 specification. Similarly, outgoing messages |
| 40 | * are parsed and manipulated to conform to the WUSB 1.0 compliant messages |
| 41 | * that the device expects. Only a few messages are affected: |
| 42 | * Affected events: |
| 43 | * UWB_RC_EVT_BEACON |
| 44 | * UWB_RC_EVT_BP_SLOT_CHANGE |
| 45 | * UWB_RC_EVT_DRP_AVAIL |
| 46 | * UWB_RC_EVT_DRP |
| 47 | * Affected commands: |
| 48 | * UWB_RC_CMD_SCAN |
| 49 | * UWB_RC_CMD_SET_DRP_IE |
| 50 | * |
| 51 | * |
| 52 | * |
| 53 | */ |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 54 | #include <linux/init.h> |
| 55 | #include <linux/module.h> |
| 56 | #include <linux/usb.h> |
| 57 | #include <linux/usb/wusb.h> |
| 58 | #include <linux/usb/wusb-wa.h> |
| 59 | #include <linux/uwb.h> |
David Vrabel | bce8369 | 2008-12-22 18:22:50 +0000 | [diff] [blame] | 60 | |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 61 | #include "uwb-internal.h" |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 62 | |
Anderson Lizardo | e477a49 | 2008-09-17 16:34:35 +0100 | [diff] [blame] | 63 | /* The device uses commands and events from the WHCI specification, although |
| 64 | * reporting itself as WUSB compliant. */ |
| 65 | #define WUSB_QUIRK_WHCI_CMD_EVT 0x01 |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 66 | |
| 67 | /** |
| 68 | * Descriptor for an instance of the UWB Radio Control Driver that |
| 69 | * attaches to the RCI interface of the Host Wired Adapter. |
| 70 | * |
| 71 | * Unless there is a lock specific to the 'data members', all access |
| 72 | * is protected by uwb_rc->mutex. |
| 73 | * |
| 74 | * The NEEP (Notification/Event EndPoint) URB (@neep_urb) writes to |
| 75 | * @rd_buffer. Note there is no locking because it is perfectly (heh!) |
| 76 | * serialized--probe() submits an URB, callback is called, processes |
| 77 | * the data (synchronously), submits another URB, and so on. There is |
| 78 | * no concurrent access to the buffer. |
| 79 | */ |
| 80 | struct hwarc { |
| 81 | struct usb_device *usb_dev; |
| 82 | struct usb_interface *usb_iface; |
| 83 | struct uwb_rc *uwb_rc; /* UWB host controller */ |
| 84 | struct urb *neep_urb; /* Notification endpoint handling */ |
| 85 | struct edc neep_edc; |
| 86 | void *rd_buffer; /* NEEP read buffer */ |
| 87 | }; |
| 88 | |
| 89 | |
| 90 | /* Beacon received notification (WUSB 1.0 [8.6.3.2]) */ |
| 91 | struct uwb_rc_evt_beacon_WUSB_0100 { |
| 92 | struct uwb_rceb rceb; |
| 93 | u8 bChannelNumber; |
| 94 | __le16 wBPSTOffset; |
| 95 | u8 bLQI; |
| 96 | u8 bRSSI; |
| 97 | __le16 wBeaconInfoLength; |
| 98 | u8 BeaconInfo[]; |
| 99 | } __attribute__((packed)); |
| 100 | |
| 101 | /** |
| 102 | * Filter WUSB 1.0 BEACON RCV notification to be WHCI 0.95 |
| 103 | * |
| 104 | * @header: the incoming event |
| 105 | * @buf_size: size of buffer containing incoming event |
| 106 | * @new_size: size of event after filtering completed |
| 107 | * |
| 108 | * The WHCI 0.95 spec has a "Beacon Type" field. This value is unknown at |
| 109 | * the time we receive the beacon from WUSB so we just set it to |
| 110 | * UWB_RC_BEACON_TYPE_NEIGHBOR as a default. |
| 111 | * The solution below allocates memory upon receipt of every beacon from a |
| 112 | * WUSB device. This will deteriorate performance. What is the right way to |
| 113 | * do this? |
| 114 | */ |
| 115 | static |
| 116 | int hwarc_filter_evt_beacon_WUSB_0100(struct uwb_rc *rc, |
| 117 | struct uwb_rceb **header, |
| 118 | const size_t buf_size, |
| 119 | size_t *new_size) |
| 120 | { |
| 121 | struct uwb_rc_evt_beacon_WUSB_0100 *be; |
| 122 | struct uwb_rc_evt_beacon *newbe; |
| 123 | size_t bytes_left, ielength; |
| 124 | struct device *dev = &rc->uwb_dev.dev; |
| 125 | |
| 126 | be = container_of(*header, struct uwb_rc_evt_beacon_WUSB_0100, rceb); |
| 127 | bytes_left = buf_size; |
| 128 | if (bytes_left < sizeof(*be)) { |
| 129 | dev_err(dev, "Beacon Received Notification: Not enough data " |
| 130 | "to decode for filtering (%zu vs %zu bytes needed)\n", |
| 131 | bytes_left, sizeof(*be)); |
| 132 | return -EINVAL; |
| 133 | } |
| 134 | bytes_left -= sizeof(*be); |
| 135 | ielength = le16_to_cpu(be->wBeaconInfoLength); |
| 136 | if (bytes_left < ielength) { |
| 137 | dev_err(dev, "Beacon Received Notification: Not enough data " |
| 138 | "to decode IEs (%zu vs %zu bytes needed)\n", |
| 139 | bytes_left, ielength); |
| 140 | return -EINVAL; |
| 141 | } |
| 142 | newbe = kzalloc(sizeof(*newbe) + ielength, GFP_ATOMIC); |
| 143 | if (newbe == NULL) |
| 144 | return -ENOMEM; |
| 145 | newbe->rceb = be->rceb; |
| 146 | newbe->bChannelNumber = be->bChannelNumber; |
| 147 | newbe->bBeaconType = UWB_RC_BEACON_TYPE_NEIGHBOR; |
| 148 | newbe->wBPSTOffset = be->wBPSTOffset; |
| 149 | newbe->bLQI = be->bLQI; |
| 150 | newbe->bRSSI = be->bRSSI; |
| 151 | newbe->wBeaconInfoLength = be->wBeaconInfoLength; |
| 152 | memcpy(newbe->BeaconInfo, be->BeaconInfo, ielength); |
| 153 | *header = &newbe->rceb; |
| 154 | *new_size = sizeof(*newbe) + ielength; |
| 155 | return 1; /* calling function will free memory */ |
| 156 | } |
| 157 | |
| 158 | |
| 159 | /* DRP Availability change notification (WUSB 1.0 [8.6.3.8]) */ |
| 160 | struct uwb_rc_evt_drp_avail_WUSB_0100 { |
| 161 | struct uwb_rceb rceb; |
| 162 | __le16 wIELength; |
| 163 | u8 IEData[]; |
| 164 | } __attribute__((packed)); |
| 165 | |
| 166 | /** |
| 167 | * Filter WUSB 1.0 DRP AVAILABILITY CHANGE notification to be WHCI 0.95 |
| 168 | * |
| 169 | * @header: the incoming event |
| 170 | * @buf_size: size of buffer containing incoming event |
| 171 | * @new_size: size of event after filtering completed |
| 172 | */ |
| 173 | static |
| 174 | int hwarc_filter_evt_drp_avail_WUSB_0100(struct uwb_rc *rc, |
| 175 | struct uwb_rceb **header, |
| 176 | const size_t buf_size, |
| 177 | size_t *new_size) |
| 178 | { |
| 179 | struct uwb_rc_evt_drp_avail_WUSB_0100 *da; |
| 180 | struct uwb_rc_evt_drp_avail *newda; |
| 181 | struct uwb_ie_hdr *ie_hdr; |
| 182 | size_t bytes_left, ielength; |
| 183 | struct device *dev = &rc->uwb_dev.dev; |
| 184 | |
| 185 | |
| 186 | da = container_of(*header, struct uwb_rc_evt_drp_avail_WUSB_0100, rceb); |
| 187 | bytes_left = buf_size; |
| 188 | if (bytes_left < sizeof(*da)) { |
| 189 | dev_err(dev, "Not enough data to decode DRP Avail " |
| 190 | "Notification for filtering. Expected %zu, " |
| 191 | "received %zu.\n", (size_t)sizeof(*da), bytes_left); |
| 192 | return -EINVAL; |
| 193 | } |
| 194 | bytes_left -= sizeof(*da); |
| 195 | ielength = le16_to_cpu(da->wIELength); |
| 196 | if (bytes_left < ielength) { |
| 197 | dev_err(dev, "DRP Avail Notification filter: IE length " |
| 198 | "[%zu bytes] does not match actual length " |
| 199 | "[%zu bytes].\n", ielength, bytes_left); |
| 200 | return -EINVAL; |
| 201 | } |
| 202 | if (ielength < sizeof(*ie_hdr)) { |
| 203 | dev_err(dev, "DRP Avail Notification filter: Not enough " |
| 204 | "data to decode IE [%zu bytes, %zu needed]\n", |
| 205 | ielength, sizeof(*ie_hdr)); |
| 206 | return -EINVAL; |
| 207 | } |
| 208 | ie_hdr = (void *) da->IEData; |
| 209 | if (ie_hdr->length > 32) { |
| 210 | dev_err(dev, "DRP Availability Change event has unexpected " |
| 211 | "length for filtering. Expected < 32 bytes, " |
| 212 | "got %zu bytes.\n", (size_t)ie_hdr->length); |
| 213 | return -EINVAL; |
| 214 | } |
| 215 | newda = kzalloc(sizeof(*newda), GFP_ATOMIC); |
| 216 | if (newda == NULL) |
| 217 | return -ENOMEM; |
| 218 | newda->rceb = da->rceb; |
| 219 | memcpy(newda->bmp, (u8 *) ie_hdr + sizeof(*ie_hdr), ie_hdr->length); |
| 220 | *header = &newda->rceb; |
| 221 | *new_size = sizeof(*newda); |
| 222 | return 1; /* calling function will free memory */ |
| 223 | } |
| 224 | |
| 225 | |
| 226 | /* DRP notification (WUSB 1.0 [8.6.3.9]) */ |
| 227 | struct uwb_rc_evt_drp_WUSB_0100 { |
| 228 | struct uwb_rceb rceb; |
| 229 | struct uwb_dev_addr wSrcAddr; |
| 230 | u8 bExplicit; |
| 231 | __le16 wIELength; |
| 232 | u8 IEData[]; |
| 233 | } __attribute__((packed)); |
| 234 | |
| 235 | /** |
| 236 | * Filter WUSB 1.0 DRP Notification to be WHCI 0.95 |
| 237 | * |
| 238 | * @header: the incoming event |
| 239 | * @buf_size: size of buffer containing incoming event |
| 240 | * @new_size: size of event after filtering completed |
| 241 | * |
| 242 | * It is hard to manage DRP reservations without having a Reason code. |
| 243 | * Unfortunately there is none in the WUSB spec. We just set the default to |
| 244 | * DRP IE RECEIVED. |
| 245 | * We do not currently use the bBeaconSlotNumber value, so we set this to |
| 246 | * zero for now. |
| 247 | */ |
| 248 | static |
| 249 | int hwarc_filter_evt_drp_WUSB_0100(struct uwb_rc *rc, |
| 250 | struct uwb_rceb **header, |
| 251 | const size_t buf_size, |
| 252 | size_t *new_size) |
| 253 | { |
| 254 | struct uwb_rc_evt_drp_WUSB_0100 *drpev; |
| 255 | struct uwb_rc_evt_drp *newdrpev; |
| 256 | size_t bytes_left, ielength; |
| 257 | struct device *dev = &rc->uwb_dev.dev; |
| 258 | |
| 259 | drpev = container_of(*header, struct uwb_rc_evt_drp_WUSB_0100, rceb); |
| 260 | bytes_left = buf_size; |
| 261 | if (bytes_left < sizeof(*drpev)) { |
| 262 | dev_err(dev, "Not enough data to decode DRP Notification " |
| 263 | "for filtering. Expected %zu, received %zu.\n", |
| 264 | (size_t)sizeof(*drpev), bytes_left); |
| 265 | return -EINVAL; |
| 266 | } |
| 267 | ielength = le16_to_cpu(drpev->wIELength); |
| 268 | bytes_left -= sizeof(*drpev); |
| 269 | if (bytes_left < ielength) { |
| 270 | dev_err(dev, "DRP Notification filter: header length [%zu " |
| 271 | "bytes] does not match actual length [%zu " |
| 272 | "bytes].\n", ielength, bytes_left); |
| 273 | return -EINVAL; |
| 274 | } |
| 275 | newdrpev = kzalloc(sizeof(*newdrpev) + ielength, GFP_ATOMIC); |
| 276 | if (newdrpev == NULL) |
| 277 | return -ENOMEM; |
| 278 | newdrpev->rceb = drpev->rceb; |
| 279 | newdrpev->src_addr = drpev->wSrcAddr; |
| 280 | newdrpev->reason = UWB_DRP_NOTIF_DRP_IE_RCVD; |
| 281 | newdrpev->beacon_slot_number = 0; |
| 282 | newdrpev->ie_length = drpev->wIELength; |
| 283 | memcpy(newdrpev->ie_data, drpev->IEData, ielength); |
| 284 | *header = &newdrpev->rceb; |
| 285 | *new_size = sizeof(*newdrpev) + ielength; |
| 286 | return 1; /* calling function will free memory */ |
| 287 | } |
| 288 | |
| 289 | |
| 290 | /* Scan Command (WUSB 1.0 [8.6.2.5]) */ |
| 291 | struct uwb_rc_cmd_scan_WUSB_0100 { |
| 292 | struct uwb_rccb rccb; |
| 293 | u8 bChannelNumber; |
| 294 | u8 bScanState; |
| 295 | } __attribute__((packed)); |
| 296 | |
| 297 | /** |
| 298 | * Filter WHCI 0.95 SCAN command to be WUSB 1.0 SCAN command |
| 299 | * |
| 300 | * @header: command sent to device (compliant to WHCI 0.95) |
| 301 | * @size: size of command sent to device |
| 302 | * |
| 303 | * We only reduce the size by two bytes because the WUSB 1.0 scan command |
| 304 | * does not have the last field (wStarttime). Also, make sure we don't send |
| 305 | * the device an unexpected scan type. |
| 306 | */ |
| 307 | static |
| 308 | int hwarc_filter_cmd_scan_WUSB_0100(struct uwb_rc *rc, |
| 309 | struct uwb_rccb **header, |
| 310 | size_t *size) |
| 311 | { |
| 312 | struct uwb_rc_cmd_scan *sc; |
| 313 | |
| 314 | sc = container_of(*header, struct uwb_rc_cmd_scan, rccb); |
| 315 | |
| 316 | if (sc->bScanState == UWB_SCAN_ONLY_STARTTIME) |
| 317 | sc->bScanState = UWB_SCAN_ONLY; |
| 318 | /* Don't send the last two bytes. */ |
| 319 | *size -= 2; |
| 320 | return 0; |
| 321 | } |
| 322 | |
| 323 | |
| 324 | /* SET DRP IE command (WUSB 1.0 [8.6.2.7]) */ |
| 325 | struct uwb_rc_cmd_set_drp_ie_WUSB_0100 { |
| 326 | struct uwb_rccb rccb; |
| 327 | u8 bExplicit; |
| 328 | __le16 wIELength; |
| 329 | struct uwb_ie_drp IEData[]; |
| 330 | } __attribute__((packed)); |
| 331 | |
| 332 | /** |
| 333 | * Filter WHCI 0.95 SET DRP IE command to be WUSB 1.0 SET DRP IE command |
| 334 | * |
| 335 | * @header: command sent to device (compliant to WHCI 0.95) |
| 336 | * @size: size of command sent to device |
| 337 | * |
| 338 | * WUSB has an extra bExplicit field - we assume always explicit |
| 339 | * negotiation so this field is set. The command expected by the device is |
| 340 | * thus larger than the one prepared by the driver so we need to |
| 341 | * reallocate memory to accommodate this. |
| 342 | * We trust the driver to send us the correct data so no checking is done |
| 343 | * on incoming data - evn though it is variable length. |
| 344 | */ |
| 345 | static |
| 346 | int hwarc_filter_cmd_set_drp_ie_WUSB_0100(struct uwb_rc *rc, |
| 347 | struct uwb_rccb **header, |
| 348 | size_t *size) |
| 349 | { |
| 350 | struct uwb_rc_cmd_set_drp_ie *orgcmd; |
| 351 | struct uwb_rc_cmd_set_drp_ie_WUSB_0100 *cmd; |
| 352 | size_t ielength; |
| 353 | |
| 354 | orgcmd = container_of(*header, struct uwb_rc_cmd_set_drp_ie, rccb); |
| 355 | ielength = le16_to_cpu(orgcmd->wIELength); |
| 356 | cmd = kzalloc(sizeof(*cmd) + ielength, GFP_KERNEL); |
| 357 | if (cmd == NULL) |
| 358 | return -ENOMEM; |
| 359 | cmd->rccb = orgcmd->rccb; |
| 360 | cmd->bExplicit = 0; |
| 361 | cmd->wIELength = orgcmd->wIELength; |
| 362 | memcpy(cmd->IEData, orgcmd->IEData, ielength); |
| 363 | *header = &cmd->rccb; |
| 364 | *size = sizeof(*cmd) + ielength; |
| 365 | return 1; /* calling function will free memory */ |
| 366 | } |
| 367 | |
| 368 | |
| 369 | /** |
| 370 | * Filter data from WHCI driver to WUSB device |
| 371 | * |
| 372 | * @header: WHCI 0.95 compliant command from driver |
| 373 | * @size: length of command |
| 374 | * |
| 375 | * The routine managing commands to the device (uwb_rc_cmd()) will call the |
| 376 | * filtering function pointer (if it exists) before it passes any data to |
| 377 | * the device. At this time the command has been formatted according to |
| 378 | * WHCI 0.95 and is ready to be sent to the device. |
| 379 | * |
| 380 | * The filter function will be provided with the current command and its |
| 381 | * length. The function will manipulate the command if necessary and |
| 382 | * potentially reallocate memory for a command that needed more memory that |
| 383 | * the given command. If new memory was created the function will return 1 |
| 384 | * to indicate to the calling function that the memory need to be freed |
| 385 | * when not needed any more. The size will contain the new length of the |
| 386 | * command. |
| 387 | * If memory has not been allocated we rely on the original mechanisms to |
| 388 | * free the memory of the command - even when we reduce the value of size. |
| 389 | */ |
| 390 | static |
| 391 | int hwarc_filter_cmd_WUSB_0100(struct uwb_rc *rc, struct uwb_rccb **header, |
| 392 | size_t *size) |
| 393 | { |
| 394 | int result; |
| 395 | struct uwb_rccb *rccb = *header; |
| 396 | int cmd = le16_to_cpu(rccb->wCommand); |
| 397 | switch (cmd) { |
| 398 | case UWB_RC_CMD_SCAN: |
| 399 | result = hwarc_filter_cmd_scan_WUSB_0100(rc, header, size); |
| 400 | break; |
| 401 | case UWB_RC_CMD_SET_DRP_IE: |
| 402 | result = hwarc_filter_cmd_set_drp_ie_WUSB_0100(rc, header, size); |
| 403 | break; |
| 404 | default: |
| 405 | result = -ENOANO; |
| 406 | break; |
| 407 | } |
| 408 | return result; |
| 409 | } |
| 410 | |
| 411 | |
| 412 | /** |
| 413 | * Filter data from WHCI driver to WUSB device |
| 414 | * |
| 415 | * @header: WHCI 0.95 compliant command from driver |
| 416 | * @size: length of command |
| 417 | * |
| 418 | * Filter commands based on which protocol the device supports. The WUSB |
| 419 | * errata should be the same as WHCI 0.95 so we do not filter that here - |
| 420 | * only WUSB 1.0. |
| 421 | */ |
| 422 | static |
| 423 | int hwarc_filter_cmd(struct uwb_rc *rc, struct uwb_rccb **header, |
| 424 | size_t *size) |
| 425 | { |
| 426 | int result = -ENOANO; |
| 427 | if (rc->version == 0x0100) |
| 428 | result = hwarc_filter_cmd_WUSB_0100(rc, header, size); |
| 429 | return result; |
| 430 | } |
| 431 | |
| 432 | |
| 433 | /** |
| 434 | * Compute return value as sum of incoming value and value at given offset |
| 435 | * |
| 436 | * @rceb: event for which we compute the size, it contains a variable |
| 437 | * length field. |
| 438 | * @core_size: size of the "non variable" part of the event |
| 439 | * @offset: place in event where the length of the variable part is stored |
| 440 | * @buf_size: total length of buffer in which event arrived - we need to make |
| 441 | * sure we read the offset in memory that is still part of the event |
| 442 | */ |
| 443 | static |
| 444 | ssize_t hwarc_get_event_size(struct uwb_rc *rc, const struct uwb_rceb *rceb, |
| 445 | size_t core_size, size_t offset, |
| 446 | const size_t buf_size) |
| 447 | { |
| 448 | ssize_t size = -ENOSPC; |
| 449 | const void *ptr = rceb; |
| 450 | size_t type_size = sizeof(__le16); |
| 451 | struct device *dev = &rc->uwb_dev.dev; |
| 452 | |
| 453 | if (offset + type_size >= buf_size) { |
| 454 | dev_err(dev, "Not enough data to read extra size of event " |
| 455 | "0x%02x/%04x/%02x, only got %zu bytes.\n", |
| 456 | rceb->bEventType, le16_to_cpu(rceb->wEvent), |
| 457 | rceb->bEventContext, buf_size); |
| 458 | goto out; |
| 459 | } |
| 460 | ptr += offset; |
| 461 | size = core_size + le16_to_cpu(*(__le16 *)ptr); |
| 462 | out: |
| 463 | return size; |
| 464 | } |
| 465 | |
| 466 | |
| 467 | /* Beacon slot change notification (WUSB 1.0 [8.6.3.5]) */ |
| 468 | struct uwb_rc_evt_bp_slot_change_WUSB_0100 { |
| 469 | struct uwb_rceb rceb; |
| 470 | u8 bSlotNumber; |
| 471 | } __attribute__((packed)); |
| 472 | |
| 473 | |
| 474 | /** |
| 475 | * Filter data from WUSB device to WHCI driver |
| 476 | * |
| 477 | * @header: incoming event |
| 478 | * @buf_size: size of buffer in which event arrived |
| 479 | * @_event_size: actual size of event in the buffer |
| 480 | * @new_size: size of event after filtered |
| 481 | * |
| 482 | * We don't know how the buffer is constructed - there may be more than one |
| 483 | * event in it so buffer length does not determine event length. We first |
| 484 | * determine the expected size of the incoming event. This value is passed |
| 485 | * back only if the actual filtering succeeded (so we know the computed |
| 486 | * expected size is correct). This value will be zero if |
| 487 | * the event did not need any filtering. |
| 488 | * |
| 489 | * WHCI interprets the BP Slot Change event's data differently than |
| 490 | * WUSB. The event sizes are exactly the same. The data field |
| 491 | * indicates the new beacon slot in which a RC is transmitting its |
| 492 | * beacon. The maximum value of this is 96 (wMacBPLength ECMA-368 |
| 493 | * 17.16 (Table 117)). We thus know that the WUSB value will not set |
| 494 | * the bit bNoSlot, so we don't really do anything (placeholder). |
| 495 | */ |
| 496 | static |
| 497 | int hwarc_filter_event_WUSB_0100(struct uwb_rc *rc, struct uwb_rceb **header, |
| 498 | const size_t buf_size, size_t *_real_size, |
| 499 | size_t *_new_size) |
| 500 | { |
| 501 | int result = -ENOANO; |
| 502 | struct uwb_rceb *rceb = *header; |
| 503 | int event = le16_to_cpu(rceb->wEvent); |
| 504 | size_t event_size; |
| 505 | size_t core_size, offset; |
| 506 | |
| 507 | if (rceb->bEventType != UWB_RC_CET_GENERAL) |
| 508 | goto out; |
| 509 | switch (event) { |
| 510 | case UWB_RC_EVT_BEACON: |
| 511 | core_size = sizeof(struct uwb_rc_evt_beacon_WUSB_0100); |
| 512 | offset = offsetof(struct uwb_rc_evt_beacon_WUSB_0100, |
| 513 | wBeaconInfoLength); |
| 514 | event_size = hwarc_get_event_size(rc, rceb, core_size, |
| 515 | offset, buf_size); |
| 516 | if (event_size < 0) |
| 517 | goto out; |
| 518 | *_real_size = event_size; |
| 519 | result = hwarc_filter_evt_beacon_WUSB_0100(rc, header, |
| 520 | buf_size, _new_size); |
| 521 | break; |
| 522 | case UWB_RC_EVT_BP_SLOT_CHANGE: |
| 523 | *_new_size = *_real_size = |
| 524 | sizeof(struct uwb_rc_evt_bp_slot_change_WUSB_0100); |
| 525 | result = 0; |
| 526 | break; |
| 527 | |
| 528 | case UWB_RC_EVT_DRP_AVAIL: |
| 529 | core_size = sizeof(struct uwb_rc_evt_drp_avail_WUSB_0100); |
| 530 | offset = offsetof(struct uwb_rc_evt_drp_avail_WUSB_0100, |
| 531 | wIELength); |
| 532 | event_size = hwarc_get_event_size(rc, rceb, core_size, |
| 533 | offset, buf_size); |
| 534 | if (event_size < 0) |
| 535 | goto out; |
| 536 | *_real_size = event_size; |
| 537 | result = hwarc_filter_evt_drp_avail_WUSB_0100( |
| 538 | rc, header, buf_size, _new_size); |
| 539 | break; |
| 540 | |
| 541 | case UWB_RC_EVT_DRP: |
| 542 | core_size = sizeof(struct uwb_rc_evt_drp_WUSB_0100); |
| 543 | offset = offsetof(struct uwb_rc_evt_drp_WUSB_0100, wIELength); |
| 544 | event_size = hwarc_get_event_size(rc, rceb, core_size, |
| 545 | offset, buf_size); |
| 546 | if (event_size < 0) |
| 547 | goto out; |
| 548 | *_real_size = event_size; |
| 549 | result = hwarc_filter_evt_drp_WUSB_0100(rc, header, |
| 550 | buf_size, _new_size); |
| 551 | break; |
| 552 | |
| 553 | default: |
| 554 | break; |
| 555 | } |
| 556 | out: |
| 557 | return result; |
| 558 | } |
| 559 | |
| 560 | /** |
| 561 | * Filter data from WUSB device to WHCI driver |
| 562 | * |
| 563 | * @header: incoming event |
| 564 | * @buf_size: size of buffer in which event arrived |
| 565 | * @_event_size: actual size of event in the buffer |
| 566 | * @_new_size: size of event after filtered |
| 567 | * |
| 568 | * Filter events based on which protocol the device supports. The WUSB |
| 569 | * errata should be the same as WHCI 0.95 so we do not filter that here - |
| 570 | * only WUSB 1.0. |
| 571 | * |
| 572 | * If we don't handle it, we return -ENOANO (why the weird error code? |
| 573 | * well, so if I get it, I can pinpoint in the code that raised |
| 574 | * it...after all, not too many places use the higher error codes). |
| 575 | */ |
| 576 | static |
| 577 | int hwarc_filter_event(struct uwb_rc *rc, struct uwb_rceb **header, |
| 578 | const size_t buf_size, size_t *_real_size, |
| 579 | size_t *_new_size) |
| 580 | { |
| 581 | int result = -ENOANO; |
| 582 | if (rc->version == 0x0100) |
| 583 | result = hwarc_filter_event_WUSB_0100( |
| 584 | rc, header, buf_size, _real_size, _new_size); |
| 585 | return result; |
| 586 | } |
| 587 | |
| 588 | |
| 589 | /** |
| 590 | * Execute an UWB RC command on HWA |
| 591 | * |
| 592 | * @rc: Instance of a Radio Controller that is a HWA |
| 593 | * @cmd: Buffer containing the RCCB and payload to execute |
| 594 | * @cmd_size: Size of the command buffer. |
| 595 | * |
| 596 | * NOTE: rc's mutex has to be locked |
| 597 | */ |
| 598 | static |
| 599 | int hwarc_cmd(struct uwb_rc *uwb_rc, const struct uwb_rccb *cmd, size_t cmd_size) |
| 600 | { |
| 601 | struct hwarc *hwarc = uwb_rc->priv; |
| 602 | return usb_control_msg( |
| 603 | hwarc->usb_dev, usb_sndctrlpipe(hwarc->usb_dev, 0), |
| 604 | WA_EXEC_RC_CMD, USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, |
| 605 | 0, hwarc->usb_iface->cur_altsetting->desc.bInterfaceNumber, |
| 606 | (void *) cmd, cmd_size, 100 /* FIXME: this is totally arbitrary */); |
| 607 | } |
| 608 | |
| 609 | static |
| 610 | int hwarc_reset(struct uwb_rc *uwb_rc) |
| 611 | { |
| 612 | struct hwarc *hwarc = uwb_rc->priv; |
| 613 | return usb_reset_device(hwarc->usb_dev); |
| 614 | } |
| 615 | |
| 616 | /** |
| 617 | * Callback for the notification and event endpoint |
| 618 | * |
| 619 | * Check's that everything is fine and then passes the read data to |
| 620 | * the notification/event handling mechanism (neh). |
| 621 | */ |
| 622 | static |
| 623 | void hwarc_neep_cb(struct urb *urb) |
| 624 | { |
| 625 | struct hwarc *hwarc = urb->context; |
| 626 | struct usb_interface *usb_iface = hwarc->usb_iface; |
| 627 | struct device *dev = &usb_iface->dev; |
| 628 | int result; |
| 629 | |
| 630 | switch (result = urb->status) { |
| 631 | case 0: |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 632 | uwb_rc_neh_grok(hwarc->uwb_rc, urb->transfer_buffer, |
| 633 | urb->actual_length); |
| 634 | break; |
| 635 | case -ECONNRESET: /* Not an error, but a controlled situation; */ |
| 636 | case -ENOENT: /* (we killed the URB)...so, no broadcast */ |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 637 | goto out; |
| 638 | case -ESHUTDOWN: /* going away! */ |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 639 | goto out; |
| 640 | default: /* On general errors, retry unless it gets ugly */ |
| 641 | if (edc_inc(&hwarc->neep_edc, EDC_MAX_ERRORS, |
| 642 | EDC_ERROR_TIMEFRAME)) |
| 643 | goto error_exceeded; |
| 644 | dev_err(dev, "NEEP: URB error %d\n", urb->status); |
| 645 | } |
| 646 | result = usb_submit_urb(urb, GFP_ATOMIC); |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 647 | if (result < 0) { |
| 648 | dev_err(dev, "NEEP: Can't resubmit URB (%d) resetting device\n", |
| 649 | result); |
| 650 | goto error; |
| 651 | } |
| 652 | out: |
| 653 | return; |
| 654 | |
| 655 | error_exceeded: |
| 656 | dev_err(dev, "NEEP: URB max acceptable errors " |
| 657 | "exceeded, resetting device\n"); |
| 658 | error: |
| 659 | uwb_rc_neh_error(hwarc->uwb_rc, result); |
| 660 | uwb_rc_reset_all(hwarc->uwb_rc); |
| 661 | return; |
| 662 | } |
| 663 | |
| 664 | static void hwarc_init(struct hwarc *hwarc) |
| 665 | { |
| 666 | edc_init(&hwarc->neep_edc); |
| 667 | } |
| 668 | |
| 669 | /** |
| 670 | * Initialize the notification/event endpoint stuff |
| 671 | * |
| 672 | * Note this is effectively a parallel thread; it knows that |
| 673 | * hwarc->uwb_rc always exists because the existence of a 'hwarc' |
| 674 | * means that there is a reverence on the hwarc->uwb_rc (see |
| 675 | * _probe()), and thus _neep_cb() can execute safely. |
| 676 | */ |
| 677 | static int hwarc_neep_init(struct uwb_rc *rc) |
| 678 | { |
| 679 | struct hwarc *hwarc = rc->priv; |
| 680 | struct usb_interface *iface = hwarc->usb_iface; |
| 681 | struct usb_device *usb_dev = interface_to_usbdev(iface); |
| 682 | struct device *dev = &iface->dev; |
| 683 | int result; |
| 684 | struct usb_endpoint_descriptor *epd; |
| 685 | |
| 686 | epd = &iface->cur_altsetting->endpoint[0].desc; |
| 687 | hwarc->rd_buffer = (void *) __get_free_page(GFP_KERNEL); |
| 688 | if (hwarc->rd_buffer == NULL) { |
| 689 | dev_err(dev, "Unable to allocate notification's read buffer\n"); |
| 690 | goto error_rd_buffer; |
| 691 | } |
| 692 | hwarc->neep_urb = usb_alloc_urb(0, GFP_KERNEL); |
| 693 | if (hwarc->neep_urb == NULL) { |
| 694 | dev_err(dev, "Unable to allocate notification URB\n"); |
| 695 | goto error_urb_alloc; |
| 696 | } |
| 697 | usb_fill_int_urb(hwarc->neep_urb, usb_dev, |
| 698 | usb_rcvintpipe(usb_dev, epd->bEndpointAddress), |
| 699 | hwarc->rd_buffer, PAGE_SIZE, |
| 700 | hwarc_neep_cb, hwarc, epd->bInterval); |
| 701 | result = usb_submit_urb(hwarc->neep_urb, GFP_ATOMIC); |
| 702 | if (result < 0) { |
| 703 | dev_err(dev, "Cannot submit notification URB: %d\n", result); |
| 704 | goto error_neep_submit; |
| 705 | } |
| 706 | return 0; |
| 707 | |
| 708 | error_neep_submit: |
| 709 | usb_free_urb(hwarc->neep_urb); |
| 710 | error_urb_alloc: |
| 711 | free_page((unsigned long)hwarc->rd_buffer); |
| 712 | error_rd_buffer: |
| 713 | return -ENOMEM; |
| 714 | } |
| 715 | |
| 716 | |
| 717 | /** Clean up all the notification endpoint resources */ |
| 718 | static void hwarc_neep_release(struct uwb_rc *rc) |
| 719 | { |
| 720 | struct hwarc *hwarc = rc->priv; |
| 721 | |
| 722 | usb_kill_urb(hwarc->neep_urb); |
| 723 | usb_free_urb(hwarc->neep_urb); |
| 724 | free_page((unsigned long)hwarc->rd_buffer); |
| 725 | } |
| 726 | |
| 727 | /** |
| 728 | * Get the version from class-specific descriptor |
| 729 | * |
| 730 | * NOTE: this descriptor comes with the big bundled configuration |
| 731 | * descriptor that includes the interfaces' and endpoints', so |
| 732 | * we just look for it in the cached copy kept by the USB stack. |
| 733 | * |
| 734 | * NOTE2: We convert LE fields to CPU order. |
| 735 | */ |
| 736 | static int hwarc_get_version(struct uwb_rc *rc) |
| 737 | { |
| 738 | int result; |
| 739 | |
| 740 | struct hwarc *hwarc = rc->priv; |
| 741 | struct uwb_rc_control_intf_class_desc *descr; |
| 742 | struct device *dev = &rc->uwb_dev.dev; |
| 743 | struct usb_device *usb_dev = hwarc->usb_dev; |
| 744 | char *itr; |
| 745 | struct usb_descriptor_header *hdr; |
| 746 | size_t itr_size, actconfig_idx; |
| 747 | u16 version; |
| 748 | |
| 749 | actconfig_idx = (usb_dev->actconfig - usb_dev->config) / |
| 750 | sizeof(usb_dev->config[0]); |
| 751 | itr = usb_dev->rawdescriptors[actconfig_idx]; |
| 752 | itr_size = le16_to_cpu(usb_dev->actconfig->desc.wTotalLength); |
| 753 | while (itr_size >= sizeof(*hdr)) { |
| 754 | hdr = (struct usb_descriptor_header *) itr; |
David Vrabel | bce8369 | 2008-12-22 18:22:50 +0000 | [diff] [blame] | 755 | dev_dbg(dev, "Extra device descriptor: " |
| 756 | "type %02x/%u bytes @ %zu (%zu left)\n", |
| 757 | hdr->bDescriptorType, hdr->bLength, |
| 758 | (itr - usb_dev->rawdescriptors[actconfig_idx]), |
| 759 | itr_size); |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 760 | if (hdr->bDescriptorType == USB_DT_CS_RADIO_CONTROL) |
| 761 | goto found; |
| 762 | itr += hdr->bLength; |
| 763 | itr_size -= hdr->bLength; |
| 764 | } |
| 765 | dev_err(dev, "cannot find Radio Control Interface Class descriptor\n"); |
| 766 | return -ENODEV; |
| 767 | |
| 768 | found: |
| 769 | result = -EINVAL; |
| 770 | if (hdr->bLength > itr_size) { /* is it available? */ |
| 771 | dev_err(dev, "incomplete Radio Control Interface Class " |
| 772 | "descriptor (%zu bytes left, %u needed)\n", |
| 773 | itr_size, hdr->bLength); |
| 774 | goto error; |
| 775 | } |
| 776 | if (hdr->bLength < sizeof(*descr)) { |
| 777 | dev_err(dev, "short Radio Control Interface Class " |
| 778 | "descriptor\n"); |
| 779 | goto error; |
| 780 | } |
| 781 | descr = (struct uwb_rc_control_intf_class_desc *) hdr; |
| 782 | /* Make LE fields CPU order */ |
| 783 | version = __le16_to_cpu(descr->bcdRCIVersion); |
| 784 | if (version != 0x0100) { |
| 785 | dev_err(dev, "Device reports protocol version 0x%04x. We " |
| 786 | "do not support that. \n", version); |
| 787 | result = -EINVAL; |
| 788 | goto error; |
| 789 | } |
| 790 | rc->version = version; |
David Vrabel | bce8369 | 2008-12-22 18:22:50 +0000 | [diff] [blame] | 791 | dev_dbg(dev, "Device supports WUSB protocol version 0x%04x \n", rc->version); |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 792 | result = 0; |
| 793 | error: |
| 794 | return result; |
| 795 | } |
| 796 | |
| 797 | /* |
| 798 | * By creating a 'uwb_rc', we have a reference on it -- that reference |
| 799 | * is the one we drop when we disconnect. |
| 800 | * |
| 801 | * No need to switch altsettings; according to WUSB1.0[8.6.1.1], there |
| 802 | * is only one altsetting allowed. |
| 803 | */ |
| 804 | static int hwarc_probe(struct usb_interface *iface, |
| 805 | const struct usb_device_id *id) |
| 806 | { |
| 807 | int result; |
| 808 | struct uwb_rc *uwb_rc; |
| 809 | struct hwarc *hwarc; |
| 810 | struct device *dev = &iface->dev; |
| 811 | |
| 812 | result = -ENOMEM; |
| 813 | uwb_rc = uwb_rc_alloc(); |
| 814 | if (uwb_rc == NULL) { |
| 815 | dev_err(dev, "unable to allocate RC instance\n"); |
| 816 | goto error_rc_alloc; |
| 817 | } |
| 818 | hwarc = kzalloc(sizeof(*hwarc), GFP_KERNEL); |
| 819 | if (hwarc == NULL) { |
| 820 | dev_err(dev, "unable to allocate HWA RC instance\n"); |
| 821 | goto error_alloc; |
| 822 | } |
| 823 | hwarc_init(hwarc); |
| 824 | hwarc->usb_dev = usb_get_dev(interface_to_usbdev(iface)); |
| 825 | hwarc->usb_iface = usb_get_intf(iface); |
| 826 | hwarc->uwb_rc = uwb_rc; |
| 827 | |
| 828 | uwb_rc->owner = THIS_MODULE; |
| 829 | uwb_rc->start = hwarc_neep_init; |
| 830 | uwb_rc->stop = hwarc_neep_release; |
| 831 | uwb_rc->cmd = hwarc_cmd; |
| 832 | uwb_rc->reset = hwarc_reset; |
Anderson Lizardo | e477a49 | 2008-09-17 16:34:35 +0100 | [diff] [blame] | 833 | if (id->driver_info & WUSB_QUIRK_WHCI_CMD_EVT) { |
| 834 | uwb_rc->filter_cmd = NULL; |
| 835 | uwb_rc->filter_event = NULL; |
| 836 | } else { |
| 837 | uwb_rc->filter_cmd = hwarc_filter_cmd; |
| 838 | uwb_rc->filter_event = hwarc_filter_event; |
| 839 | } |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 840 | |
| 841 | result = uwb_rc_add(uwb_rc, dev, hwarc); |
| 842 | if (result < 0) |
| 843 | goto error_rc_add; |
| 844 | result = hwarc_get_version(uwb_rc); |
| 845 | if (result < 0) { |
| 846 | dev_err(dev, "cannot retrieve version of RC \n"); |
| 847 | goto error_get_version; |
| 848 | } |
| 849 | usb_set_intfdata(iface, hwarc); |
| 850 | return 0; |
| 851 | |
| 852 | error_get_version: |
| 853 | uwb_rc_rm(uwb_rc); |
| 854 | error_rc_add: |
| 855 | usb_put_intf(iface); |
| 856 | usb_put_dev(hwarc->usb_dev); |
| 857 | error_alloc: |
| 858 | uwb_rc_put(uwb_rc); |
| 859 | error_rc_alloc: |
| 860 | return result; |
| 861 | } |
| 862 | |
| 863 | static void hwarc_disconnect(struct usb_interface *iface) |
| 864 | { |
| 865 | struct hwarc *hwarc = usb_get_intfdata(iface); |
| 866 | struct uwb_rc *uwb_rc = hwarc->uwb_rc; |
| 867 | |
| 868 | usb_set_intfdata(hwarc->usb_iface, NULL); |
| 869 | uwb_rc_rm(uwb_rc); |
| 870 | usb_put_intf(hwarc->usb_iface); |
| 871 | usb_put_dev(hwarc->usb_dev); |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 872 | kfree(hwarc); |
| 873 | uwb_rc_put(uwb_rc); /* when creating the device, refcount = 1 */ |
| 874 | } |
| 875 | |
David Vrabel | 307ba6d | 2008-11-07 17:37:33 +0000 | [diff] [blame] | 876 | static int hwarc_pre_reset(struct usb_interface *iface) |
| 877 | { |
| 878 | struct hwarc *hwarc = usb_get_intfdata(iface); |
| 879 | struct uwb_rc *uwb_rc = hwarc->uwb_rc; |
| 880 | |
| 881 | uwb_rc_pre_reset(uwb_rc); |
| 882 | return 0; |
| 883 | } |
| 884 | |
| 885 | static int hwarc_post_reset(struct usb_interface *iface) |
| 886 | { |
| 887 | struct hwarc *hwarc = usb_get_intfdata(iface); |
| 888 | struct uwb_rc *uwb_rc = hwarc->uwb_rc; |
| 889 | |
| 890 | uwb_rc_post_reset(uwb_rc); |
| 891 | return 0; |
| 892 | } |
| 893 | |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 894 | /** USB device ID's that we handle */ |
| 895 | static struct usb_device_id hwarc_id_table[] = { |
Anderson Lizardo | e477a49 | 2008-09-17 16:34:35 +0100 | [diff] [blame] | 896 | /* D-Link DUB-1210 */ |
| 897 | { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3d02, 0xe0, 0x01, 0x02), |
| 898 | .driver_info = WUSB_QUIRK_WHCI_CMD_EVT }, |
Anderson Lizardo | fa21183 | 2008-09-17 16:34:36 +0100 | [diff] [blame] | 899 | /* Intel i1480 (using firmware 1.3PA2-20070828) */ |
| 900 | { USB_DEVICE_AND_INTERFACE_INFO(0x8086, 0x0c3b, 0xe0, 0x01, 0x02), |
| 901 | .driver_info = WUSB_QUIRK_WHCI_CMD_EVT }, |
Anderson Lizardo | e477a49 | 2008-09-17 16:34:35 +0100 | [diff] [blame] | 902 | /* Generic match for the Radio Control interface */ |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 903 | { USB_INTERFACE_INFO(0xe0, 0x01, 0x02), }, |
| 904 | { }, |
| 905 | }; |
| 906 | MODULE_DEVICE_TABLE(usb, hwarc_id_table); |
| 907 | |
| 908 | static struct usb_driver hwarc_driver = { |
| 909 | .name = "hwa-rc", |
David Vrabel | 307ba6d | 2008-11-07 17:37:33 +0000 | [diff] [blame] | 910 | .id_table = hwarc_id_table, |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 911 | .probe = hwarc_probe, |
| 912 | .disconnect = hwarc_disconnect, |
David Vrabel | 307ba6d | 2008-11-07 17:37:33 +0000 | [diff] [blame] | 913 | .pre_reset = hwarc_pre_reset, |
| 914 | .post_reset = hwarc_post_reset, |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 915 | }; |
| 916 | |
| 917 | static int __init hwarc_driver_init(void) |
| 918 | { |
David Vrabel | bce8369 | 2008-12-22 18:22:50 +0000 | [diff] [blame] | 919 | return usb_register(&hwarc_driver); |
Inaky Perez-Gonzalez | de520b8 | 2008-09-17 16:34:15 +0100 | [diff] [blame] | 920 | } |
| 921 | module_init(hwarc_driver_init); |
| 922 | |
| 923 | static void __exit hwarc_driver_exit(void) |
| 924 | { |
| 925 | usb_deregister(&hwarc_driver); |
| 926 | } |
| 927 | module_exit(hwarc_driver_exit); |
| 928 | |
| 929 | MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>"); |
| 930 | MODULE_DESCRIPTION("Host Wireless Adapter Radio Control Driver"); |
| 931 | MODULE_LICENSE("GPL"); |