drivers/net/wireless/ath/ath9k/hif_usb.c

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