1 /* 2 * Copyright (c) 2010-2011 Atheros Communications Inc. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 #include <asm/unaligned.h> 18 #include "htc.h" 19 20 /* identify firmware images */ 21 #define FIRMWARE_AR7010_1_1 "htc_7010.fw" 22 #define FIRMWARE_AR9271 "htc_9271.fw" 23 24 MODULE_FIRMWARE(FIRMWARE_AR7010_1_1); 25 MODULE_FIRMWARE(FIRMWARE_AR9271); 26 27 static struct usb_device_id ath9k_hif_usb_ids[] = { 28 { USB_DEVICE(0x0cf3, 0x9271) }, /* Atheros */ 29 { USB_DEVICE(0x0cf3, 0x1006) }, /* Atheros */ 30 { USB_DEVICE(0x0846, 0x9030) }, /* Netgear N150 */ 31 { USB_DEVICE(0x07D1, 0x3A10) }, /* Dlink Wireless 150 */ 32 { USB_DEVICE(0x13D3, 0x3327) }, /* Azurewave */ 33 { USB_DEVICE(0x13D3, 0x3328) }, /* Azurewave */ 34 { USB_DEVICE(0x13D3, 0x3346) }, /* IMC Networks */ 35 { USB_DEVICE(0x13D3, 0x3348) }, /* Azurewave */ 36 { USB_DEVICE(0x13D3, 0x3349) }, /* Azurewave */ 37 { USB_DEVICE(0x13D3, 0x3350) }, /* Azurewave */ 38 { USB_DEVICE(0x04CA, 0x4605) }, /* Liteon */ 39 { USB_DEVICE(0x040D, 0x3801) }, /* VIA */ 40 { USB_DEVICE(0x0cf3, 0xb003) }, /* Ubiquiti WifiStation Ext */ 41 { USB_DEVICE(0x057c, 0x8403) }, /* AVM FRITZ!WLAN 11N v2 USB */ 42 43 { USB_DEVICE(0x0cf3, 0x7015), 44 .driver_info = AR9287_USB }, /* Atheros */ 45 { USB_DEVICE(0x1668, 0x1200), 46 .driver_info = AR9287_USB }, /* Verizon */ 47 48 { USB_DEVICE(0x0cf3, 0x7010), 49 .driver_info = AR9280_USB }, /* Atheros */ 50 { USB_DEVICE(0x0846, 0x9018), 51 .driver_info = AR9280_USB }, /* Netgear WNDA3200 */ 52 { USB_DEVICE(0x083A, 0xA704), 53 .driver_info = AR9280_USB }, /* SMC Networks */ 54 { USB_DEVICE(0x0411, 0x017f), 55 .driver_info = AR9280_USB }, /* Sony UWA-BR100 */ 56 { USB_DEVICE(0x04da, 0x3904), 57 .driver_info = AR9280_USB }, 58 59 { USB_DEVICE(0x0cf3, 0x20ff), 60 .driver_info = STORAGE_DEVICE }, 61 62 { }, 63 }; 64 65 MODULE_DEVICE_TABLE(usb, ath9k_hif_usb_ids); 66 67 static int __hif_usb_tx(struct hif_device_usb *hif_dev); 68 69 static void hif_usb_regout_cb(struct urb *urb) 70 { 71 struct cmd_buf *cmd = (struct cmd_buf *)urb->context; 72 73 switch (urb->status) { 74 case 0: 75 break; 76 case -ENOENT: 77 case -ECONNRESET: 78 case -ENODEV: 79 case -ESHUTDOWN: 80 goto free; 81 default: 82 break; 83 } 84 85 if (cmd) { 86 ath9k_htc_txcompletion_cb(cmd->hif_dev->htc_handle, 87 cmd->skb, true); 88 kfree(cmd); 89 } 90 91 return; 92 free: 93 kfree_skb(cmd->skb); 94 kfree(cmd); 95 } 96 97 static int hif_usb_send_regout(struct hif_device_usb *hif_dev, 98 struct sk_buff *skb) 99 { 100 struct urb *urb; 101 struct cmd_buf *cmd; 102 int ret = 0; 103 104 urb = usb_alloc_urb(0, GFP_KERNEL); 105 if (urb == NULL) 106 return -ENOMEM; 107 108 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 109 if (cmd == NULL) { 110 usb_free_urb(urb); 111 return -ENOMEM; 112 } 113 114 cmd->skb = skb; 115 cmd->hif_dev = hif_dev; 116 117 usb_fill_bulk_urb(urb, hif_dev->udev, 118 usb_sndbulkpipe(hif_dev->udev, USB_REG_OUT_PIPE), 119 skb->data, skb->len, 120 hif_usb_regout_cb, cmd); 121 122 usb_anchor_urb(urb, &hif_dev->regout_submitted); 123 ret = usb_submit_urb(urb, GFP_KERNEL); 124 if (ret) { 125 usb_unanchor_urb(urb); 126 kfree(cmd); 127 } 128 usb_free_urb(urb); 129 130 return ret; 131 } 132 133 static void hif_usb_mgmt_cb(struct urb *urb) 134 { 135 struct cmd_buf *cmd = (struct cmd_buf *)urb->context; 136 struct hif_device_usb *hif_dev; 137 bool txok = true; 138 139 if (!cmd || !cmd->skb || !cmd->hif_dev) 140 return; 141 142 hif_dev = cmd->hif_dev; 143 144 switch (urb->status) { 145 case 0: 146 break; 147 case -ENOENT: 148 case -ECONNRESET: 149 case -ENODEV: 150 case -ESHUTDOWN: 151 txok = false; 152 153 /* 154 * If the URBs are being flushed, no need to complete 155 * this packet. 156 */ 157 spin_lock(&hif_dev->tx.tx_lock); 158 if (hif_dev->tx.flags & HIF_USB_TX_FLUSH) { 159 spin_unlock(&hif_dev->tx.tx_lock); 160 dev_kfree_skb_any(cmd->skb); 161 kfree(cmd); 162 return; 163 } 164 spin_unlock(&hif_dev->tx.tx_lock); 165 166 break; 167 default: 168 txok = false; 169 break; 170 } 171 172 skb_pull(cmd->skb, 4); 173 ath9k_htc_txcompletion_cb(cmd->hif_dev->htc_handle, 174 cmd->skb, txok); 175 kfree(cmd); 176 } 177 178 static int hif_usb_send_mgmt(struct hif_device_usb *hif_dev, 179 struct sk_buff *skb) 180 { 181 struct urb *urb; 182 struct cmd_buf *cmd; 183 int ret = 0; 184 __le16 *hdr; 185 186 urb = usb_alloc_urb(0, GFP_ATOMIC); 187 if (urb == NULL) 188 return -ENOMEM; 189 190 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC); 191 if (cmd == NULL) { 192 usb_free_urb(urb); 193 return -ENOMEM; 194 } 195 196 cmd->skb = skb; 197 cmd->hif_dev = hif_dev; 198 199 hdr = (__le16 *) skb_push(skb, 4); 200 *hdr++ = cpu_to_le16(skb->len - 4); 201 *hdr++ = cpu_to_le16(ATH_USB_TX_STREAM_MODE_TAG); 202 203 usb_fill_bulk_urb(urb, hif_dev->udev, 204 usb_sndbulkpipe(hif_dev->udev, USB_WLAN_TX_PIPE), 205 skb->data, skb->len, 206 hif_usb_mgmt_cb, cmd); 207 208 usb_anchor_urb(urb, &hif_dev->mgmt_submitted); 209 ret = usb_submit_urb(urb, GFP_ATOMIC); 210 if (ret) { 211 usb_unanchor_urb(urb); 212 kfree(cmd); 213 } 214 usb_free_urb(urb); 215 216 return ret; 217 } 218 219 static inline void ath9k_skb_queue_purge(struct hif_device_usb *hif_dev, 220 struct sk_buff_head *list) 221 { 222 struct sk_buff *skb; 223 224 while ((skb = __skb_dequeue(list)) != NULL) { 225 dev_kfree_skb_any(skb); 226 } 227 } 228 229 static inline void ath9k_skb_queue_complete(struct hif_device_usb *hif_dev, 230 struct sk_buff_head *queue, 231 bool txok) 232 { 233 struct sk_buff *skb; 234 235 while ((skb = __skb_dequeue(queue)) != NULL) { 236 ath9k_htc_txcompletion_cb(hif_dev->htc_handle, 237 skb, txok); 238 if (txok) 239 TX_STAT_INC(skb_success); 240 else 241 TX_STAT_INC(skb_failed); 242 } 243 } 244 245 static void hif_usb_tx_cb(struct urb *urb) 246 { 247 struct tx_buf *tx_buf = (struct tx_buf *) urb->context; 248 struct hif_device_usb *hif_dev; 249 bool txok = true; 250 251 if (!tx_buf || !tx_buf->hif_dev) 252 return; 253 254 hif_dev = tx_buf->hif_dev; 255 256 switch (urb->status) { 257 case 0: 258 break; 259 case -ENOENT: 260 case -ECONNRESET: 261 case -ENODEV: 262 case -ESHUTDOWN: 263 txok = false; 264 265 /* 266 * If the URBs are being flushed, no need to add this 267 * URB to the free list. 268 */ 269 spin_lock(&hif_dev->tx.tx_lock); 270 if (hif_dev->tx.flags & HIF_USB_TX_FLUSH) { 271 spin_unlock(&hif_dev->tx.tx_lock); 272 ath9k_skb_queue_purge(hif_dev, &tx_buf->skb_queue); 273 return; 274 } 275 spin_unlock(&hif_dev->tx.tx_lock); 276 277 break; 278 default: 279 txok = false; 280 break; 281 } 282 283 ath9k_skb_queue_complete(hif_dev, &tx_buf->skb_queue, txok); 284 285 /* Re-initialize the SKB queue */ 286 tx_buf->len = tx_buf->offset = 0; 287 __skb_queue_head_init(&tx_buf->skb_queue); 288 289 /* Add this TX buffer to the free list */ 290 spin_lock(&hif_dev->tx.tx_lock); 291 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf); 292 hif_dev->tx.tx_buf_cnt++; 293 if (!(hif_dev->tx.flags & HIF_USB_TX_STOP)) 294 __hif_usb_tx(hif_dev); /* Check for pending SKBs */ 295 TX_STAT_INC(buf_completed); 296 spin_unlock(&hif_dev->tx.tx_lock); 297 } 298 299 /* TX lock has to be taken */ 300 static int __hif_usb_tx(struct hif_device_usb *hif_dev) 301 { 302 struct tx_buf *tx_buf = NULL; 303 struct sk_buff *nskb = NULL; 304 int ret = 0, i; 305 u16 tx_skb_cnt = 0; 306 u8 *buf; 307 __le16 *hdr; 308 309 if (hif_dev->tx.tx_skb_cnt == 0) 310 return 0; 311 312 /* Check if a free TX buffer is available */ 313 if (list_empty(&hif_dev->tx.tx_buf)) 314 return 0; 315 316 tx_buf = list_first_entry(&hif_dev->tx.tx_buf, struct tx_buf, list); 317 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_pending); 318 hif_dev->tx.tx_buf_cnt--; 319 320 tx_skb_cnt = min_t(u16, hif_dev->tx.tx_skb_cnt, MAX_TX_AGGR_NUM); 321 322 for (i = 0; i < tx_skb_cnt; i++) { 323 nskb = __skb_dequeue(&hif_dev->tx.tx_skb_queue); 324 325 /* Should never be NULL */ 326 BUG_ON(!nskb); 327 328 hif_dev->tx.tx_skb_cnt--; 329 330 buf = tx_buf->buf; 331 buf += tx_buf->offset; 332 hdr = (__le16 *)buf; 333 *hdr++ = cpu_to_le16(nskb->len); 334 *hdr++ = cpu_to_le16(ATH_USB_TX_STREAM_MODE_TAG); 335 buf += 4; 336 memcpy(buf, nskb->data, nskb->len); 337 tx_buf->len = nskb->len + 4; 338 339 if (i < (tx_skb_cnt - 1)) 340 tx_buf->offset += (((tx_buf->len - 1) / 4) + 1) * 4; 341 342 if (i == (tx_skb_cnt - 1)) 343 tx_buf->len += tx_buf->offset; 344 345 __skb_queue_tail(&tx_buf->skb_queue, nskb); 346 TX_STAT_INC(skb_queued); 347 } 348 349 usb_fill_bulk_urb(tx_buf->urb, hif_dev->udev, 350 usb_sndbulkpipe(hif_dev->udev, USB_WLAN_TX_PIPE), 351 tx_buf->buf, tx_buf->len, 352 hif_usb_tx_cb, tx_buf); 353 354 ret = usb_submit_urb(tx_buf->urb, GFP_ATOMIC); 355 if (ret) { 356 tx_buf->len = tx_buf->offset = 0; 357 ath9k_skb_queue_complete(hif_dev, &tx_buf->skb_queue, false); 358 __skb_queue_head_init(&tx_buf->skb_queue); 359 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf); 360 hif_dev->tx.tx_buf_cnt++; 361 } 362 363 if (!ret) 364 TX_STAT_INC(buf_queued); 365 366 return ret; 367 } 368 369 static int hif_usb_send_tx(struct hif_device_usb *hif_dev, struct sk_buff *skb) 370 { 371 struct ath9k_htc_tx_ctl *tx_ctl; 372 unsigned long flags; 373 int ret = 0; 374 375 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags); 376 377 if (hif_dev->tx.flags & HIF_USB_TX_STOP) { 378 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 379 return -ENODEV; 380 } 381 382 /* Check if the max queue count has been reached */ 383 if (hif_dev->tx.tx_skb_cnt > MAX_TX_BUF_NUM) { 384 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 385 return -ENOMEM; 386 } 387 388 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 389 390 tx_ctl = HTC_SKB_CB(skb); 391 392 /* Mgmt/Beacon frames don't use the TX buffer pool */ 393 if ((tx_ctl->type == ATH9K_HTC_MGMT) || 394 (tx_ctl->type == ATH9K_HTC_BEACON)) { 395 ret = hif_usb_send_mgmt(hif_dev, skb); 396 } 397 398 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags); 399 400 if ((tx_ctl->type == ATH9K_HTC_NORMAL) || 401 (tx_ctl->type == ATH9K_HTC_AMPDU)) { 402 __skb_queue_tail(&hif_dev->tx.tx_skb_queue, skb); 403 hif_dev->tx.tx_skb_cnt++; 404 } 405 406 /* Check if AMPDUs have to be sent immediately */ 407 if ((hif_dev->tx.tx_buf_cnt == MAX_TX_URB_NUM) && 408 (hif_dev->tx.tx_skb_cnt < 2)) { 409 __hif_usb_tx(hif_dev); 410 } 411 412 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 413 414 return ret; 415 } 416 417 static void hif_usb_start(void *hif_handle) 418 { 419 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle; 420 unsigned long flags; 421 422 hif_dev->flags |= HIF_USB_START; 423 424 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags); 425 hif_dev->tx.flags &= ~HIF_USB_TX_STOP; 426 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 427 } 428 429 static void hif_usb_stop(void *hif_handle) 430 { 431 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle; 432 struct tx_buf *tx_buf = NULL, *tx_buf_tmp = NULL; 433 unsigned long flags; 434 435 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags); 436 ath9k_skb_queue_complete(hif_dev, &hif_dev->tx.tx_skb_queue, false); 437 hif_dev->tx.tx_skb_cnt = 0; 438 hif_dev->tx.flags |= HIF_USB_TX_STOP; 439 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 440 441 /* The pending URBs have to be canceled. */ 442 list_for_each_entry_safe(tx_buf, tx_buf_tmp, 443 &hif_dev->tx.tx_pending, list) { 444 usb_kill_urb(tx_buf->urb); 445 } 446 447 usb_kill_anchored_urbs(&hif_dev->mgmt_submitted); 448 } 449 450 static int hif_usb_send(void *hif_handle, u8 pipe_id, struct sk_buff *skb) 451 { 452 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle; 453 int ret = 0; 454 455 switch (pipe_id) { 456 case USB_WLAN_TX_PIPE: 457 ret = hif_usb_send_tx(hif_dev, skb); 458 break; 459 case USB_REG_OUT_PIPE: 460 ret = hif_usb_send_regout(hif_dev, skb); 461 break; 462 default: 463 dev_err(&hif_dev->udev->dev, 464 "ath9k_htc: Invalid TX pipe: %d\n", pipe_id); 465 ret = -EINVAL; 466 break; 467 } 468 469 return ret; 470 } 471 472 static inline bool check_index(struct sk_buff *skb, u8 idx) 473 { 474 struct ath9k_htc_tx_ctl *tx_ctl; 475 476 tx_ctl = HTC_SKB_CB(skb); 477 478 if ((tx_ctl->type == ATH9K_HTC_AMPDU) && 479 (tx_ctl->sta_idx == idx)) 480 return true; 481 482 return false; 483 } 484 485 static void hif_usb_sta_drain(void *hif_handle, u8 idx) 486 { 487 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle; 488 struct sk_buff *skb, *tmp; 489 unsigned long flags; 490 491 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags); 492 493 skb_queue_walk_safe(&hif_dev->tx.tx_skb_queue, skb, tmp) { 494 if (check_index(skb, idx)) { 495 __skb_unlink(skb, &hif_dev->tx.tx_skb_queue); 496 ath9k_htc_txcompletion_cb(hif_dev->htc_handle, 497 skb, false); 498 hif_dev->tx.tx_skb_cnt--; 499 TX_STAT_INC(skb_failed); 500 } 501 } 502 503 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 504 } 505 506 static struct ath9k_htc_hif hif_usb = { 507 .transport = ATH9K_HIF_USB, 508 .name = "ath9k_hif_usb", 509 510 .control_ul_pipe = USB_REG_OUT_PIPE, 511 .control_dl_pipe = USB_REG_IN_PIPE, 512 513 .start = hif_usb_start, 514 .stop = hif_usb_stop, 515 .sta_drain = hif_usb_sta_drain, 516 .send = hif_usb_send, 517 }; 518 519 static void ath9k_hif_usb_rx_stream(struct hif_device_usb *hif_dev, 520 struct sk_buff *skb) 521 { 522 struct sk_buff *nskb, *skb_pool[MAX_PKT_NUM_IN_TRANSFER]; 523 int index = 0, i = 0, len = skb->len; 524 int rx_remain_len, rx_pkt_len; 525 u16 pool_index = 0; 526 u8 *ptr; 527 528 spin_lock(&hif_dev->rx_lock); 529 530 rx_remain_len = hif_dev->rx_remain_len; 531 rx_pkt_len = hif_dev->rx_transfer_len; 532 533 if (rx_remain_len != 0) { 534 struct sk_buff *remain_skb = hif_dev->remain_skb; 535 536 if (remain_skb) { 537 ptr = (u8 *) remain_skb->data; 538 539 index = rx_remain_len; 540 rx_remain_len -= hif_dev->rx_pad_len; 541 ptr += rx_pkt_len; 542 543 memcpy(ptr, skb->data, rx_remain_len); 544 545 rx_pkt_len += rx_remain_len; 546 hif_dev->rx_remain_len = 0; 547 skb_put(remain_skb, rx_pkt_len); 548 549 skb_pool[pool_index++] = remain_skb; 550 551 } else { 552 index = rx_remain_len; 553 } 554 } 555 556 spin_unlock(&hif_dev->rx_lock); 557 558 while (index < len) { 559 u16 pkt_len; 560 u16 pkt_tag; 561 u16 pad_len; 562 int chk_idx; 563 564 ptr = (u8 *) skb->data; 565 566 pkt_len = get_unaligned_le16(ptr + index); 567 pkt_tag = get_unaligned_le16(ptr + index + 2); 568 569 if (pkt_tag != ATH_USB_RX_STREAM_MODE_TAG) { 570 RX_STAT_INC(skb_dropped); 571 return; 572 } 573 574 pad_len = 4 - (pkt_len & 0x3); 575 if (pad_len == 4) 576 pad_len = 0; 577 578 chk_idx = index; 579 index = index + 4 + pkt_len + pad_len; 580 581 if (index > MAX_RX_BUF_SIZE) { 582 spin_lock(&hif_dev->rx_lock); 583 hif_dev->rx_remain_len = index - MAX_RX_BUF_SIZE; 584 hif_dev->rx_transfer_len = 585 MAX_RX_BUF_SIZE - chk_idx - 4; 586 hif_dev->rx_pad_len = pad_len; 587 588 nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC); 589 if (!nskb) { 590 dev_err(&hif_dev->udev->dev, 591 "ath9k_htc: RX memory allocation error\n"); 592 spin_unlock(&hif_dev->rx_lock); 593 goto err; 594 } 595 skb_reserve(nskb, 32); 596 RX_STAT_INC(skb_allocated); 597 598 memcpy(nskb->data, &(skb->data[chk_idx+4]), 599 hif_dev->rx_transfer_len); 600 601 /* Record the buffer pointer */ 602 hif_dev->remain_skb = nskb; 603 spin_unlock(&hif_dev->rx_lock); 604 } else { 605 nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC); 606 if (!nskb) { 607 dev_err(&hif_dev->udev->dev, 608 "ath9k_htc: RX memory allocation error\n"); 609 goto err; 610 } 611 skb_reserve(nskb, 32); 612 RX_STAT_INC(skb_allocated); 613 614 memcpy(nskb->data, &(skb->data[chk_idx+4]), pkt_len); 615 skb_put(nskb, pkt_len); 616 skb_pool[pool_index++] = nskb; 617 } 618 } 619 620 err: 621 for (i = 0; i < pool_index; i++) { 622 ath9k_htc_rx_msg(hif_dev->htc_handle, skb_pool[i], 623 skb_pool[i]->len, USB_WLAN_RX_PIPE); 624 RX_STAT_INC(skb_completed); 625 } 626 } 627 628 static void ath9k_hif_usb_rx_cb(struct urb *urb) 629 { 630 struct sk_buff *skb = (struct sk_buff *) urb->context; 631 struct hif_device_usb *hif_dev = 632 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0)); 633 int ret; 634 635 if (!skb) 636 return; 637 638 if (!hif_dev) 639 goto free; 640 641 switch (urb->status) { 642 case 0: 643 break; 644 case -ENOENT: 645 case -ECONNRESET: 646 case -ENODEV: 647 case -ESHUTDOWN: 648 goto free; 649 default: 650 goto resubmit; 651 } 652 653 if (likely(urb->actual_length != 0)) { 654 skb_put(skb, urb->actual_length); 655 ath9k_hif_usb_rx_stream(hif_dev, skb); 656 } 657 658 resubmit: 659 skb_reset_tail_pointer(skb); 660 skb_trim(skb, 0); 661 662 usb_anchor_urb(urb, &hif_dev->rx_submitted); 663 ret = usb_submit_urb(urb, GFP_ATOMIC); 664 if (ret) { 665 usb_unanchor_urb(urb); 666 goto free; 667 } 668 669 return; 670 free: 671 kfree_skb(skb); 672 } 673 674 static void ath9k_hif_usb_reg_in_cb(struct urb *urb) 675 { 676 struct sk_buff *skb = (struct sk_buff *) urb->context; 677 struct sk_buff *nskb; 678 struct hif_device_usb *hif_dev = 679 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0)); 680 int ret; 681 682 if (!skb) 683 return; 684 685 if (!hif_dev) 686 goto free; 687 688 switch (urb->status) { 689 case 0: 690 break; 691 case -ENOENT: 692 case -ECONNRESET: 693 case -ENODEV: 694 case -ESHUTDOWN: 695 goto free; 696 default: 697 skb_reset_tail_pointer(skb); 698 skb_trim(skb, 0); 699 700 goto resubmit; 701 } 702 703 if (likely(urb->actual_length != 0)) { 704 skb_put(skb, urb->actual_length); 705 706 /* Process the command first */ 707 ath9k_htc_rx_msg(hif_dev->htc_handle, skb, 708 skb->len, USB_REG_IN_PIPE); 709 710 711 nskb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_ATOMIC); 712 if (!nskb) { 713 dev_err(&hif_dev->udev->dev, 714 "ath9k_htc: REG_IN memory allocation failure\n"); 715 urb->context = NULL; 716 return; 717 } 718 719 usb_fill_bulk_urb(urb, hif_dev->udev, 720 usb_rcvbulkpipe(hif_dev->udev, 721 USB_REG_IN_PIPE), 722 nskb->data, MAX_REG_IN_BUF_SIZE, 723 ath9k_hif_usb_reg_in_cb, nskb); 724 } 725 726 resubmit: 727 usb_anchor_urb(urb, &hif_dev->reg_in_submitted); 728 ret = usb_submit_urb(urb, GFP_ATOMIC); 729 if (ret) { 730 usb_unanchor_urb(urb); 731 goto free; 732 } 733 734 return; 735 free: 736 kfree_skb(skb); 737 urb->context = NULL; 738 } 739 740 static void ath9k_hif_usb_dealloc_tx_urbs(struct hif_device_usb *hif_dev) 741 { 742 struct tx_buf *tx_buf = NULL, *tx_buf_tmp = NULL; 743 unsigned long flags; 744 745 list_for_each_entry_safe(tx_buf, tx_buf_tmp, 746 &hif_dev->tx.tx_buf, list) { 747 usb_kill_urb(tx_buf->urb); 748 list_del(&tx_buf->list); 749 usb_free_urb(tx_buf->urb); 750 kfree(tx_buf->buf); 751 kfree(tx_buf); 752 } 753 754 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags); 755 hif_dev->tx.flags |= HIF_USB_TX_FLUSH; 756 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags); 757 758 list_for_each_entry_safe(tx_buf, tx_buf_tmp, 759 &hif_dev->tx.tx_pending, list) { 760 usb_kill_urb(tx_buf->urb); 761 list_del(&tx_buf->list); 762 usb_free_urb(tx_buf->urb); 763 kfree(tx_buf->buf); 764 kfree(tx_buf); 765 } 766 767 usb_kill_anchored_urbs(&hif_dev->mgmt_submitted); 768 } 769 770 static int ath9k_hif_usb_alloc_tx_urbs(struct hif_device_usb *hif_dev) 771 { 772 struct tx_buf *tx_buf; 773 int i; 774 775 INIT_LIST_HEAD(&hif_dev->tx.tx_buf); 776 INIT_LIST_HEAD(&hif_dev->tx.tx_pending); 777 spin_lock_init(&hif_dev->tx.tx_lock); 778 __skb_queue_head_init(&hif_dev->tx.tx_skb_queue); 779 init_usb_anchor(&hif_dev->mgmt_submitted); 780 781 for (i = 0; i < MAX_TX_URB_NUM; i++) { 782 tx_buf = kzalloc(sizeof(struct tx_buf), GFP_KERNEL); 783 if (!tx_buf) 784 goto err; 785 786 tx_buf->buf = kzalloc(MAX_TX_BUF_SIZE, GFP_KERNEL); 787 if (!tx_buf->buf) 788 goto err; 789 790 tx_buf->urb = usb_alloc_urb(0, GFP_KERNEL); 791 if (!tx_buf->urb) 792 goto err; 793 794 tx_buf->hif_dev = hif_dev; 795 __skb_queue_head_init(&tx_buf->skb_queue); 796 797 list_add_tail(&tx_buf->list, &hif_dev->tx.tx_buf); 798 } 799 800 hif_dev->tx.tx_buf_cnt = MAX_TX_URB_NUM; 801 802 return 0; 803 err: 804 if (tx_buf) { 805 kfree(tx_buf->buf); 806 kfree(tx_buf); 807 } 808 ath9k_hif_usb_dealloc_tx_urbs(hif_dev); 809 return -ENOMEM; 810 } 811 812 static void ath9k_hif_usb_dealloc_rx_urbs(struct hif_device_usb *hif_dev) 813 { 814 usb_kill_anchored_urbs(&hif_dev->rx_submitted); 815 } 816 817 static int ath9k_hif_usb_alloc_rx_urbs(struct hif_device_usb *hif_dev) 818 { 819 struct urb *urb = NULL; 820 struct sk_buff *skb = NULL; 821 int i, ret; 822 823 init_usb_anchor(&hif_dev->rx_submitted); 824 spin_lock_init(&hif_dev->rx_lock); 825 826 for (i = 0; i < MAX_RX_URB_NUM; i++) { 827 828 /* Allocate URB */ 829 urb = usb_alloc_urb(0, GFP_KERNEL); 830 if (urb == NULL) { 831 ret = -ENOMEM; 832 goto err_urb; 833 } 834 835 /* Allocate buffer */ 836 skb = alloc_skb(MAX_RX_BUF_SIZE, GFP_KERNEL); 837 if (!skb) { 838 ret = -ENOMEM; 839 goto err_skb; 840 } 841 842 usb_fill_bulk_urb(urb, hif_dev->udev, 843 usb_rcvbulkpipe(hif_dev->udev, 844 USB_WLAN_RX_PIPE), 845 skb->data, MAX_RX_BUF_SIZE, 846 ath9k_hif_usb_rx_cb, skb); 847 848 /* Anchor URB */ 849 usb_anchor_urb(urb, &hif_dev->rx_submitted); 850 851 /* Submit URB */ 852 ret = usb_submit_urb(urb, GFP_KERNEL); 853 if (ret) { 854 usb_unanchor_urb(urb); 855 goto err_submit; 856 } 857 858 /* 859 * Drop reference count. 860 * This ensures that the URB is freed when killing them. 861 */ 862 usb_free_urb(urb); 863 } 864 865 return 0; 866 867 err_submit: 868 kfree_skb(skb); 869 err_skb: 870 usb_free_urb(urb); 871 err_urb: 872 ath9k_hif_usb_dealloc_rx_urbs(hif_dev); 873 return ret; 874 } 875 876 static void ath9k_hif_usb_dealloc_reg_in_urbs(struct hif_device_usb *hif_dev) 877 { 878 usb_kill_anchored_urbs(&hif_dev->reg_in_submitted); 879 } 880 881 static int ath9k_hif_usb_alloc_reg_in_urbs(struct hif_device_usb *hif_dev) 882 { 883 struct urb *urb = NULL; 884 struct sk_buff *skb = NULL; 885 int i, ret; 886 887 init_usb_anchor(&hif_dev->reg_in_submitted); 888 889 for (i = 0; i < MAX_REG_IN_URB_NUM; i++) { 890 891 /* Allocate URB */ 892 urb = usb_alloc_urb(0, GFP_KERNEL); 893 if (urb == NULL) { 894 ret = -ENOMEM; 895 goto err_urb; 896 } 897 898 /* Allocate buffer */ 899 skb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_KERNEL); 900 if (!skb) { 901 ret = -ENOMEM; 902 goto err_skb; 903 } 904 905 usb_fill_bulk_urb(urb, hif_dev->udev, 906 usb_rcvbulkpipe(hif_dev->udev, 907 USB_REG_IN_PIPE), 908 skb->data, MAX_REG_IN_BUF_SIZE, 909 ath9k_hif_usb_reg_in_cb, skb); 910 911 /* Anchor URB */ 912 usb_anchor_urb(urb, &hif_dev->reg_in_submitted); 913 914 /* Submit URB */ 915 ret = usb_submit_urb(urb, GFP_KERNEL); 916 if (ret) { 917 usb_unanchor_urb(urb); 918 goto err_submit; 919 } 920 921 /* 922 * Drop reference count. 923 * This ensures that the URB is freed when killing them. 924 */ 925 usb_free_urb(urb); 926 } 927 928 return 0; 929 930 err_submit: 931 kfree_skb(skb); 932 err_skb: 933 usb_free_urb(urb); 934 err_urb: 935 ath9k_hif_usb_dealloc_reg_in_urbs(hif_dev); 936 return ret; 937 } 938 939 static int ath9k_hif_usb_alloc_urbs(struct hif_device_usb *hif_dev) 940 { 941 /* Register Write */ 942 init_usb_anchor(&hif_dev->regout_submitted); 943 944 /* TX */ 945 if (ath9k_hif_usb_alloc_tx_urbs(hif_dev) < 0) 946 goto err; 947 948 /* RX */ 949 if (ath9k_hif_usb_alloc_rx_urbs(hif_dev) < 0) 950 goto err_rx; 951 952 /* Register Read */ 953 if (ath9k_hif_usb_alloc_reg_in_urbs(hif_dev) < 0) 954 goto err_reg; 955 956 return 0; 957 err_reg: 958 ath9k_hif_usb_dealloc_rx_urbs(hif_dev); 959 err_rx: 960 ath9k_hif_usb_dealloc_tx_urbs(hif_dev); 961 err: 962 return -ENOMEM; 963 } 964 965 static void ath9k_hif_usb_dealloc_urbs(struct hif_device_usb *hif_dev) 966 { 967 usb_kill_anchored_urbs(&hif_dev->regout_submitted); 968 ath9k_hif_usb_dealloc_reg_in_urbs(hif_dev); 969 ath9k_hif_usb_dealloc_tx_urbs(hif_dev); 970 ath9k_hif_usb_dealloc_rx_urbs(hif_dev); 971 } 972 973 static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev) 974 { 975 int transfer, err; 976 const void *data = hif_dev->firmware->data; 977 size_t len = hif_dev->firmware->size; 978 u32 addr = AR9271_FIRMWARE; 979 u8 *buf = kzalloc(4096, GFP_KERNEL); 980 u32 firm_offset; 981 982 if (!buf) 983 return -ENOMEM; 984 985 while (len) { 986 transfer = min_t(size_t, len, 4096); 987 memcpy(buf, data, transfer); 988 989 err = usb_control_msg(hif_dev->udev, 990 usb_sndctrlpipe(hif_dev->udev, 0), 991 FIRMWARE_DOWNLOAD, 0x40 | USB_DIR_OUT, 992 addr >> 8, 0, buf, transfer, HZ); 993 if (err < 0) { 994 kfree(buf); 995 return err; 996 } 997 998 len -= transfer; 999 data += transfer; 1000 addr += transfer; 1001 } 1002 kfree(buf); 1003 1004 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info)) 1005 firm_offset = AR7010_FIRMWARE_TEXT; 1006 else 1007 firm_offset = AR9271_FIRMWARE_TEXT; 1008 1009 /* 1010 * Issue FW download complete command to firmware. 1011 */ 1012 err = usb_control_msg(hif_dev->udev, usb_sndctrlpipe(hif_dev->udev, 0), 1013 FIRMWARE_DOWNLOAD_COMP, 1014 0x40 | USB_DIR_OUT, 1015 firm_offset >> 8, 0, NULL, 0, HZ); 1016 if (err) 1017 return -EIO; 1018 1019 dev_info(&hif_dev->udev->dev, "ath9k_htc: Transferred FW: %s, size: %ld\n", 1020 hif_dev->fw_name, (unsigned long) hif_dev->firmware->size); 1021 1022 return 0; 1023 } 1024 1025 static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev) 1026 { 1027 struct usb_host_interface *alt = &hif_dev->interface->altsetting[0]; 1028 struct usb_endpoint_descriptor *endp; 1029 int ret, idx; 1030 1031 ret = ath9k_hif_usb_download_fw(hif_dev); 1032 if (ret) { 1033 dev_err(&hif_dev->udev->dev, 1034 "ath9k_htc: Firmware - %s download failed\n", 1035 hif_dev->fw_name); 1036 return ret; 1037 } 1038 1039 /* On downloading the firmware to the target, the USB descriptor of EP4 1040 * is 'patched' to change the type of the endpoint to Bulk. This will 1041 * bring down CPU usage during the scan period. 1042 */ 1043 for (idx = 0; idx < alt->desc.bNumEndpoints; idx++) { 1044 endp = &alt->endpoint[idx].desc; 1045 if ((endp->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 1046 == USB_ENDPOINT_XFER_INT) { 1047 endp->bmAttributes &= ~USB_ENDPOINT_XFERTYPE_MASK; 1048 endp->bmAttributes |= USB_ENDPOINT_XFER_BULK; 1049 endp->bInterval = 0; 1050 } 1051 } 1052 1053 /* Alloc URBs */ 1054 ret = ath9k_hif_usb_alloc_urbs(hif_dev); 1055 if (ret) { 1056 dev_err(&hif_dev->udev->dev, 1057 "ath9k_htc: Unable to allocate URBs\n"); 1058 return ret; 1059 } 1060 1061 return 0; 1062 } 1063 1064 static void ath9k_hif_usb_dev_deinit(struct hif_device_usb *hif_dev) 1065 { 1066 ath9k_hif_usb_dealloc_urbs(hif_dev); 1067 } 1068 1069 /* 1070 * If initialization fails or the FW cannot be retrieved, 1071 * detach the device. 1072 */ 1073 static void ath9k_hif_usb_firmware_fail(struct hif_device_usb *hif_dev) 1074 { 1075 struct device *parent = hif_dev->udev->dev.parent; 1076 1077 complete(&hif_dev->fw_done); 1078 1079 if (parent) 1080 device_lock(parent); 1081 1082 device_release_driver(&hif_dev->udev->dev); 1083 1084 if (parent) 1085 device_unlock(parent); 1086 } 1087 1088 static void ath9k_hif_usb_firmware_cb(const struct firmware *fw, void *context) 1089 { 1090 struct hif_device_usb *hif_dev = context; 1091 int ret; 1092 1093 if (!fw) { 1094 dev_err(&hif_dev->udev->dev, 1095 "ath9k_htc: Failed to get firmware %s\n", 1096 hif_dev->fw_name); 1097 goto err_fw; 1098 } 1099 1100 hif_dev->htc_handle = ath9k_htc_hw_alloc(hif_dev, &hif_usb, 1101 &hif_dev->udev->dev); 1102 if (hif_dev->htc_handle == NULL) { 1103 goto err_fw; 1104 } 1105 1106 hif_dev->firmware = fw; 1107 1108 /* Proceed with initialization */ 1109 1110 ret = ath9k_hif_usb_dev_init(hif_dev); 1111 if (ret) 1112 goto err_dev_init; 1113 1114 ret = ath9k_htc_hw_init(hif_dev->htc_handle, 1115 &hif_dev->interface->dev, 1116 hif_dev->usb_device_id->idProduct, 1117 hif_dev->udev->product, 1118 hif_dev->usb_device_id->driver_info); 1119 if (ret) { 1120 ret = -EINVAL; 1121 goto err_htc_hw_init; 1122 } 1123 1124 complete(&hif_dev->fw_done); 1125 1126 return; 1127 1128 err_htc_hw_init: 1129 ath9k_hif_usb_dev_deinit(hif_dev); 1130 err_dev_init: 1131 ath9k_htc_hw_free(hif_dev->htc_handle); 1132 release_firmware(fw); 1133 hif_dev->firmware = NULL; 1134 err_fw: 1135 ath9k_hif_usb_firmware_fail(hif_dev); 1136 } 1137 1138 /* 1139 * An exact copy of the function from zd1211rw. 1140 */ 1141 static int send_eject_command(struct usb_interface *interface) 1142 { 1143 struct usb_device *udev = interface_to_usbdev(interface); 1144 struct usb_host_interface *iface_desc = &interface->altsetting[0]; 1145 struct usb_endpoint_descriptor *endpoint; 1146 unsigned char *cmd; 1147 u8 bulk_out_ep; 1148 int r; 1149 1150 /* Find bulk out endpoint */ 1151 for (r = 1; r >= 0; r--) { 1152 endpoint = &iface_desc->endpoint[r].desc; 1153 if (usb_endpoint_dir_out(endpoint) && 1154 usb_endpoint_xfer_bulk(endpoint)) { 1155 bulk_out_ep = endpoint->bEndpointAddress; 1156 break; 1157 } 1158 } 1159 if (r == -1) { 1160 dev_err(&udev->dev, 1161 "ath9k_htc: Could not find bulk out endpoint\n"); 1162 return -ENODEV; 1163 } 1164 1165 cmd = kzalloc(31, GFP_KERNEL); 1166 if (cmd == NULL) 1167 return -ENODEV; 1168 1169 /* USB bulk command block */ 1170 cmd[0] = 0x55; /* bulk command signature */ 1171 cmd[1] = 0x53; /* bulk command signature */ 1172 cmd[2] = 0x42; /* bulk command signature */ 1173 cmd[3] = 0x43; /* bulk command signature */ 1174 cmd[14] = 6; /* command length */ 1175 1176 cmd[15] = 0x1b; /* SCSI command: START STOP UNIT */ 1177 cmd[19] = 0x2; /* eject disc */ 1178 1179 dev_info(&udev->dev, "Ejecting storage device...\n"); 1180 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, bulk_out_ep), 1181 cmd, 31, NULL, 2000); 1182 kfree(cmd); 1183 if (r) 1184 return r; 1185 1186 /* At this point, the device disconnects and reconnects with the real 1187 * ID numbers. */ 1188 1189 usb_set_intfdata(interface, NULL); 1190 return 0; 1191 } 1192 1193 static int ath9k_hif_usb_probe(struct usb_interface *interface, 1194 const struct usb_device_id *id) 1195 { 1196 struct usb_device *udev = interface_to_usbdev(interface); 1197 struct hif_device_usb *hif_dev; 1198 int ret = 0; 1199 1200 if (id->driver_info == STORAGE_DEVICE) 1201 return send_eject_command(interface); 1202 1203 hif_dev = kzalloc(sizeof(struct hif_device_usb), GFP_KERNEL); 1204 if (!hif_dev) { 1205 ret = -ENOMEM; 1206 goto err_alloc; 1207 } 1208 1209 usb_get_dev(udev); 1210 1211 hif_dev->udev = udev; 1212 hif_dev->interface = interface; 1213 hif_dev->usb_device_id = id; 1214 #ifdef CONFIG_PM 1215 udev->reset_resume = 1; 1216 #endif 1217 usb_set_intfdata(interface, hif_dev); 1218 1219 init_completion(&hif_dev->fw_done); 1220 1221 /* Find out which firmware to load */ 1222 1223 if (IS_AR7010_DEVICE(id->driver_info)) 1224 hif_dev->fw_name = FIRMWARE_AR7010_1_1; 1225 else 1226 hif_dev->fw_name = FIRMWARE_AR9271; 1227 1228 ret = request_firmware_nowait(THIS_MODULE, true, hif_dev->fw_name, 1229 &hif_dev->udev->dev, GFP_KERNEL, 1230 hif_dev, ath9k_hif_usb_firmware_cb); 1231 if (ret) { 1232 dev_err(&hif_dev->udev->dev, 1233 "ath9k_htc: Async request for firmware %s failed\n", 1234 hif_dev->fw_name); 1235 goto err_fw_req; 1236 } 1237 1238 dev_info(&hif_dev->udev->dev, "ath9k_htc: Firmware %s requested\n", 1239 hif_dev->fw_name); 1240 1241 return 0; 1242 1243 err_fw_req: 1244 usb_set_intfdata(interface, NULL); 1245 kfree(hif_dev); 1246 usb_put_dev(udev); 1247 err_alloc: 1248 return ret; 1249 } 1250 1251 static void ath9k_hif_usb_reboot(struct usb_device *udev) 1252 { 1253 u32 reboot_cmd = 0xffffffff; 1254 void *buf; 1255 int ret; 1256 1257 buf = kmemdup(&reboot_cmd, 4, GFP_KERNEL); 1258 if (!buf) 1259 return; 1260 1261 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, USB_REG_OUT_PIPE), 1262 buf, 4, NULL, HZ); 1263 if (ret) 1264 dev_err(&udev->dev, "ath9k_htc: USB reboot failed\n"); 1265 1266 kfree(buf); 1267 } 1268 1269 static void ath9k_hif_usb_disconnect(struct usb_interface *interface) 1270 { 1271 struct usb_device *udev = interface_to_usbdev(interface); 1272 struct hif_device_usb *hif_dev = usb_get_intfdata(interface); 1273 bool unplugged = (udev->state == USB_STATE_NOTATTACHED) ? true : false; 1274 1275 if (!hif_dev) 1276 return; 1277 1278 wait_for_completion(&hif_dev->fw_done); 1279 1280 if (hif_dev->firmware) { 1281 ath9k_htc_hw_deinit(hif_dev->htc_handle, unplugged); 1282 ath9k_htc_hw_free(hif_dev->htc_handle); 1283 ath9k_hif_usb_dev_deinit(hif_dev); 1284 release_firmware(hif_dev->firmware); 1285 } 1286 1287 usb_set_intfdata(interface, NULL); 1288 1289 if (!unplugged && (hif_dev->flags & HIF_USB_START)) 1290 ath9k_hif_usb_reboot(udev); 1291 1292 kfree(hif_dev); 1293 dev_info(&udev->dev, "ath9k_htc: USB layer deinitialized\n"); 1294 usb_put_dev(udev); 1295 } 1296 1297 #ifdef CONFIG_PM 1298 static int ath9k_hif_usb_suspend(struct usb_interface *interface, 1299 pm_message_t message) 1300 { 1301 struct hif_device_usb *hif_dev = usb_get_intfdata(interface); 1302 1303 /* 1304 * The device has to be set to FULLSLEEP mode in case no 1305 * interface is up. 1306 */ 1307 if (!(hif_dev->flags & HIF_USB_START)) 1308 ath9k_htc_suspend(hif_dev->htc_handle); 1309 1310 ath9k_hif_usb_dealloc_urbs(hif_dev); 1311 1312 return 0; 1313 } 1314 1315 static int ath9k_hif_usb_resume(struct usb_interface *interface) 1316 { 1317 struct hif_device_usb *hif_dev = usb_get_intfdata(interface); 1318 struct htc_target *htc_handle = hif_dev->htc_handle; 1319 int ret; 1320 1321 ret = ath9k_hif_usb_alloc_urbs(hif_dev); 1322 if (ret) 1323 return ret; 1324 1325 if (hif_dev->firmware) { 1326 ret = ath9k_hif_usb_download_fw(hif_dev); 1327 if (ret) 1328 goto fail_resume; 1329 } else { 1330 ath9k_hif_usb_dealloc_urbs(hif_dev); 1331 return -EIO; 1332 } 1333 1334 mdelay(100); 1335 1336 ret = ath9k_htc_resume(htc_handle); 1337 1338 if (ret) 1339 goto fail_resume; 1340 1341 return 0; 1342 1343 fail_resume: 1344 ath9k_hif_usb_dealloc_urbs(hif_dev); 1345 1346 return ret; 1347 } 1348 #endif 1349 1350 static struct usb_driver ath9k_hif_usb_driver = { 1351 .name = KBUILD_MODNAME, 1352 .probe = ath9k_hif_usb_probe, 1353 .disconnect = ath9k_hif_usb_disconnect, 1354 #ifdef CONFIG_PM 1355 .suspend = ath9k_hif_usb_suspend, 1356 .resume = ath9k_hif_usb_resume, 1357 .reset_resume = ath9k_hif_usb_resume, 1358 #endif 1359 .id_table = ath9k_hif_usb_ids, 1360 .soft_unbind = 1, 1361 .disable_hub_initiated_lpm = 1, 1362 }; 1363 1364 int ath9k_hif_usb_init(void) 1365 { 1366 return usb_register(&ath9k_hif_usb_driver); 1367 } 1368 1369 void ath9k_hif_usb_exit(void) 1370 { 1371 usb_deregister(&ath9k_hif_usb_driver); 1372 } 1373