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