1546 lines · c
1/*2 * Copyright (c) 2010-2011 Atheros Communications Inc.3 *4 * Permission to use, copy, modify, and/or distribute this software for any5 * purpose with or without fee is hereby granted, provided that the above6 * copyright notice and this permission notice appear in all copies.7 *8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.15 */16 17#include <linux/unaligned.h>18#include "htc.h"19 20MODULE_FIRMWARE(HTC_7010_MODULE_FW);21MODULE_FIRMWARE(HTC_9271_MODULE_FW);22 23static const 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(0x07b8, 0x9271) }, /* Altai WA1011N-GU */28 { USB_DEVICE(0x07D1, 0x3A10) }, /* Dlink Wireless 150 */29 { USB_DEVICE(0x13D3, 0x3327) }, /* Azurewave */30 { USB_DEVICE(0x13D3, 0x3328) }, /* Azurewave */31 { USB_DEVICE(0x13D3, 0x3346) }, /* IMC Networks */32 { USB_DEVICE(0x13D3, 0x3348) }, /* Azurewave */33 { USB_DEVICE(0x13D3, 0x3349) }, /* Azurewave */34 { USB_DEVICE(0x13D3, 0x3350) }, /* Azurewave */35 { USB_DEVICE(0x04CA, 0x4605) }, /* Liteon */36 { USB_DEVICE(0x040D, 0x3801) }, /* VIA */37 { USB_DEVICE(0x0cf3, 0xb003) }, /* Ubiquiti WifiStation Ext */38 { USB_DEVICE(0x0cf3, 0xb002) }, /* Ubiquiti WifiStation */39 { USB_DEVICE(0x057c, 0x8403) }, /* AVM FRITZ!WLAN 11N v2 USB */40 { USB_DEVICE(0x0471, 0x209e) }, /* Philips (or NXP) PTA01 */41 { USB_DEVICE(0x1eda, 0x2315) }, /* AirTies */42 43 { USB_DEVICE(0x0cf3, 0x7015),44 .driver_info = AR9287_USB }, /* Atheros */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 67MODULE_DEVICE_TABLE(usb, ath9k_hif_usb_ids);68 69static int __hif_usb_tx(struct hif_device_usb *hif_dev);70 71static void hif_usb_regout_cb(struct urb *urb)72{73 struct cmd_buf *cmd = 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;94free:95 kfree_skb(cmd->skb);96 kfree(cmd);97}98 99static 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 135static void hif_usb_mgmt_cb(struct urb *urb)136{137 struct cmd_buf *cmd = urb->context;138 struct hif_device_usb *hif_dev;139 unsigned long flags;140 bool txok = true;141 142 if (!cmd || !cmd->skb || !cmd->hif_dev)143 return;144 145 hif_dev = cmd->hif_dev;146 147 switch (urb->status) {148 case 0:149 break;150 case -ENOENT:151 case -ECONNRESET:152 case -ENODEV:153 case -ESHUTDOWN:154 txok = false;155 156 /*157 * If the URBs are being flushed, no need to complete158 * this packet.159 */160 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);161 if (hif_dev->tx.flags & HIF_USB_TX_FLUSH) {162 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);163 dev_kfree_skb_any(cmd->skb);164 kfree(cmd);165 return;166 }167 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);168 169 break;170 default:171 txok = false;172 break;173 }174 175 skb_pull(cmd->skb, 4);176 ath9k_htc_txcompletion_cb(cmd->hif_dev->htc_handle,177 cmd->skb, txok);178 kfree(cmd);179}180 181static int hif_usb_send_mgmt(struct hif_device_usb *hif_dev,182 struct sk_buff *skb)183{184 struct urb *urb;185 struct cmd_buf *cmd;186 int ret = 0;187 __le16 *hdr;188 189 urb = usb_alloc_urb(0, GFP_ATOMIC);190 if (urb == NULL)191 return -ENOMEM;192 193 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);194 if (cmd == NULL) {195 usb_free_urb(urb);196 return -ENOMEM;197 }198 199 cmd->skb = skb;200 cmd->hif_dev = hif_dev;201 202 hdr = skb_push(skb, 4);203 *hdr++ = cpu_to_le16(skb->len - 4);204 *hdr++ = cpu_to_le16(ATH_USB_TX_STREAM_MODE_TAG);205 206 usb_fill_bulk_urb(urb, hif_dev->udev,207 usb_sndbulkpipe(hif_dev->udev, USB_WLAN_TX_PIPE),208 skb->data, skb->len,209 hif_usb_mgmt_cb, cmd);210 211 usb_anchor_urb(urb, &hif_dev->mgmt_submitted);212 ret = usb_submit_urb(urb, GFP_ATOMIC);213 if (ret) {214 usb_unanchor_urb(urb);215 kfree(cmd);216 }217 usb_free_urb(urb);218 219 return ret;220}221 222static inline void ath9k_skb_queue_purge(struct hif_device_usb *hif_dev,223 struct sk_buff_head *list)224{225 struct sk_buff *skb;226 227 while ((skb = __skb_dequeue(list)) != NULL) {228 dev_kfree_skb_any(skb);229 }230}231 232static inline void ath9k_skb_queue_complete(struct hif_device_usb *hif_dev,233 struct sk_buff_head *queue,234 bool txok)235{236 struct sk_buff *skb;237 238 while ((skb = __skb_dequeue(queue)) != NULL) {239#ifdef CONFIG_ATH9K_HTC_DEBUGFS240 int ln = skb->len;241#endif242 ath9k_htc_txcompletion_cb(hif_dev->htc_handle,243 skb, txok);244 if (txok) {245 TX_STAT_INC(hif_dev, skb_success);246 TX_STAT_ADD(hif_dev, skb_success_bytes, ln);247 }248 else249 TX_STAT_INC(hif_dev, skb_failed);250 }251}252 253static void hif_usb_tx_cb(struct urb *urb)254{255 struct tx_buf *tx_buf = urb->context;256 struct hif_device_usb *hif_dev;257 bool txok = true;258 259 if (!tx_buf || !tx_buf->hif_dev)260 return;261 262 hif_dev = tx_buf->hif_dev;263 264 switch (urb->status) {265 case 0:266 break;267 case -ENOENT:268 case -ECONNRESET:269 case -ENODEV:270 case -ESHUTDOWN:271 txok = false;272 273 /*274 * If the URBs are being flushed, no need to add this275 * URB to the free list.276 */277 spin_lock(&hif_dev->tx.tx_lock);278 if (hif_dev->tx.flags & HIF_USB_TX_FLUSH) {279 spin_unlock(&hif_dev->tx.tx_lock);280 ath9k_skb_queue_purge(hif_dev, &tx_buf->skb_queue);281 return;282 }283 spin_unlock(&hif_dev->tx.tx_lock);284 285 break;286 default:287 txok = false;288 break;289 }290 291 ath9k_skb_queue_complete(hif_dev, &tx_buf->skb_queue, txok);292 293 /* Re-initialize the SKB queue */294 tx_buf->len = tx_buf->offset = 0;295 __skb_queue_head_init(&tx_buf->skb_queue);296 297 /* Add this TX buffer to the free list */298 spin_lock(&hif_dev->tx.tx_lock);299 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf);300 hif_dev->tx.tx_buf_cnt++;301 if (!(hif_dev->tx.flags & HIF_USB_TX_STOP))302 __hif_usb_tx(hif_dev); /* Check for pending SKBs */303 TX_STAT_INC(hif_dev, buf_completed);304 spin_unlock(&hif_dev->tx.tx_lock);305}306 307/* TX lock has to be taken */308static int __hif_usb_tx(struct hif_device_usb *hif_dev)309{310 struct tx_buf *tx_buf = NULL;311 struct sk_buff *nskb = NULL;312 int ret = 0, i;313 u16 tx_skb_cnt = 0;314 u8 *buf;315 __le16 *hdr;316 317 if (hif_dev->tx.tx_skb_cnt == 0)318 return 0;319 320 /* Check if a free TX buffer is available */321 if (list_empty(&hif_dev->tx.tx_buf))322 return 0;323 324 tx_buf = list_first_entry(&hif_dev->tx.tx_buf, struct tx_buf, list);325 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_pending);326 hif_dev->tx.tx_buf_cnt--;327 328 tx_skb_cnt = min_t(u16, hif_dev->tx.tx_skb_cnt, MAX_TX_AGGR_NUM);329 330 for (i = 0; i < tx_skb_cnt; i++) {331 nskb = __skb_dequeue(&hif_dev->tx.tx_skb_queue);332 333 /* Should never be NULL */334 BUG_ON(!nskb);335 336 hif_dev->tx.tx_skb_cnt--;337 338 buf = tx_buf->buf;339 buf += tx_buf->offset;340 hdr = (__le16 *)buf;341 *hdr++ = cpu_to_le16(nskb->len);342 *hdr++ = cpu_to_le16(ATH_USB_TX_STREAM_MODE_TAG);343 buf += 4;344 memcpy(buf, nskb->data, nskb->len);345 tx_buf->len = nskb->len + 4;346 347 if (i < (tx_skb_cnt - 1))348 tx_buf->offset += (((tx_buf->len - 1) / 4) + 1) * 4;349 350 if (i == (tx_skb_cnt - 1))351 tx_buf->len += tx_buf->offset;352 353 __skb_queue_tail(&tx_buf->skb_queue, nskb);354 TX_STAT_INC(hif_dev, skb_queued);355 }356 357 usb_fill_bulk_urb(tx_buf->urb, hif_dev->udev,358 usb_sndbulkpipe(hif_dev->udev, USB_WLAN_TX_PIPE),359 tx_buf->buf, tx_buf->len,360 hif_usb_tx_cb, tx_buf);361 362 ret = usb_submit_urb(tx_buf->urb, GFP_ATOMIC);363 if (ret) {364 tx_buf->len = tx_buf->offset = 0;365 ath9k_skb_queue_complete(hif_dev, &tx_buf->skb_queue, false);366 __skb_queue_head_init(&tx_buf->skb_queue);367 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf);368 hif_dev->tx.tx_buf_cnt++;369 } else {370 TX_STAT_INC(hif_dev, buf_queued);371 }372 373 return ret;374}375 376static 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 424static void hif_usb_start(void *hif_handle)425{426 struct hif_device_usb *hif_dev = 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 436static void hif_usb_stop(void *hif_handle)437{438 struct hif_device_usb *hif_dev = 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 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);450 list_for_each_entry_safe(tx_buf, tx_buf_tmp,451 &hif_dev->tx.tx_pending, list) {452 usb_get_urb(tx_buf->urb);453 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);454 usb_kill_urb(tx_buf->urb);455 list_del(&tx_buf->list);456 usb_free_urb(tx_buf->urb);457 kfree(tx_buf->buf);458 kfree(tx_buf);459 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);460 }461 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);462 463 usb_kill_anchored_urbs(&hif_dev->mgmt_submitted);464}465 466static int hif_usb_send(void *hif_handle, u8 pipe_id, struct sk_buff *skb)467{468 struct hif_device_usb *hif_dev = hif_handle;469 int ret = 0;470 471 switch (pipe_id) {472 case USB_WLAN_TX_PIPE:473 ret = hif_usb_send_tx(hif_dev, skb);474 break;475 case USB_REG_OUT_PIPE:476 ret = hif_usb_send_regout(hif_dev, skb);477 break;478 default:479 dev_err(&hif_dev->udev->dev,480 "ath9k_htc: Invalid TX pipe: %d\n", pipe_id);481 ret = -EINVAL;482 break;483 }484 485 return ret;486}487 488static inline bool check_index(struct sk_buff *skb, u8 idx)489{490 struct ath9k_htc_tx_ctl *tx_ctl;491 492 tx_ctl = HTC_SKB_CB(skb);493 494 if ((tx_ctl->type == ATH9K_HTC_AMPDU) &&495 (tx_ctl->sta_idx == idx))496 return true;497 498 return false;499}500 501static void hif_usb_sta_drain(void *hif_handle, u8 idx)502{503 struct hif_device_usb *hif_dev = hif_handle;504 struct sk_buff *skb, *tmp;505 unsigned long flags;506 507 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);508 509 skb_queue_walk_safe(&hif_dev->tx.tx_skb_queue, skb, tmp) {510 if (check_index(skb, idx)) {511 __skb_unlink(skb, &hif_dev->tx.tx_skb_queue);512 ath9k_htc_txcompletion_cb(hif_dev->htc_handle,513 skb, false);514 hif_dev->tx.tx_skb_cnt--;515 TX_STAT_INC(hif_dev, skb_failed);516 }517 }518 519 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);520}521 522static struct ath9k_htc_hif hif_usb = {523 .transport = ATH9K_HIF_USB,524 .name = "ath9k_hif_usb",525 526 .control_ul_pipe = USB_REG_OUT_PIPE,527 .control_dl_pipe = USB_REG_IN_PIPE,528 529 .start = hif_usb_start,530 .stop = hif_usb_stop,531 .sta_drain = hif_usb_sta_drain,532 .send = hif_usb_send,533};534 535/* Need to free remain_skb allocated in ath9k_hif_usb_rx_stream536 * in case ath9k_hif_usb_rx_stream wasn't called next time to537 * process the buffer and subsequently free it.538 */539static void ath9k_hif_usb_free_rx_remain_skb(struct hif_device_usb *hif_dev)540{541 unsigned long flags;542 543 spin_lock_irqsave(&hif_dev->rx_lock, flags);544 if (hif_dev->remain_skb) {545 dev_kfree_skb_any(hif_dev->remain_skb);546 hif_dev->remain_skb = NULL;547 hif_dev->rx_remain_len = 0;548 RX_STAT_INC(hif_dev, skb_dropped);549 }550 spin_unlock_irqrestore(&hif_dev->rx_lock, flags);551}552 553static void ath9k_hif_usb_rx_stream(struct hif_device_usb *hif_dev,554 struct sk_buff *skb)555{556 struct sk_buff *nskb, *skb_pool[MAX_PKT_NUM_IN_TRANSFER];557 int index = 0, i, len = skb->len;558 int rx_remain_len, rx_pkt_len;559 u16 pool_index = 0;560 u8 *ptr;561 562 spin_lock(&hif_dev->rx_lock);563 564 rx_remain_len = hif_dev->rx_remain_len;565 rx_pkt_len = hif_dev->rx_transfer_len;566 567 if (rx_remain_len != 0) {568 struct sk_buff *remain_skb = hif_dev->remain_skb;569 570 if (remain_skb) {571 ptr = (u8 *) remain_skb->data;572 573 index = rx_remain_len;574 rx_remain_len -= hif_dev->rx_pad_len;575 ptr += rx_pkt_len;576 577 memcpy(ptr, skb->data, rx_remain_len);578 579 rx_pkt_len += rx_remain_len;580 skb_put(remain_skb, rx_pkt_len);581 582 skb_pool[pool_index++] = remain_skb;583 hif_dev->remain_skb = NULL;584 hif_dev->rx_remain_len = 0;585 } else {586 index = rx_remain_len;587 }588 }589 590 spin_unlock(&hif_dev->rx_lock);591 592 while (index < len) {593 u16 pkt_len;594 u16 pkt_tag;595 u16 pad_len;596 int chk_idx;597 598 ptr = (u8 *) skb->data;599 600 pkt_len = get_unaligned_le16(ptr + index);601 pkt_tag = get_unaligned_le16(ptr + index + 2);602 603 /* It is supposed that if we have an invalid pkt_tag or604 * pkt_len then the whole input SKB is considered invalid605 * and dropped; the associated packets already in skb_pool606 * are dropped, too.607 */608 if (pkt_tag != ATH_USB_RX_STREAM_MODE_TAG) {609 RX_STAT_INC(hif_dev, skb_dropped);610 goto invalid_pkt;611 }612 613 if (pkt_len > 2 * MAX_RX_BUF_SIZE) {614 dev_err(&hif_dev->udev->dev,615 "ath9k_htc: invalid pkt_len (%x)\n", pkt_len);616 RX_STAT_INC(hif_dev, skb_dropped);617 goto invalid_pkt;618 }619 620 pad_len = 4 - (pkt_len & 0x3);621 if (pad_len == 4)622 pad_len = 0;623 624 chk_idx = index;625 index = index + 4 + pkt_len + pad_len;626 627 if (index > MAX_RX_BUF_SIZE) {628 spin_lock(&hif_dev->rx_lock);629 nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC);630 if (!nskb) {631 dev_err(&hif_dev->udev->dev,632 "ath9k_htc: RX memory allocation error\n");633 spin_unlock(&hif_dev->rx_lock);634 goto err;635 }636 637 hif_dev->rx_remain_len = index - MAX_RX_BUF_SIZE;638 hif_dev->rx_transfer_len =639 MAX_RX_BUF_SIZE - chk_idx - 4;640 hif_dev->rx_pad_len = pad_len;641 642 skb_reserve(nskb, 32);643 RX_STAT_INC(hif_dev, skb_allocated);644 645 memcpy(nskb->data, &(skb->data[chk_idx+4]),646 hif_dev->rx_transfer_len);647 648 /* Record the buffer pointer */649 hif_dev->remain_skb = nskb;650 spin_unlock(&hif_dev->rx_lock);651 } else {652 if (pool_index == MAX_PKT_NUM_IN_TRANSFER) {653 dev_err(&hif_dev->udev->dev,654 "ath9k_htc: over RX MAX_PKT_NUM\n");655 goto err;656 }657 nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC);658 if (!nskb) {659 dev_err(&hif_dev->udev->dev,660 "ath9k_htc: RX memory allocation error\n");661 goto err;662 }663 skb_reserve(nskb, 32);664 RX_STAT_INC(hif_dev, skb_allocated);665 666 memcpy(nskb->data, &(skb->data[chk_idx+4]), pkt_len);667 skb_put(nskb, pkt_len);668 skb_pool[pool_index++] = nskb;669 }670 }671 672err:673 for (i = 0; i < pool_index; i++) {674 RX_STAT_ADD(hif_dev, skb_completed_bytes, skb_pool[i]->len);675 ath9k_htc_rx_msg(hif_dev->htc_handle, skb_pool[i],676 skb_pool[i]->len, USB_WLAN_RX_PIPE);677 RX_STAT_INC(hif_dev, skb_completed);678 }679 return;680invalid_pkt:681 for (i = 0; i < pool_index; i++) {682 dev_kfree_skb_any(skb_pool[i]);683 RX_STAT_INC(hif_dev, skb_dropped);684 }685 return;686}687 688static void ath9k_hif_usb_rx_cb(struct urb *urb)689{690 struct rx_buf *rx_buf = urb->context;691 struct hif_device_usb *hif_dev = rx_buf->hif_dev;692 struct sk_buff *skb = rx_buf->skb;693 int ret;694 695 if (!skb)696 return;697 698 if (!hif_dev)699 goto free;700 701 switch (urb->status) {702 case 0:703 break;704 case -ENOENT:705 case -ECONNRESET:706 case -ENODEV:707 case -ESHUTDOWN:708 goto free;709 default:710 goto resubmit;711 }712 713 if (likely(urb->actual_length != 0)) {714 skb_put(skb, urb->actual_length);715 ath9k_hif_usb_rx_stream(hif_dev, skb);716 }717 718resubmit:719 __skb_set_length(skb, 0);720 721 usb_anchor_urb(urb, &hif_dev->rx_submitted);722 ret = usb_submit_urb(urb, GFP_ATOMIC);723 if (ret) {724 usb_unanchor_urb(urb);725 goto free;726 }727 728 return;729free:730 kfree_skb(skb);731 kfree(rx_buf);732}733 734static void ath9k_hif_usb_reg_in_cb(struct urb *urb)735{736 struct rx_buf *rx_buf = urb->context;737 struct hif_device_usb *hif_dev = rx_buf->hif_dev;738 struct sk_buff *skb = rx_buf->skb;739 int ret;740 741 if (!skb)742 return;743 744 if (!hif_dev)745 goto free_skb;746 747 switch (urb->status) {748 case 0:749 break;750 case -ENOENT:751 case -ECONNRESET:752 case -ENODEV:753 case -ESHUTDOWN:754 goto free_skb;755 default:756 __skb_set_length(skb, 0);757 758 goto resubmit;759 }760 761 if (likely(urb->actual_length != 0)) {762 skb_put(skb, urb->actual_length);763 764 /*765 * Process the command first.766 * skb is either freed here or passed to be767 * managed to another callback function.768 */769 ath9k_htc_rx_msg(hif_dev->htc_handle, skb,770 skb->len, USB_REG_IN_PIPE);771 772 skb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_ATOMIC);773 if (!skb) {774 dev_err(&hif_dev->udev->dev,775 "ath9k_htc: REG_IN memory allocation failure\n");776 goto free_rx_buf;777 }778 779 rx_buf->skb = skb;780 781 usb_fill_int_urb(urb, hif_dev->udev,782 usb_rcvintpipe(hif_dev->udev,783 USB_REG_IN_PIPE),784 skb->data, MAX_REG_IN_BUF_SIZE,785 ath9k_hif_usb_reg_in_cb, rx_buf, 1);786 }787 788resubmit:789 usb_anchor_urb(urb, &hif_dev->reg_in_submitted);790 ret = usb_submit_urb(urb, GFP_ATOMIC);791 if (ret) {792 usb_unanchor_urb(urb);793 goto free_skb;794 }795 796 return;797free_skb:798 kfree_skb(skb);799free_rx_buf:800 kfree(rx_buf);801 urb->context = NULL;802}803 804static void ath9k_hif_usb_dealloc_tx_urbs(struct hif_device_usb *hif_dev)805{806 struct tx_buf *tx_buf = NULL, *tx_buf_tmp = NULL;807 unsigned long flags;808 809 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);810 list_for_each_entry_safe(tx_buf, tx_buf_tmp,811 &hif_dev->tx.tx_buf, list) {812 list_del(&tx_buf->list);813 usb_free_urb(tx_buf->urb);814 kfree(tx_buf->buf);815 kfree(tx_buf);816 }817 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);818 819 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);820 hif_dev->tx.flags |= HIF_USB_TX_FLUSH;821 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);822 823 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);824 list_for_each_entry_safe(tx_buf, tx_buf_tmp,825 &hif_dev->tx.tx_pending, list) {826 usb_get_urb(tx_buf->urb);827 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);828 usb_kill_urb(tx_buf->urb);829 list_del(&tx_buf->list);830 usb_free_urb(tx_buf->urb);831 kfree(tx_buf->buf);832 kfree(tx_buf);833 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);834 }835 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);836 837 usb_kill_anchored_urbs(&hif_dev->mgmt_submitted);838}839 840static int ath9k_hif_usb_alloc_tx_urbs(struct hif_device_usb *hif_dev)841{842 struct tx_buf *tx_buf;843 int i;844 845 INIT_LIST_HEAD(&hif_dev->tx.tx_buf);846 INIT_LIST_HEAD(&hif_dev->tx.tx_pending);847 spin_lock_init(&hif_dev->tx.tx_lock);848 __skb_queue_head_init(&hif_dev->tx.tx_skb_queue);849 init_usb_anchor(&hif_dev->mgmt_submitted);850 851 for (i = 0; i < MAX_TX_URB_NUM; i++) {852 tx_buf = kzalloc(sizeof(*tx_buf), GFP_KERNEL);853 if (!tx_buf)854 goto err;855 856 tx_buf->buf = kzalloc(MAX_TX_BUF_SIZE, GFP_KERNEL);857 if (!tx_buf->buf)858 goto err;859 860 tx_buf->urb = usb_alloc_urb(0, GFP_KERNEL);861 if (!tx_buf->urb)862 goto err;863 864 tx_buf->hif_dev = hif_dev;865 __skb_queue_head_init(&tx_buf->skb_queue);866 867 list_add_tail(&tx_buf->list, &hif_dev->tx.tx_buf);868 }869 870 hif_dev->tx.tx_buf_cnt = MAX_TX_URB_NUM;871 872 return 0;873err:874 if (tx_buf) {875 kfree(tx_buf->buf);876 kfree(tx_buf);877 }878 ath9k_hif_usb_dealloc_tx_urbs(hif_dev);879 return -ENOMEM;880}881 882static void ath9k_hif_usb_dealloc_rx_urbs(struct hif_device_usb *hif_dev)883{884 usb_kill_anchored_urbs(&hif_dev->rx_submitted);885 ath9k_hif_usb_free_rx_remain_skb(hif_dev);886}887 888static int ath9k_hif_usb_alloc_rx_urbs(struct hif_device_usb *hif_dev)889{890 struct rx_buf *rx_buf = NULL;891 struct sk_buff *skb = NULL;892 struct urb *urb = NULL;893 int i, ret;894 895 init_usb_anchor(&hif_dev->rx_submitted);896 spin_lock_init(&hif_dev->rx_lock);897 898 for (i = 0; i < MAX_RX_URB_NUM; i++) {899 900 rx_buf = kzalloc(sizeof(*rx_buf), GFP_KERNEL);901 if (!rx_buf) {902 ret = -ENOMEM;903 goto err_rxb;904 }905 906 /* Allocate URB */907 urb = usb_alloc_urb(0, GFP_KERNEL);908 if (urb == NULL) {909 ret = -ENOMEM;910 goto err_urb;911 }912 913 /* Allocate buffer */914 skb = alloc_skb(MAX_RX_BUF_SIZE, GFP_KERNEL);915 if (!skb) {916 ret = -ENOMEM;917 goto err_skb;918 }919 920 rx_buf->hif_dev = hif_dev;921 rx_buf->skb = skb;922 923 usb_fill_bulk_urb(urb, hif_dev->udev,924 usb_rcvbulkpipe(hif_dev->udev,925 USB_WLAN_RX_PIPE),926 skb->data, MAX_RX_BUF_SIZE,927 ath9k_hif_usb_rx_cb, rx_buf);928 929 /* Anchor URB */930 usb_anchor_urb(urb, &hif_dev->rx_submitted);931 932 /* Submit URB */933 ret = usb_submit_urb(urb, GFP_KERNEL);934 if (ret) {935 usb_unanchor_urb(urb);936 goto err_submit;937 }938 939 /*940 * Drop reference count.941 * This ensures that the URB is freed when killing them.942 */943 usb_free_urb(urb);944 }945 946 return 0;947 948err_submit:949 kfree_skb(skb);950err_skb:951 usb_free_urb(urb);952err_urb:953 kfree(rx_buf);954err_rxb:955 ath9k_hif_usb_dealloc_rx_urbs(hif_dev);956 return ret;957}958 959static void ath9k_hif_usb_dealloc_reg_in_urbs(struct hif_device_usb *hif_dev)960{961 usb_kill_anchored_urbs(&hif_dev->reg_in_submitted);962}963 964static int ath9k_hif_usb_alloc_reg_in_urbs(struct hif_device_usb *hif_dev)965{966 struct rx_buf *rx_buf = NULL;967 struct sk_buff *skb = NULL;968 struct urb *urb = NULL;969 int i, ret;970 971 init_usb_anchor(&hif_dev->reg_in_submitted);972 973 for (i = 0; i < MAX_REG_IN_URB_NUM; i++) {974 975 rx_buf = kzalloc(sizeof(*rx_buf), GFP_KERNEL);976 if (!rx_buf) {977 ret = -ENOMEM;978 goto err_rxb;979 }980 981 /* Allocate URB */982 urb = usb_alloc_urb(0, GFP_KERNEL);983 if (urb == NULL) {984 ret = -ENOMEM;985 goto err_urb;986 }987 988 /* Allocate buffer */989 skb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_KERNEL);990 if (!skb) {991 ret = -ENOMEM;992 goto err_skb;993 }994 995 rx_buf->hif_dev = hif_dev;996 rx_buf->skb = skb;997 998 usb_fill_int_urb(urb, hif_dev->udev,999 usb_rcvintpipe(hif_dev->udev,1000 USB_REG_IN_PIPE),1001 skb->data, MAX_REG_IN_BUF_SIZE,1002 ath9k_hif_usb_reg_in_cb, rx_buf, 1);1003 1004 /* Anchor URB */1005 usb_anchor_urb(urb, &hif_dev->reg_in_submitted);1006 1007 /* Submit URB */1008 ret = usb_submit_urb(urb, GFP_KERNEL);1009 if (ret) {1010 usb_unanchor_urb(urb);1011 goto err_submit;1012 }1013 1014 /*1015 * Drop reference count.1016 * This ensures that the URB is freed when killing them.1017 */1018 usb_free_urb(urb);1019 }1020 1021 return 0;1022 1023err_submit:1024 kfree_skb(skb);1025err_skb:1026 usb_free_urb(urb);1027err_urb:1028 kfree(rx_buf);1029err_rxb:1030 ath9k_hif_usb_dealloc_reg_in_urbs(hif_dev);1031 return ret;1032}1033 1034static int ath9k_hif_usb_alloc_urbs(struct hif_device_usb *hif_dev)1035{1036 /* Register Write */1037 init_usb_anchor(&hif_dev->regout_submitted);1038 1039 /* TX */1040 if (ath9k_hif_usb_alloc_tx_urbs(hif_dev) < 0)1041 goto err;1042 1043 /* RX */1044 if (ath9k_hif_usb_alloc_rx_urbs(hif_dev) < 0)1045 goto err_rx;1046 1047 /* Register Read */1048 if (ath9k_hif_usb_alloc_reg_in_urbs(hif_dev) < 0)1049 goto err_reg;1050 1051 return 0;1052err_reg:1053 ath9k_hif_usb_dealloc_rx_urbs(hif_dev);1054err_rx:1055 ath9k_hif_usb_dealloc_tx_urbs(hif_dev);1056err:1057 return -ENOMEM;1058}1059 1060void ath9k_hif_usb_dealloc_urbs(struct hif_device_usb *hif_dev)1061{1062 usb_kill_anchored_urbs(&hif_dev->regout_submitted);1063 ath9k_hif_usb_dealloc_reg_in_urbs(hif_dev);1064 ath9k_hif_usb_dealloc_tx_urbs(hif_dev);1065 ath9k_hif_usb_dealloc_rx_urbs(hif_dev);1066}1067 1068static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev)1069{1070 int transfer, err;1071 const void *data = hif_dev->fw_data;1072 size_t len = hif_dev->fw_size;1073 u32 addr = AR9271_FIRMWARE;1074 u8 *buf = kzalloc(4096, GFP_KERNEL);1075 u32 firm_offset;1076 1077 if (!buf)1078 return -ENOMEM;1079 1080 while (len) {1081 transfer = min_t(size_t, len, 4096);1082 memcpy(buf, data, transfer);1083 1084 err = usb_control_msg(hif_dev->udev,1085 usb_sndctrlpipe(hif_dev->udev, 0),1086 FIRMWARE_DOWNLOAD, 0x40 | USB_DIR_OUT,1087 addr >> 8, 0, buf, transfer,1088 USB_MSG_TIMEOUT);1089 if (err < 0) {1090 kfree(buf);1091 return err;1092 }1093 1094 len -= transfer;1095 data += transfer;1096 addr += transfer;1097 }1098 kfree(buf);1099 1100 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info))1101 firm_offset = AR7010_FIRMWARE_TEXT;1102 else1103 firm_offset = AR9271_FIRMWARE_TEXT;1104 1105 /*1106 * Issue FW download complete command to firmware.1107 */1108 err = usb_control_msg(hif_dev->udev, usb_sndctrlpipe(hif_dev->udev, 0),1109 FIRMWARE_DOWNLOAD_COMP,1110 0x40 | USB_DIR_OUT,1111 firm_offset >> 8, 0, NULL, 0, USB_MSG_TIMEOUT);1112 if (err)1113 return -EIO;1114 1115 dev_info(&hif_dev->udev->dev, "ath9k_htc: Transferred FW: %s, size: %ld\n",1116 hif_dev->fw_name, (unsigned long) hif_dev->fw_size);1117 1118 return 0;1119}1120 1121static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev)1122{1123 int ret;1124 1125 ret = ath9k_hif_usb_download_fw(hif_dev);1126 if (ret) {1127 dev_err(&hif_dev->udev->dev,1128 "ath9k_htc: Firmware - %s download failed\n",1129 hif_dev->fw_name);1130 return ret;1131 }1132 1133 /* Alloc URBs */1134 ret = ath9k_hif_usb_alloc_urbs(hif_dev);1135 if (ret) {1136 dev_err(&hif_dev->udev->dev,1137 "ath9k_htc: Unable to allocate URBs\n");1138 return ret;1139 }1140 1141 return 0;1142}1143 1144static void ath9k_hif_usb_dev_deinit(struct hif_device_usb *hif_dev)1145{1146 ath9k_hif_usb_dealloc_urbs(hif_dev);1147}1148 1149/*1150 * If initialization fails or the FW cannot be retrieved,1151 * detach the device.1152 */1153static void ath9k_hif_usb_firmware_fail(struct hif_device_usb *hif_dev)1154{1155 struct device *dev = &hif_dev->udev->dev;1156 struct device *parent = dev->parent;1157 1158 complete_all(&hif_dev->fw_done);1159 1160 if (parent)1161 device_lock(parent);1162 1163 device_release_driver(dev);1164 1165 if (parent)1166 device_unlock(parent);1167}1168 1169static void ath9k_hif_usb_firmware_cb(const struct firmware *fw, void *context);1170 1171/* taken from iwlwifi */1172static int ath9k_hif_request_firmware(struct hif_device_usb *hif_dev,1173 bool first)1174{1175 char index[8], *chip;1176 int ret;1177 1178 if (first) {1179 if (htc_use_dev_fw) {1180 hif_dev->fw_minor_index = FIRMWARE_MINOR_IDX_MAX + 1;1181 sprintf(index, "%s", "dev");1182 } else {1183 hif_dev->fw_minor_index = FIRMWARE_MINOR_IDX_MAX;1184 sprintf(index, "%d", hif_dev->fw_minor_index);1185 }1186 } else {1187 hif_dev->fw_minor_index--;1188 sprintf(index, "%d", hif_dev->fw_minor_index);1189 }1190 1191 /* test for FW 1.3 */1192 if (MAJOR_VERSION_REQ == 1 && hif_dev->fw_minor_index == 3) {1193 const char *filename;1194 1195 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info))1196 filename = FIRMWARE_AR7010_1_1;1197 else1198 filename = FIRMWARE_AR9271;1199 1200 /* expected fw locations:1201 * - htc_9271.fw (stable version 1.3, depricated)1202 */1203 snprintf(hif_dev->fw_name, sizeof(hif_dev->fw_name),1204 "%s", filename);1205 1206 } else if (hif_dev->fw_minor_index < FIRMWARE_MINOR_IDX_MIN) {1207 dev_err(&hif_dev->udev->dev, "no suitable firmware found!\n");1208 1209 return -ENOENT;1210 } else {1211 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info))1212 chip = "7010";1213 else1214 chip = "9271";1215 1216 /* expected fw locations:1217 * - ath9k_htc/htc_9271-1.dev.0.fw (development version)1218 * - ath9k_htc/htc_9271-1.4.0.fw (stable version)1219 */1220 snprintf(hif_dev->fw_name, sizeof(hif_dev->fw_name),1221 "%s/htc_%s-%d.%s.0.fw", HTC_FW_PATH,1222 chip, MAJOR_VERSION_REQ, index);1223 }1224 1225 ret = request_firmware_nowait(THIS_MODULE, true, hif_dev->fw_name,1226 &hif_dev->udev->dev, GFP_KERNEL,1227 hif_dev, ath9k_hif_usb_firmware_cb);1228 if (ret) {1229 dev_err(&hif_dev->udev->dev,1230 "ath9k_htc: Async request for firmware %s failed\n",1231 hif_dev->fw_name);1232 return ret;1233 }1234 1235 dev_info(&hif_dev->udev->dev, "ath9k_htc: Firmware %s requested\n",1236 hif_dev->fw_name);1237 1238 return ret;1239}1240 1241static void ath9k_hif_usb_firmware_cb(const struct firmware *fw, void *context)1242{1243 struct hif_device_usb *hif_dev = context;1244 int ret;1245 1246 if (!fw) {1247 ret = ath9k_hif_request_firmware(hif_dev, false);1248 if (!ret)1249 return;1250 1251 dev_err(&hif_dev->udev->dev,1252 "ath9k_htc: Failed to get firmware %s\n",1253 hif_dev->fw_name);1254 goto err_fw;1255 }1256 1257 hif_dev->htc_handle = ath9k_htc_hw_alloc(hif_dev, &hif_usb,1258 &hif_dev->udev->dev);1259 if (hif_dev->htc_handle == NULL)1260 goto err_dev_alloc;1261 1262 hif_dev->fw_data = fw->data;1263 hif_dev->fw_size = fw->size;1264 1265 /* Proceed with initialization */1266 1267 ret = ath9k_hif_usb_dev_init(hif_dev);1268 if (ret)1269 goto err_dev_init;1270 1271 ret = ath9k_htc_hw_init(hif_dev->htc_handle,1272 &hif_dev->interface->dev,1273 hif_dev->usb_device_id->idProduct,1274 hif_dev->udev->product,1275 hif_dev->usb_device_id->driver_info);1276 if (ret) {1277 ret = -EINVAL;1278 goto err_htc_hw_init;1279 }1280 1281 release_firmware(fw);1282 hif_dev->flags |= HIF_USB_READY;1283 complete_all(&hif_dev->fw_done);1284 1285 return;1286 1287err_htc_hw_init:1288 ath9k_hif_usb_dev_deinit(hif_dev);1289err_dev_init:1290 ath9k_htc_hw_free(hif_dev->htc_handle);1291err_dev_alloc:1292 release_firmware(fw);1293err_fw:1294 ath9k_hif_usb_firmware_fail(hif_dev);1295}1296 1297/*1298 * An exact copy of the function from zd1211rw.1299 */1300static int send_eject_command(struct usb_interface *interface)1301{1302 struct usb_device *udev = interface_to_usbdev(interface);1303 struct usb_host_interface *iface_desc = interface->cur_altsetting;1304 struct usb_endpoint_descriptor *endpoint;1305 unsigned char *cmd;1306 u8 bulk_out_ep;1307 int r;1308 1309 if (iface_desc->desc.bNumEndpoints < 2)1310 return -ENODEV;1311 1312 /* Find bulk out endpoint */1313 for (r = 1; r >= 0; r--) {1314 endpoint = &iface_desc->endpoint[r].desc;1315 if (usb_endpoint_dir_out(endpoint) &&1316 usb_endpoint_xfer_bulk(endpoint)) {1317 bulk_out_ep = endpoint->bEndpointAddress;1318 break;1319 }1320 }1321 if (r == -1) {1322 dev_err(&udev->dev,1323 "ath9k_htc: Could not find bulk out endpoint\n");1324 return -ENODEV;1325 }1326 1327 cmd = kzalloc(31, GFP_KERNEL);1328 if (cmd == NULL)1329 return -ENODEV;1330 1331 /* USB bulk command block */1332 cmd[0] = 0x55; /* bulk command signature */1333 cmd[1] = 0x53; /* bulk command signature */1334 cmd[2] = 0x42; /* bulk command signature */1335 cmd[3] = 0x43; /* bulk command signature */1336 cmd[14] = 6; /* command length */1337 1338 cmd[15] = 0x1b; /* SCSI command: START STOP UNIT */1339 cmd[19] = 0x2; /* eject disc */1340 1341 dev_info(&udev->dev, "Ejecting storage device...\n");1342 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, bulk_out_ep),1343 cmd, 31, NULL, 2 * USB_MSG_TIMEOUT);1344 kfree(cmd);1345 if (r)1346 return r;1347 1348 /* At this point, the device disconnects and reconnects with the real1349 * ID numbers. */1350 1351 usb_set_intfdata(interface, NULL);1352 return 0;1353}1354 1355static int ath9k_hif_usb_probe(struct usb_interface *interface,1356 const struct usb_device_id *id)1357{1358 struct usb_endpoint_descriptor *bulk_in, *bulk_out, *int_in, *int_out;1359 struct usb_device *udev = interface_to_usbdev(interface);1360 struct usb_host_interface *alt;1361 struct hif_device_usb *hif_dev;1362 int ret = 0;1363 1364 /* Verify the expected endpoints are present */1365 alt = interface->cur_altsetting;1366 if (usb_find_common_endpoints(alt, &bulk_in, &bulk_out, &int_in, &int_out) < 0 ||1367 usb_endpoint_num(bulk_in) != USB_WLAN_RX_PIPE ||1368 usb_endpoint_num(bulk_out) != USB_WLAN_TX_PIPE ||1369 usb_endpoint_num(int_in) != USB_REG_IN_PIPE ||1370 usb_endpoint_num(int_out) != USB_REG_OUT_PIPE) {1371 dev_err(&udev->dev,1372 "ath9k_htc: Device endpoint numbers are not the expected ones\n");1373 return -ENODEV;1374 }1375 1376 if (id->driver_info == STORAGE_DEVICE)1377 return send_eject_command(interface);1378 1379 hif_dev = kzalloc(sizeof(struct hif_device_usb), GFP_KERNEL);1380 if (!hif_dev) {1381 ret = -ENOMEM;1382 goto err_alloc;1383 }1384 1385 usb_get_dev(udev);1386 1387 hif_dev->udev = udev;1388 hif_dev->interface = interface;1389 hif_dev->usb_device_id = id;1390#ifdef CONFIG_PM1391 udev->reset_resume = 1;1392#endif1393 usb_set_intfdata(interface, hif_dev);1394 1395 init_completion(&hif_dev->fw_done);1396 1397 ret = ath9k_hif_request_firmware(hif_dev, true);1398 if (ret)1399 goto err_fw_req;1400 1401 return ret;1402 1403err_fw_req:1404 usb_set_intfdata(interface, NULL);1405 kfree(hif_dev);1406 usb_put_dev(udev);1407err_alloc:1408 return ret;1409}1410 1411static void ath9k_hif_usb_reboot(struct usb_device *udev)1412{1413 u32 reboot_cmd = 0xffffffff;1414 void *buf;1415 int ret;1416 1417 buf = kmemdup(&reboot_cmd, 4, GFP_KERNEL);1418 if (!buf)1419 return;1420 1421 ret = usb_interrupt_msg(udev, usb_sndintpipe(udev, USB_REG_OUT_PIPE),1422 buf, 4, NULL, USB_MSG_TIMEOUT);1423 if (ret)1424 dev_err(&udev->dev, "ath9k_htc: USB reboot failed\n");1425 1426 kfree(buf);1427}1428 1429static void ath9k_hif_usb_disconnect(struct usb_interface *interface)1430{1431 struct usb_device *udev = interface_to_usbdev(interface);1432 struct hif_device_usb *hif_dev = usb_get_intfdata(interface);1433 bool unplugged = udev->state == USB_STATE_NOTATTACHED;1434 1435 if (!hif_dev)1436 return;1437 1438 wait_for_completion(&hif_dev->fw_done);1439 1440 if (hif_dev->flags & HIF_USB_READY) {1441 ath9k_htc_hw_deinit(hif_dev->htc_handle, unplugged);1442 ath9k_htc_hw_free(hif_dev->htc_handle);1443 }1444 1445 usb_set_intfdata(interface, NULL);1446 1447 /* If firmware was loaded we should drop it1448 * go back to first stage bootloader. */1449 if (!unplugged && (hif_dev->flags & HIF_USB_READY))1450 ath9k_hif_usb_reboot(udev);1451 1452 kfree(hif_dev);1453 dev_info(&udev->dev, "ath9k_htc: USB layer deinitialized\n");1454 usb_put_dev(udev);1455}1456 1457#ifdef CONFIG_PM1458static int ath9k_hif_usb_suspend(struct usb_interface *interface,1459 pm_message_t message)1460{1461 struct hif_device_usb *hif_dev = usb_get_intfdata(interface);1462 1463 /*1464 * The device has to be set to FULLSLEEP mode in case no1465 * interface is up.1466 */1467 if (!(hif_dev->flags & HIF_USB_START))1468 ath9k_htc_suspend(hif_dev->htc_handle);1469 1470 wait_for_completion(&hif_dev->fw_done);1471 1472 if (hif_dev->flags & HIF_USB_READY)1473 ath9k_hif_usb_dealloc_urbs(hif_dev);1474 1475 return 0;1476}1477 1478static int ath9k_hif_usb_resume(struct usb_interface *interface)1479{1480 struct hif_device_usb *hif_dev = usb_get_intfdata(interface);1481 struct htc_target *htc_handle = hif_dev->htc_handle;1482 const struct firmware *fw;1483 int ret;1484 1485 ret = ath9k_hif_usb_alloc_urbs(hif_dev);1486 if (ret)1487 return ret;1488 1489 if (!(hif_dev->flags & HIF_USB_READY)) {1490 ret = -EIO;1491 goto fail_resume;1492 }1493 1494 /* request cached firmware during suspend/resume cycle */1495 ret = request_firmware(&fw, hif_dev->fw_name,1496 &hif_dev->udev->dev);1497 if (ret)1498 goto fail_resume;1499 1500 hif_dev->fw_data = fw->data;1501 hif_dev->fw_size = fw->size;1502 ret = ath9k_hif_usb_download_fw(hif_dev);1503 release_firmware(fw);1504 if (ret)1505 goto fail_resume;1506 1507 mdelay(100);1508 1509 ret = ath9k_htc_resume(htc_handle);1510 1511 if (ret)1512 goto fail_resume;1513 1514 return 0;1515 1516fail_resume:1517 ath9k_hif_usb_dealloc_urbs(hif_dev);1518 1519 return ret;1520}1521#endif1522 1523static struct usb_driver ath9k_hif_usb_driver = {1524 .name = KBUILD_MODNAME,1525 .probe = ath9k_hif_usb_probe,1526 .disconnect = ath9k_hif_usb_disconnect,1527#ifdef CONFIG_PM1528 .suspend = ath9k_hif_usb_suspend,1529 .resume = ath9k_hif_usb_resume,1530 .reset_resume = ath9k_hif_usb_resume,1531#endif1532 .id_table = ath9k_hif_usb_ids,1533 .soft_unbind = 1,1534 .disable_hub_initiated_lpm = 1,1535};1536 1537int ath9k_hif_usb_init(void)1538{1539 return usb_register(&ath9k_hif_usb_driver);1540}1541 1542void ath9k_hif_usb_exit(void)1543{1544 usb_deregister(&ath9k_hif_usb_driver);1545}1546