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