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, 1001 USB_MSG_TIMEOUT); 1002 if (err < 0) { 1003 kfree(buf); 1004 return err; 1005 } 1006 1007 len -= transfer; 1008 data += transfer; 1009 addr += transfer; 1010 } 1011 kfree(buf); 1012 1013 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info)) 1014 firm_offset = AR7010_FIRMWARE_TEXT; 1015 else 1016 firm_offset = AR9271_FIRMWARE_TEXT; 1017 1018 /* 1019 * Issue FW download complete command to firmware. 1020 */ 1021 err = usb_control_msg(hif_dev->udev, usb_sndctrlpipe(hif_dev->udev, 0), 1022 FIRMWARE_DOWNLOAD_COMP, 1023 0x40 | USB_DIR_OUT, 1024 firm_offset >> 8, 0, NULL, 0, USB_MSG_TIMEOUT); 1025 if (err) 1026 return -EIO; 1027 1028 dev_info(&hif_dev->udev->dev, "ath9k_htc: Transferred FW: %s, size: %ld\n", 1029 hif_dev->fw_name, (unsigned long) hif_dev->fw_size); 1030 1031 return 0; 1032 } 1033 1034 static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev) 1035 { 1036 int ret; 1037 1038 ret = ath9k_hif_usb_download_fw(hif_dev); 1039 if (ret) { 1040 dev_err(&hif_dev->udev->dev, 1041 "ath9k_htc: Firmware - %s download failed\n", 1042 hif_dev->fw_name); 1043 return ret; 1044 } 1045 1046 /* Alloc URBs */ 1047 ret = ath9k_hif_usb_alloc_urbs(hif_dev); 1048 if (ret) { 1049 dev_err(&hif_dev->udev->dev, 1050 "ath9k_htc: Unable to allocate URBs\n"); 1051 return ret; 1052 } 1053 1054 return 0; 1055 } 1056 1057 static void ath9k_hif_usb_dev_deinit(struct hif_device_usb *hif_dev) 1058 { 1059 ath9k_hif_usb_dealloc_urbs(hif_dev); 1060 } 1061 1062 /* 1063 * If initialization fails or the FW cannot be retrieved, 1064 * detach the device. 1065 */ 1066 static void ath9k_hif_usb_firmware_fail(struct hif_device_usb *hif_dev) 1067 { 1068 struct device *dev = &hif_dev->udev->dev; 1069 struct device *parent = dev->parent; 1070 1071 complete_all(&hif_dev->fw_done); 1072 1073 if (parent) 1074 device_lock(parent); 1075 1076 device_release_driver(dev); 1077 1078 if (parent) 1079 device_unlock(parent); 1080 } 1081 1082 static void ath9k_hif_usb_firmware_cb(const struct firmware *fw, void *context); 1083 1084 /* taken from iwlwifi */ 1085 static int ath9k_hif_request_firmware(struct hif_device_usb *hif_dev, 1086 bool first) 1087 { 1088 char index[8], *chip; 1089 int ret; 1090 1091 if (first) { 1092 if (htc_use_dev_fw) { 1093 hif_dev->fw_minor_index = FIRMWARE_MINOR_IDX_MAX + 1; 1094 sprintf(index, "%s", "dev"); 1095 } else { 1096 hif_dev->fw_minor_index = FIRMWARE_MINOR_IDX_MAX; 1097 sprintf(index, "%d", hif_dev->fw_minor_index); 1098 } 1099 } else { 1100 hif_dev->fw_minor_index--; 1101 sprintf(index, "%d", hif_dev->fw_minor_index); 1102 } 1103 1104 /* test for FW 1.3 */ 1105 if (MAJOR_VERSION_REQ == 1 && hif_dev->fw_minor_index == 3) { 1106 const char *filename; 1107 1108 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info)) 1109 filename = FIRMWARE_AR7010_1_1; 1110 else 1111 filename = FIRMWARE_AR9271; 1112 1113 /* expected fw locations: 1114 * - htc_9271.fw (stable version 1.3, depricated) 1115 */ 1116 snprintf(hif_dev->fw_name, sizeof(hif_dev->fw_name), 1117 "%s", filename); 1118 1119 } else if (hif_dev->fw_minor_index < FIRMWARE_MINOR_IDX_MIN) { 1120 dev_err(&hif_dev->udev->dev, "no suitable firmware found!\n"); 1121 1122 return -ENOENT; 1123 } else { 1124 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info)) 1125 chip = "7010"; 1126 else 1127 chip = "9271"; 1128 1129 /* expected fw locations: 1130 * - ath9k_htc/htc_9271-1.dev.0.fw (development version) 1131 * - ath9k_htc/htc_9271-1.4.0.fw (stable version) 1132 */ 1133 snprintf(hif_dev->fw_name, sizeof(hif_dev->fw_name), 1134 "%s/htc_%s-%d.%s.0.fw", HTC_FW_PATH, 1135 chip, MAJOR_VERSION_REQ, index); 1136 } 1137 1138 ret = request_firmware_nowait(THIS_MODULE, true, hif_dev->fw_name, 1139 &hif_dev->udev->dev, GFP_KERNEL, 1140 hif_dev, ath9k_hif_usb_firmware_cb); 1141 if (ret) { 1142 dev_err(&hif_dev->udev->dev, 1143 "ath9k_htc: Async request for firmware %s failed\n", 1144 hif_dev->fw_name); 1145 return ret; 1146 } 1147 1148 dev_info(&hif_dev->udev->dev, "ath9k_htc: Firmware %s requested\n", 1149 hif_dev->fw_name); 1150 1151 return ret; 1152 } 1153 1154 static void ath9k_hif_usb_firmware_cb(const struct firmware *fw, void *context) 1155 { 1156 struct hif_device_usb *hif_dev = context; 1157 int ret; 1158 1159 if (!fw) { 1160 ret = ath9k_hif_request_firmware(hif_dev, false); 1161 if (!ret) 1162 return; 1163 1164 dev_err(&hif_dev->udev->dev, 1165 "ath9k_htc: Failed to get firmware %s\n", 1166 hif_dev->fw_name); 1167 goto err_fw; 1168 } 1169 1170 hif_dev->htc_handle = ath9k_htc_hw_alloc(hif_dev, &hif_usb, 1171 &hif_dev->udev->dev); 1172 if (hif_dev->htc_handle == NULL) 1173 goto err_dev_alloc; 1174 1175 hif_dev->fw_data = fw->data; 1176 hif_dev->fw_size = fw->size; 1177 1178 /* Proceed with initialization */ 1179 1180 ret = ath9k_hif_usb_dev_init(hif_dev); 1181 if (ret) 1182 goto err_dev_init; 1183 1184 ret = ath9k_htc_hw_init(hif_dev->htc_handle, 1185 &hif_dev->interface->dev, 1186 hif_dev->usb_device_id->idProduct, 1187 hif_dev->udev->product, 1188 hif_dev->usb_device_id->driver_info); 1189 if (ret) { 1190 ret = -EINVAL; 1191 goto err_htc_hw_init; 1192 } 1193 1194 release_firmware(fw); 1195 hif_dev->flags |= HIF_USB_READY; 1196 complete_all(&hif_dev->fw_done); 1197 1198 return; 1199 1200 err_htc_hw_init: 1201 ath9k_hif_usb_dev_deinit(hif_dev); 1202 err_dev_init: 1203 ath9k_htc_hw_free(hif_dev->htc_handle); 1204 err_dev_alloc: 1205 release_firmware(fw); 1206 err_fw: 1207 ath9k_hif_usb_firmware_fail(hif_dev); 1208 } 1209 1210 /* 1211 * An exact copy of the function from zd1211rw. 1212 */ 1213 static int send_eject_command(struct usb_interface *interface) 1214 { 1215 struct usb_device *udev = interface_to_usbdev(interface); 1216 struct usb_host_interface *iface_desc = &interface->altsetting[0]; 1217 struct usb_endpoint_descriptor *endpoint; 1218 unsigned char *cmd; 1219 u8 bulk_out_ep; 1220 int r; 1221 1222 /* Find bulk out endpoint */ 1223 for (r = 1; r >= 0; r--) { 1224 endpoint = &iface_desc->endpoint[r].desc; 1225 if (usb_endpoint_dir_out(endpoint) && 1226 usb_endpoint_xfer_bulk(endpoint)) { 1227 bulk_out_ep = endpoint->bEndpointAddress; 1228 break; 1229 } 1230 } 1231 if (r == -1) { 1232 dev_err(&udev->dev, 1233 "ath9k_htc: Could not find bulk out endpoint\n"); 1234 return -ENODEV; 1235 } 1236 1237 cmd = kzalloc(31, GFP_KERNEL); 1238 if (cmd == NULL) 1239 return -ENODEV; 1240 1241 /* USB bulk command block */ 1242 cmd[0] = 0x55; /* bulk command signature */ 1243 cmd[1] = 0x53; /* bulk command signature */ 1244 cmd[2] = 0x42; /* bulk command signature */ 1245 cmd[3] = 0x43; /* bulk command signature */ 1246 cmd[14] = 6; /* command length */ 1247 1248 cmd[15] = 0x1b; /* SCSI command: START STOP UNIT */ 1249 cmd[19] = 0x2; /* eject disc */ 1250 1251 dev_info(&udev->dev, "Ejecting storage device...\n"); 1252 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, bulk_out_ep), 1253 cmd, 31, NULL, 2 * USB_MSG_TIMEOUT); 1254 kfree(cmd); 1255 if (r) 1256 return r; 1257 1258 /* At this point, the device disconnects and reconnects with the real 1259 * ID numbers. */ 1260 1261 usb_set_intfdata(interface, NULL); 1262 return 0; 1263 } 1264 1265 static int ath9k_hif_usb_probe(struct usb_interface *interface, 1266 const struct usb_device_id *id) 1267 { 1268 struct usb_device *udev = interface_to_usbdev(interface); 1269 struct hif_device_usb *hif_dev; 1270 int ret = 0; 1271 1272 if (id->driver_info == STORAGE_DEVICE) 1273 return send_eject_command(interface); 1274 1275 hif_dev = kzalloc(sizeof(struct hif_device_usb), GFP_KERNEL); 1276 if (!hif_dev) { 1277 ret = -ENOMEM; 1278 goto err_alloc; 1279 } 1280 1281 usb_get_dev(udev); 1282 1283 hif_dev->udev = udev; 1284 hif_dev->interface = interface; 1285 hif_dev->usb_device_id = id; 1286 #ifdef CONFIG_PM 1287 udev->reset_resume = 1; 1288 #endif 1289 usb_set_intfdata(interface, hif_dev); 1290 1291 init_completion(&hif_dev->fw_done); 1292 1293 ret = ath9k_hif_request_firmware(hif_dev, true); 1294 if (ret) 1295 goto err_fw_req; 1296 1297 return ret; 1298 1299 err_fw_req: 1300 usb_set_intfdata(interface, NULL); 1301 kfree(hif_dev); 1302 usb_put_dev(udev); 1303 err_alloc: 1304 return ret; 1305 } 1306 1307 static void ath9k_hif_usb_reboot(struct usb_device *udev) 1308 { 1309 u32 reboot_cmd = 0xffffffff; 1310 void *buf; 1311 int ret; 1312 1313 buf = kmemdup(&reboot_cmd, 4, GFP_KERNEL); 1314 if (!buf) 1315 return; 1316 1317 ret = usb_interrupt_msg(udev, usb_sndintpipe(udev, USB_REG_OUT_PIPE), 1318 buf, 4, NULL, USB_MSG_TIMEOUT); 1319 if (ret) 1320 dev_err(&udev->dev, "ath9k_htc: USB reboot failed\n"); 1321 1322 kfree(buf); 1323 } 1324 1325 static void ath9k_hif_usb_disconnect(struct usb_interface *interface) 1326 { 1327 struct usb_device *udev = interface_to_usbdev(interface); 1328 struct hif_device_usb *hif_dev = usb_get_intfdata(interface); 1329 bool unplugged = (udev->state == USB_STATE_NOTATTACHED) ? true : false; 1330 1331 if (!hif_dev) 1332 return; 1333 1334 wait_for_completion(&hif_dev->fw_done); 1335 1336 if (hif_dev->flags & HIF_USB_READY) { 1337 ath9k_htc_hw_deinit(hif_dev->htc_handle, unplugged); 1338 ath9k_htc_hw_free(hif_dev->htc_handle); 1339 ath9k_hif_usb_dev_deinit(hif_dev); 1340 } 1341 1342 usb_set_intfdata(interface, NULL); 1343 1344 /* If firmware was loaded we should drop it 1345 * go back to first stage bootloader. */ 1346 if (!unplugged && (hif_dev->flags & HIF_USB_READY)) 1347 ath9k_hif_usb_reboot(udev); 1348 1349 kfree(hif_dev); 1350 dev_info(&udev->dev, "ath9k_htc: USB layer deinitialized\n"); 1351 usb_put_dev(udev); 1352 } 1353 1354 #ifdef CONFIG_PM 1355 static int ath9k_hif_usb_suspend(struct usb_interface *interface, 1356 pm_message_t message) 1357 { 1358 struct hif_device_usb *hif_dev = usb_get_intfdata(interface); 1359 1360 /* 1361 * The device has to be set to FULLSLEEP mode in case no 1362 * interface is up. 1363 */ 1364 if (!(hif_dev->flags & HIF_USB_START)) 1365 ath9k_htc_suspend(hif_dev->htc_handle); 1366 1367 wait_for_completion(&hif_dev->fw_done); 1368 1369 if (hif_dev->flags & HIF_USB_READY) 1370 ath9k_hif_usb_dealloc_urbs(hif_dev); 1371 1372 return 0; 1373 } 1374 1375 static int ath9k_hif_usb_resume(struct usb_interface *interface) 1376 { 1377 struct hif_device_usb *hif_dev = usb_get_intfdata(interface); 1378 struct htc_target *htc_handle = hif_dev->htc_handle; 1379 int ret; 1380 const struct firmware *fw; 1381 1382 ret = ath9k_hif_usb_alloc_urbs(hif_dev); 1383 if (ret) 1384 return ret; 1385 1386 if (hif_dev->flags & HIF_USB_READY) { 1387 /* request cached firmware during suspend/resume cycle */ 1388 ret = request_firmware(&fw, hif_dev->fw_name, 1389 &hif_dev->udev->dev); 1390 if (ret) 1391 goto fail_resume; 1392 1393 hif_dev->fw_data = fw->data; 1394 hif_dev->fw_size = fw->size; 1395 ret = ath9k_hif_usb_download_fw(hif_dev); 1396 release_firmware(fw); 1397 if (ret) 1398 goto fail_resume; 1399 } else { 1400 ath9k_hif_usb_dealloc_urbs(hif_dev); 1401 return -EIO; 1402 } 1403 1404 mdelay(100); 1405 1406 ret = ath9k_htc_resume(htc_handle); 1407 1408 if (ret) 1409 goto fail_resume; 1410 1411 return 0; 1412 1413 fail_resume: 1414 ath9k_hif_usb_dealloc_urbs(hif_dev); 1415 1416 return ret; 1417 } 1418 #endif 1419 1420 static struct usb_driver ath9k_hif_usb_driver = { 1421 .name = KBUILD_MODNAME, 1422 .probe = ath9k_hif_usb_probe, 1423 .disconnect = ath9k_hif_usb_disconnect, 1424 #ifdef CONFIG_PM 1425 .suspend = ath9k_hif_usb_suspend, 1426 .resume = ath9k_hif_usb_resume, 1427 .reset_resume = ath9k_hif_usb_resume, 1428 #endif 1429 .id_table = ath9k_hif_usb_ids, 1430 .soft_unbind = 1, 1431 .disable_hub_initiated_lpm = 1, 1432 }; 1433 1434 int ath9k_hif_usb_init(void) 1435 { 1436 return usb_register(&ath9k_hif_usb_driver); 1437 } 1438 1439 void ath9k_hif_usb_exit(void) 1440 { 1441 usb_deregister(&ath9k_hif_usb_driver); 1442 } 1443