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

   1 /*
   2  * Copyright (c) 2010 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 "htc.h"
  18
  19 /* identify firmware images */
  20 #define FIRMWARE_AR7010         "ar7010.fw"
  21 #define FIRMWARE_AR7010_1_1     "ar7010_1_1.fw"
  22 #define FIRMWARE_AR9271         "ar9271.fw"
  23
  24 MODULE_FIRMWARE(FIRMWARE_AR7010);
  25 MODULE_FIRMWARE(FIRMWARE_AR7010_1_1);
  26 MODULE_FIRMWARE(FIRMWARE_AR9271);
  27
  28 static struct usb_device_id ath9k_hif_usb_ids[] = {
  29         { USB_DEVICE(0x0cf3, 0x9271) }, /* Atheros */
  30         { USB_DEVICE(0x0cf3, 0x1006) }, /* Atheros */
  31         { USB_DEVICE(0x0cf3, 0x7010),
  32                 .driver_info = AR7010_DEVICE },
  33                                         /* Atheros */
  34         { USB_DEVICE(0x0cf3, 0x7015),
  35                 .driver_info = AR7010_DEVICE | AR9287_DEVICE },
  36                                         /* Atheros */
  37         { USB_DEVICE(0x0846, 0x9030) }, /* Netgear N150 */
  38         { USB_DEVICE(0x0846, 0x9018),
  39                 .driver_info = AR7010_DEVICE },
  40                                         /* Netgear WNDA3200 */
  41         { USB_DEVICE(0x07D1, 0x3A10) }, /* Dlink Wireless 150 */
  42         { USB_DEVICE(0x13D3, 0x3327) }, /* Azurewave */
  43         { USB_DEVICE(0x13D3, 0x3328) }, /* Azurewave */
  44         { USB_DEVICE(0x13D3, 0x3346) }, /* IMC Networks */
  45         { USB_DEVICE(0x13D3, 0x3348) }, /* Azurewave */
  46         { USB_DEVICE(0x13D3, 0x3349) }, /* Azurewave */
  47         { USB_DEVICE(0x13D3, 0x3350) }, /* Azurewave */
  48         { USB_DEVICE(0x04CA, 0x4605) }, /* Liteon */
  49         { USB_DEVICE(0x083A, 0xA704),
  50                 .driver_info = AR7010_DEVICE },
  51                                         /* SMC Networks */
  52         { USB_DEVICE(0x040D, 0x3801) }, /* VIA */
  53         { USB_DEVICE(0x1668, 0x1200),
  54                 .driver_info = AR7010_DEVICE | AR9287_DEVICE },
  55                                         /* Verizon */
  56         { },
  57 };
  58
  59 MODULE_DEVICE_TABLE(usb, ath9k_hif_usb_ids);
  60
  61 static int __hif_usb_tx(struct hif_device_usb *hif_dev);
  62
  63 static void hif_usb_regout_cb(struct urb *urb)
  64 {
  65         struct cmd_buf *cmd = (struct cmd_buf *)urb->context;
  66
  67         switch (urb->status) {
  68         case 0:
  69                 break;
  70         case -ENOENT:
  71         case -ECONNRESET:
  72         case -ENODEV:
  73         case -ESHUTDOWN:
  74                 goto free;
  75         default:
  76                 break;
  77         }
  78
  79         if (cmd) {
  80                 ath9k_htc_txcompletion_cb(cmd->hif_dev->htc_handle,
  81                                           cmd->skb, 1);
  82                 kfree(cmd);
  83         }
  84
  85         return;
  86 free:
  87         kfree_skb(cmd->skb);
  88         kfree(cmd);
  89 }
  90
  91 static int hif_usb_send_regout(struct hif_device_usb *hif_dev,
  92                                struct sk_buff *skb)
  93 {
  94         struct urb *urb;
  95         struct cmd_buf *cmd;
  96         int ret = 0;
  97
  98         urb = usb_alloc_urb(0, GFP_KERNEL);
  99         if (urb == NULL)
 100                 return -ENOMEM;
 101
 102         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 103         if (cmd == NULL) {
 104                 usb_free_urb(urb);
 105                 return -ENOMEM;
 106         }
 107
 108         cmd->skb = skb;
 109         cmd->hif_dev = hif_dev;
 110
 111         usb_fill_bulk_urb(urb, hif_dev->udev,
 112                          usb_sndbulkpipe(hif_dev->udev, USB_REG_OUT_PIPE),
 113                          skb->data, skb->len,
 114                          hif_usb_regout_cb, cmd);
 115
 116         usb_anchor_urb(urb, &hif_dev->regout_submitted);
 117         ret = usb_submit_urb(urb, GFP_KERNEL);
 118         if (ret) {
 119                 usb_unanchor_urb(urb);
 120                 kfree(cmd);
 121         }
 122         usb_free_urb(urb);
 123
 124         return ret;
 125 }
 126
 127 static inline void ath9k_skb_queue_purge(struct hif_device_usb *hif_dev,
 128                                          struct sk_buff_head *list)
 129 {
 130         struct sk_buff *skb;
 131
 132         while ((skb = __skb_dequeue(list)) != NULL) {
 133                 dev_kfree_skb_any(skb);
 134                 TX_STAT_INC(skb_dropped);
 135         }
 136 }
 137
 138 static void hif_usb_tx_cb(struct urb *urb)
 139 {
 140         struct tx_buf *tx_buf = (struct tx_buf *) urb->context;
 141         struct hif_device_usb *hif_dev;
 142         struct sk_buff *skb;
 143
 144         if (!tx_buf || !tx_buf->hif_dev)
 145                 return;
 146
 147         hif_dev = tx_buf->hif_dev;
 148
 149         switch (urb->status) {
 150         case 0:
 151                 break;
 152         case -ENOENT:
 153         case -ECONNRESET:
 154         case -ENODEV:
 155         case -ESHUTDOWN:
 156                 /*
 157                  * The URB has been killed, free the SKBs
 158                  * and return.
 159                  */
 160                 ath9k_skb_queue_purge(hif_dev, &tx_buf->skb_queue);
 161                 return;
 162         default:
 163                 break;
 164         }
 165
 166         /* Check if TX has been stopped */
 167         spin_lock(&hif_dev->tx.tx_lock);
 168         if (hif_dev->tx.flags & HIF_USB_TX_STOP) {
 169                 spin_unlock(&hif_dev->tx.tx_lock);
 170                 ath9k_skb_queue_purge(hif_dev, &tx_buf->skb_queue);
 171                 goto add_free;
 172         }
 173         spin_unlock(&hif_dev->tx.tx_lock);
 174
 175         /* Complete the queued SKBs. */
 176         while ((skb = __skb_dequeue(&tx_buf->skb_queue)) != NULL) {
 177                 ath9k_htc_txcompletion_cb(hif_dev->htc_handle,
 178                                           skb, 1);
 179                 TX_STAT_INC(skb_completed);
 180         }
 181
 182 add_free:
 183         /* Re-initialize the SKB queue */
 184         tx_buf->len = tx_buf->offset = 0;
 185         __skb_queue_head_init(&tx_buf->skb_queue);
 186
 187         /* Add this TX buffer to the free list */
 188         spin_lock(&hif_dev->tx.tx_lock);
 189         list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf);
 190         hif_dev->tx.tx_buf_cnt++;
 191         if (!(hif_dev->tx.flags & HIF_USB_TX_STOP))
 192                 __hif_usb_tx(hif_dev); /* Check for pending SKBs */
 193         TX_STAT_INC(buf_completed);
 194         spin_unlock(&hif_dev->tx.tx_lock);
 195 }
 196
 197 /* TX lock has to be taken */
 198 static int __hif_usb_tx(struct hif_device_usb *hif_dev)
 199 {
 200         struct tx_buf *tx_buf = NULL;
 201         struct sk_buff *nskb = NULL;
 202         int ret = 0, i;
 203         u16 *hdr, tx_skb_cnt = 0;
 204         u8 *buf;
 205
 206         if (hif_dev->tx.tx_skb_cnt == 0)
 207                 return 0;
 208
 209         /* Check if a free TX buffer is available */
 210         if (list_empty(&hif_dev->tx.tx_buf))
 211                 return 0;
 212
 213         tx_buf = list_first_entry(&hif_dev->tx.tx_buf, struct tx_buf, list);
 214         list_move_tail(&tx_buf->list, &hif_dev->tx.tx_pending);
 215         hif_dev->tx.tx_buf_cnt--;
 216
 217         tx_skb_cnt = min_t(u16, hif_dev->tx.tx_skb_cnt, MAX_TX_AGGR_NUM);
 218
 219         for (i = 0; i < tx_skb_cnt; i++) {
 220                 nskb = __skb_dequeue(&hif_dev->tx.tx_skb_queue);
 221
 222                 /* Should never be NULL */
 223                 BUG_ON(!nskb);
 224
 225                 hif_dev->tx.tx_skb_cnt--;
 226
 227                 buf = tx_buf->buf;
 228                 buf += tx_buf->offset;
 229                 hdr = (u16 *)buf;
 230                 *hdr++ = nskb->len;
 231                 *hdr++ = ATH_USB_TX_STREAM_MODE_TAG;
 232                 buf += 4;
 233                 memcpy(buf, nskb->data, nskb->len);
 234                 tx_buf->len = nskb->len + 4;
 235
 236                 if (i < (tx_skb_cnt - 1))
 237                         tx_buf->offset += (((tx_buf->len - 1) / 4) + 1) * 4;
 238
 239                 if (i == (tx_skb_cnt - 1))
 240                         tx_buf->len += tx_buf->offset;
 241
 242                 __skb_queue_tail(&tx_buf->skb_queue, nskb);
 243                 TX_STAT_INC(skb_queued);
 244         }
 245
 246         usb_fill_bulk_urb(tx_buf->urb, hif_dev->udev,
 247                           usb_sndbulkpipe(hif_dev->udev, USB_WLAN_TX_PIPE),
 248                           tx_buf->buf, tx_buf->len,
 249                           hif_usb_tx_cb, tx_buf);
 250
 251         ret = usb_submit_urb(tx_buf->urb, GFP_ATOMIC);
 252         if (ret) {
 253                 tx_buf->len = tx_buf->offset = 0;
 254                 ath9k_skb_queue_purge(hif_dev, &tx_buf->skb_queue);
 255                 __skb_queue_head_init(&tx_buf->skb_queue);
 256                 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf);
 257                 hif_dev->tx.tx_buf_cnt++;
 258         }
 259
 260         if (!ret)
 261                 TX_STAT_INC(buf_queued);
 262
 263         return ret;
 264 }
 265
 266 static int hif_usb_send_tx(struct hif_device_usb *hif_dev, struct sk_buff *skb,
 267                            struct ath9k_htc_tx_ctl *tx_ctl)
 268 {
 269         unsigned long flags;
 270
 271         spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
 272
 273         if (hif_dev->tx.flags & HIF_USB_TX_STOP) {
 274                 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
 275                 return -ENODEV;
 276         }
 277
 278         /* Check if the max queue count has been reached */
 279         if (hif_dev->tx.tx_skb_cnt > MAX_TX_BUF_NUM) {
 280                 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
 281                 return -ENOMEM;
 282         }
 283
 284         __skb_queue_tail(&hif_dev->tx.tx_skb_queue, skb);
 285         hif_dev->tx.tx_skb_cnt++;
 286
 287         /* Send normal frames immediately */
 288         if (!tx_ctl || (tx_ctl && (tx_ctl->type == ATH9K_HTC_NORMAL)))
 289                 __hif_usb_tx(hif_dev);
 290
 291         /* Check if AMPDUs have to be sent immediately */
 292         if (tx_ctl && (tx_ctl->type == ATH9K_HTC_AMPDU) &&
 293             (hif_dev->tx.tx_buf_cnt == MAX_TX_URB_NUM) &&
 294             (hif_dev->tx.tx_skb_cnt < 2)) {
 295                 __hif_usb_tx(hif_dev);
 296         }
 297
 298         spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
 299
 300         return 0;
 301 }
 302
 303 static void hif_usb_start(void *hif_handle, u8 pipe_id)
 304 {
 305         struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle;
 306         unsigned long flags;
 307
 308         hif_dev->flags |= HIF_USB_START;
 309
 310         spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
 311         hif_dev->tx.flags &= ~HIF_USB_TX_STOP;
 312         spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
 313 }
 314
 315 static void hif_usb_stop(void *hif_handle, u8 pipe_id)
 316 {
 317         struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle;
 318         unsigned long flags;
 319
 320         spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
 321         ath9k_skb_queue_purge(hif_dev, &hif_dev->tx.tx_skb_queue);
 322         hif_dev->tx.tx_skb_cnt = 0;
 323         hif_dev->tx.flags |= HIF_USB_TX_STOP;
 324         spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
 325 }
 326
 327 static int hif_usb_send(void *hif_handle, u8 pipe_id, struct sk_buff *skb,
 328                         struct ath9k_htc_tx_ctl *tx_ctl)
 329 {
 330         struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle;
 331         int ret = 0;
 332
 333         switch (pipe_id) {
 334         case USB_WLAN_TX_PIPE:
 335                 ret = hif_usb_send_tx(hif_dev, skb, tx_ctl);
 336                 break;
 337         case USB_REG_OUT_PIPE:
 338                 ret = hif_usb_send_regout(hif_dev, skb);
 339                 break;
 340         default:
 341                 dev_err(&hif_dev->udev->dev,
 342                         "ath9k_htc: Invalid TX pipe: %d\n", pipe_id);
 343                 ret = -EINVAL;
 344                 break;
 345         }
 346
 347         return ret;
 348 }
 349
 350 static struct ath9k_htc_hif hif_usb = {
 351         .transport = ATH9K_HIF_USB,
 352         .name = "ath9k_hif_usb",
 353
 354         .control_ul_pipe = USB_REG_OUT_PIPE,
 355         .control_dl_pipe = USB_REG_IN_PIPE,
 356
 357         .start = hif_usb_start,
 358         .stop = hif_usb_stop,
 359         .send = hif_usb_send,
 360 };
 361
 362 static void ath9k_hif_usb_rx_stream(struct hif_device_usb *hif_dev,
 363                                     struct sk_buff *skb)
 364 {
 365         struct sk_buff *nskb, *skb_pool[MAX_PKT_NUM_IN_TRANSFER];
 366         int index = 0, i = 0, len = skb->len;
 367         int rx_remain_len, rx_pkt_len;
 368         u16 pool_index = 0;
 369         u8 *ptr;
 370
 371         spin_lock(&hif_dev->rx_lock);
 372
 373         rx_remain_len = hif_dev->rx_remain_len;
 374         rx_pkt_len = hif_dev->rx_transfer_len;
 375
 376         if (rx_remain_len != 0) {
 377                 struct sk_buff *remain_skb = hif_dev->remain_skb;
 378
 379                 if (remain_skb) {
 380                         ptr = (u8 *) remain_skb->data;
 381
 382                         index = rx_remain_len;
 383                         rx_remain_len -= hif_dev->rx_pad_len;
 384                         ptr += rx_pkt_len;
 385
 386                         memcpy(ptr, skb->data, rx_remain_len);
 387
 388                         rx_pkt_len += rx_remain_len;
 389                         hif_dev->rx_remain_len = 0;
 390                         skb_put(remain_skb, rx_pkt_len);
 391
 392                         skb_pool[pool_index++] = remain_skb;
 393
 394                 } else {
 395                         index = rx_remain_len;
 396                 }
 397         }
 398
 399         spin_unlock(&hif_dev->rx_lock);
 400
 401         while (index < len) {
 402                 u16 pkt_len;
 403                 u16 pkt_tag;
 404                 u16 pad_len;
 405                 int chk_idx;
 406
 407                 ptr = (u8 *) skb->data;
 408
 409                 pkt_len = ptr[index] + (ptr[index+1] << 8);
 410                 pkt_tag = ptr[index+2] + (ptr[index+3] << 8);
 411
 412                 if (pkt_tag != ATH_USB_RX_STREAM_MODE_TAG) {
 413                         RX_STAT_INC(skb_dropped);
 414                         return;
 415                 }
 416
 417                 pad_len = 4 - (pkt_len & 0x3);
 418                 if (pad_len == 4)
 419                         pad_len = 0;
 420
 421                 chk_idx = index;
 422                 index = index + 4 + pkt_len + pad_len;
 423
 424                 if (index > MAX_RX_BUF_SIZE) {
 425                         spin_lock(&hif_dev->rx_lock);
 426                         hif_dev->rx_remain_len = index - MAX_RX_BUF_SIZE;
 427                         hif_dev->rx_transfer_len =
 428                                 MAX_RX_BUF_SIZE - chk_idx - 4;
 429                         hif_dev->rx_pad_len = pad_len;
 430
 431                         nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC);
 432                         if (!nskb) {
 433                                 dev_err(&hif_dev->udev->dev,
 434                                         "ath9k_htc: RX memory allocation error\n");
 435                                 spin_unlock(&hif_dev->rx_lock);
 436                                 goto err;
 437                         }
 438                         skb_reserve(nskb, 32);
 439                         RX_STAT_INC(skb_allocated);
 440
 441                         memcpy(nskb->data, &(skb->data[chk_idx+4]),
 442                                hif_dev->rx_transfer_len);
 443
 444                         /* Record the buffer pointer */
 445                         hif_dev->remain_skb = nskb;
 446                         spin_unlock(&hif_dev->rx_lock);
 447                 } else {
 448                         nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC);
 449                         if (!nskb) {
 450                                 dev_err(&hif_dev->udev->dev,
 451                                         "ath9k_htc: RX memory allocation error\n");
 452                                 goto err;
 453                         }
 454                         skb_reserve(nskb, 32);
 455                         RX_STAT_INC(skb_allocated);
 456
 457                         memcpy(nskb->data, &(skb->data[chk_idx+4]), pkt_len);
 458                         skb_put(nskb, pkt_len);
 459                         skb_pool[pool_index++] = nskb;
 460                 }
 461         }
 462
 463 err:
 464         for (i = 0; i < pool_index; i++) {
 465                 ath9k_htc_rx_msg(hif_dev->htc_handle, skb_pool[i],
 466                                  skb_pool[i]->len, USB_WLAN_RX_PIPE);
 467                 RX_STAT_INC(skb_completed);
 468         }
 469 }
 470
 471 static void ath9k_hif_usb_rx_cb(struct urb *urb)
 472 {
 473         struct sk_buff *skb = (struct sk_buff *) urb->context;
 474         struct hif_device_usb *hif_dev =
 475                 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
 476         int ret;
 477
 478         if (!skb)
 479                 return;
 480
 481         if (!hif_dev)
 482                 goto free;
 483
 484         switch (urb->status) {
 485         case 0:
 486                 break;
 487         case -ENOENT:
 488         case -ECONNRESET:
 489         case -ENODEV:
 490         case -ESHUTDOWN:
 491                 goto free;
 492         default:
 493                 goto resubmit;
 494         }
 495
 496         if (likely(urb->actual_length != 0)) {
 497                 skb_put(skb, urb->actual_length);
 498                 ath9k_hif_usb_rx_stream(hif_dev, skb);
 499         }
 500
 501 resubmit:
 502         skb_reset_tail_pointer(skb);
 503         skb_trim(skb, 0);
 504
 505         usb_anchor_urb(urb, &hif_dev->rx_submitted);
 506         ret = usb_submit_urb(urb, GFP_ATOMIC);
 507         if (ret) {
 508                 usb_unanchor_urb(urb);
 509                 goto free;
 510         }
 511
 512         return;
 513 free:
 514         kfree_skb(skb);
 515 }
 516
 517 static void ath9k_hif_usb_reg_in_cb(struct urb *urb)
 518 {
 519         struct sk_buff *skb = (struct sk_buff *) urb->context;
 520         struct sk_buff *nskb;
 521         struct hif_device_usb *hif_dev =
 522                 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
 523         int ret;
 524
 525         if (!skb)
 526                 return;
 527
 528         if (!hif_dev)
 529                 goto free;
 530
 531         switch (urb->status) {
 532         case 0:
 533                 break;
 534         case -ENOENT:
 535         case -ECONNRESET:
 536         case -ENODEV:
 537         case -ESHUTDOWN:
 538                 goto free;
 539         default:
 540                 goto resubmit;
 541         }
 542
 543         if (likely(urb->actual_length != 0)) {
 544                 skb_put(skb, urb->actual_length);
 545
 546                 /* Process the command first */
 547                 ath9k_htc_rx_msg(hif_dev->htc_handle, skb,
 548                                  skb->len, USB_REG_IN_PIPE);
 549
 550
 551                 nskb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_ATOMIC);
 552                 if (!nskb) {
 553                         dev_err(&hif_dev->udev->dev,
 554                                 "ath9k_htc: REG_IN memory allocation failure\n");
 555                         urb->context = NULL;
 556                         return;
 557                 }
 558
 559                 usb_fill_bulk_urb(urb, hif_dev->udev,
 560                                  usb_rcvbulkpipe(hif_dev->udev,
 561                                                  USB_REG_IN_PIPE),
 562                                  nskb->data, MAX_REG_IN_BUF_SIZE,
 563                                  ath9k_hif_usb_reg_in_cb, nskb);
 564
 565                 ret = usb_submit_urb(urb, GFP_ATOMIC);
 566                 if (ret) {
 567                         kfree_skb(nskb);
 568                         urb->context = NULL;
 569                 }
 570
 571                 return;
 572         }
 573
 574 resubmit:
 575         skb_reset_tail_pointer(skb);
 576         skb_trim(skb, 0);
 577
 578         ret = usb_submit_urb(urb, GFP_ATOMIC);
 579         if (ret)
 580                 goto free;
 581
 582         return;
 583 free:
 584         kfree_skb(skb);
 585         urb->context = NULL;
 586 }
 587
 588 static void ath9k_hif_usb_dealloc_tx_urbs(struct hif_device_usb *hif_dev)
 589 {
 590         struct tx_buf *tx_buf = NULL, *tx_buf_tmp = NULL;
 591
 592         list_for_each_entry_safe(tx_buf, tx_buf_tmp,
 593                                  &hif_dev->tx.tx_buf, list) {
 594                 usb_kill_urb(tx_buf->urb);
 595                 list_del(&tx_buf->list);
 596                 usb_free_urb(tx_buf->urb);
 597                 kfree(tx_buf->buf);
 598                 kfree(tx_buf);
 599         }
 600
 601         list_for_each_entry_safe(tx_buf, tx_buf_tmp,
 602                                  &hif_dev->tx.tx_pending, list) {
 603                 usb_kill_urb(tx_buf->urb);
 604                 list_del(&tx_buf->list);
 605                 usb_free_urb(tx_buf->urb);
 606                 kfree(tx_buf->buf);
 607                 kfree(tx_buf);
 608         }
 609 }
 610
 611 static int ath9k_hif_usb_alloc_tx_urbs(struct hif_device_usb *hif_dev)
 612 {
 613         struct tx_buf *tx_buf;
 614         int i;
 615
 616         INIT_LIST_HEAD(&hif_dev->tx.tx_buf);
 617         INIT_LIST_HEAD(&hif_dev->tx.tx_pending);
 618         spin_lock_init(&hif_dev->tx.tx_lock);
 619         __skb_queue_head_init(&hif_dev->tx.tx_skb_queue);
 620
 621         for (i = 0; i < MAX_TX_URB_NUM; i++) {
 622                 tx_buf = kzalloc(sizeof(struct tx_buf), GFP_KERNEL);
 623                 if (!tx_buf)
 624                         goto err;
 625
 626                 tx_buf->buf = kzalloc(MAX_TX_BUF_SIZE, GFP_KERNEL);
 627                 if (!tx_buf->buf)
 628                         goto err;
 629
 630                 tx_buf->urb = usb_alloc_urb(0, GFP_KERNEL);
 631                 if (!tx_buf->urb)
 632                         goto err;
 633
 634                 tx_buf->hif_dev = hif_dev;
 635                 __skb_queue_head_init(&tx_buf->skb_queue);
 636
 637                 list_add_tail(&tx_buf->list, &hif_dev->tx.tx_buf);
 638         }
 639
 640         hif_dev->tx.tx_buf_cnt = MAX_TX_URB_NUM;
 641
 642         return 0;
 643 err:
 644         if (tx_buf) {
 645                 kfree(tx_buf->buf);
 646                 kfree(tx_buf);
 647         }
 648         ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
 649         return -ENOMEM;
 650 }
 651
 652 static void ath9k_hif_usb_dealloc_rx_urbs(struct hif_device_usb *hif_dev)
 653 {
 654         usb_kill_anchored_urbs(&hif_dev->rx_submitted);
 655 }
 656
 657 static int ath9k_hif_usb_alloc_rx_urbs(struct hif_device_usb *hif_dev)
 658 {
 659         struct urb *urb = NULL;
 660         struct sk_buff *skb = NULL;
 661         int i, ret;
 662
 663         init_usb_anchor(&hif_dev->rx_submitted);
 664         spin_lock_init(&hif_dev->rx_lock);
 665
 666         for (i = 0; i < MAX_RX_URB_NUM; i++) {
 667
 668                 /* Allocate URB */
 669                 urb = usb_alloc_urb(0, GFP_KERNEL);
 670                 if (urb == NULL) {
 671                         ret = -ENOMEM;
 672                         goto err_urb;
 673                 }
 674
 675                 /* Allocate buffer */
 676                 skb = alloc_skb(MAX_RX_BUF_SIZE, GFP_KERNEL);
 677                 if (!skb) {
 678                         ret = -ENOMEM;
 679                         goto err_skb;
 680                 }
 681
 682                 usb_fill_bulk_urb(urb, hif_dev->udev,
 683                                   usb_rcvbulkpipe(hif_dev->udev,
 684                                                   USB_WLAN_RX_PIPE),
 685                                   skb->data, MAX_RX_BUF_SIZE,
 686                                   ath9k_hif_usb_rx_cb, skb);
 687
 688                 /* Anchor URB */
 689                 usb_anchor_urb(urb, &hif_dev->rx_submitted);
 690
 691                 /* Submit URB */
 692                 ret = usb_submit_urb(urb, GFP_KERNEL);
 693                 if (ret) {
 694                         usb_unanchor_urb(urb);
 695                         goto err_submit;
 696                 }
 697
 698                 /*
 699                  * Drop reference count.
 700                  * This ensures that the URB is freed when killing them.
 701                  */
 702                 usb_free_urb(urb);
 703         }
 704
 705         return 0;
 706
 707 err_submit:
 708         kfree_skb(skb);
 709 err_skb:
 710         usb_free_urb(urb);
 711 err_urb:
 712         ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
 713         return ret;
 714 }
 715
 716 static void ath9k_hif_usb_dealloc_reg_in_urb(struct hif_device_usb *hif_dev)
 717 {
 718         if (hif_dev->reg_in_urb) {
 719                 usb_kill_urb(hif_dev->reg_in_urb);
 720                 if (hif_dev->reg_in_urb->context)
 721                         kfree_skb((void *)hif_dev->reg_in_urb->context);
 722                 usb_free_urb(hif_dev->reg_in_urb);
 723                 hif_dev->reg_in_urb = NULL;
 724         }
 725 }
 726
 727 static int ath9k_hif_usb_alloc_reg_in_urb(struct hif_device_usb *hif_dev)
 728 {
 729         struct sk_buff *skb;
 730
 731         hif_dev->reg_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 732         if (hif_dev->reg_in_urb == NULL)
 733                 return -ENOMEM;
 734
 735         skb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_KERNEL);
 736         if (!skb)
 737                 goto err;
 738
 739         usb_fill_bulk_urb(hif_dev->reg_in_urb, hif_dev->udev,
 740                          usb_rcvbulkpipe(hif_dev->udev,
 741                                          USB_REG_IN_PIPE),
 742                          skb->data, MAX_REG_IN_BUF_SIZE,
 743                          ath9k_hif_usb_reg_in_cb, skb);
 744
 745         if (usb_submit_urb(hif_dev->reg_in_urb, GFP_KERNEL) != 0)
 746                 goto err;
 747
 748         return 0;
 749
 750 err:
 751         ath9k_hif_usb_dealloc_reg_in_urb(hif_dev);
 752         return -ENOMEM;
 753 }
 754
 755 static int ath9k_hif_usb_alloc_urbs(struct hif_device_usb *hif_dev)
 756 {
 757         /* Register Write */
 758         init_usb_anchor(&hif_dev->regout_submitted);
 759
 760         /* TX */
 761         if (ath9k_hif_usb_alloc_tx_urbs(hif_dev) < 0)
 762                 goto err;
 763
 764         /* RX */
 765         if (ath9k_hif_usb_alloc_rx_urbs(hif_dev) < 0)
 766                 goto err_rx;
 767
 768         /* Register Read */
 769         if (ath9k_hif_usb_alloc_reg_in_urb(hif_dev) < 0)
 770                 goto err_reg;
 771
 772         return 0;
 773 err_reg:
 774         ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
 775 err_rx:
 776         ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
 777 err:
 778         return -ENOMEM;
 779 }
 780
 781 static void ath9k_hif_usb_dealloc_urbs(struct hif_device_usb *hif_dev)
 782 {
 783         usb_kill_anchored_urbs(&hif_dev->regout_submitted);
 784         ath9k_hif_usb_dealloc_reg_in_urb(hif_dev);
 785         ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
 786         ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
 787 }
 788
 789 static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev,
 790                                      u32 drv_info)
 791 {
 792         int transfer, err;
 793         const void *data = hif_dev->firmware->data;
 794         size_t len = hif_dev->firmware->size;
 795         u32 addr = AR9271_FIRMWARE;
 796         u8 *buf = kzalloc(4096, GFP_KERNEL);
 797         u32 firm_offset;
 798
 799         if (!buf)
 800                 return -ENOMEM;
 801
 802         while (len) {
 803                 transfer = min_t(int, len, 4096);
 804                 memcpy(buf, data, transfer);
 805
 806                 err = usb_control_msg(hif_dev->udev,
 807                                       usb_sndctrlpipe(hif_dev->udev, 0),
 808                                       FIRMWARE_DOWNLOAD, 0x40 | USB_DIR_OUT,
 809                                       addr >> 8, 0, buf, transfer, HZ);
 810                 if (err < 0) {
 811                         kfree(buf);
 812                         return err;
 813                 }
 814
 815                 len -= transfer;
 816                 data += transfer;
 817                 addr += transfer;
 818         }
 819         kfree(buf);
 820
 821         if (drv_info & AR7010_DEVICE)
 822                 firm_offset = AR7010_FIRMWARE_TEXT;
 823         else
 824                 firm_offset = AR9271_FIRMWARE_TEXT;
 825
 826         /*
 827          * Issue FW download complete command to firmware.
 828          */
 829         err = usb_control_msg(hif_dev->udev, usb_sndctrlpipe(hif_dev->udev, 0),
 830                               FIRMWARE_DOWNLOAD_COMP,
 831                               0x40 | USB_DIR_OUT,
 832                               firm_offset >> 8, 0, NULL, 0, HZ);
 833         if (err)
 834                 return -EIO;
 835
 836         dev_info(&hif_dev->udev->dev, "ath9k_htc: Transferred FW: %s, size: %ld\n",
 837                  hif_dev->fw_name, (unsigned long) hif_dev->firmware->size);
 838
 839         return 0;
 840 }
 841
 842 static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev, u32 drv_info)
 843 {
 844         int ret, idx;
 845         struct usb_host_interface *alt = &hif_dev->interface->altsetting[0];
 846         struct usb_endpoint_descriptor *endp;
 847
 848         /* Request firmware */
 849         ret = request_firmware(&hif_dev->firmware, hif_dev->fw_name,
 850                                &hif_dev->udev->dev);
 851         if (ret) {
 852                 dev_err(&hif_dev->udev->dev,
 853                         "ath9k_htc: Firmware - %s not found\n", hif_dev->fw_name);
 854                 goto err_fw_req;
 855         }
 856
 857         /* Download firmware */
 858         ret = ath9k_hif_usb_download_fw(hif_dev, drv_info);
 859         if (ret) {
 860                 dev_err(&hif_dev->udev->dev,
 861                         "ath9k_htc: Firmware - %s download failed\n",
 862                         hif_dev->fw_name);
 863                 goto err_fw_download;
 864         }
 865
 866         /* On downloading the firmware to the target, the USB descriptor of EP4
 867          * is 'patched' to change the type of the endpoint to Bulk. This will
 868          * bring down CPU usage during the scan period.
 869          */
 870         for (idx = 0; idx < alt->desc.bNumEndpoints; idx++) {
 871                 endp = &alt->endpoint[idx].desc;
 872                 if ((endp->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
 873                                 == USB_ENDPOINT_XFER_INT) {
 874                         endp->bmAttributes &= ~USB_ENDPOINT_XFERTYPE_MASK;
 875                         endp->bmAttributes |= USB_ENDPOINT_XFER_BULK;
 876                         endp->bInterval = 0;
 877                 }
 878         }
 879
 880         /* Alloc URBs */
 881         ret = ath9k_hif_usb_alloc_urbs(hif_dev);
 882         if (ret) {
 883                 dev_err(&hif_dev->udev->dev,
 884                         "ath9k_htc: Unable to allocate URBs\n");
 885                 goto err_urb;
 886         }
 887
 888         return 0;
 889
 890 err_fw_download:
 891         ath9k_hif_usb_dealloc_urbs(hif_dev);
 892 err_urb:
 893         release_firmware(hif_dev->firmware);
 894 err_fw_req:
 895         hif_dev->firmware = NULL;
 896         return ret;
 897 }
 898
 899 static void ath9k_hif_usb_dev_deinit(struct hif_device_usb *hif_dev)
 900 {
 901         ath9k_hif_usb_dealloc_urbs(hif_dev);
 902         if (hif_dev->firmware)
 903                 release_firmware(hif_dev->firmware);
 904 }
 905
 906 static int ath9k_hif_usb_probe(struct usb_interface *interface,
 907                                const struct usb_device_id *id)
 908 {
 909         struct usb_device *udev = interface_to_usbdev(interface);
 910         struct hif_device_usb *hif_dev;
 911         int ret = 0;
 912
 913         hif_dev = kzalloc(sizeof(struct hif_device_usb), GFP_KERNEL);
 914         if (!hif_dev) {
 915                 ret = -ENOMEM;
 916                 goto err_alloc;
 917         }
 918
 919         usb_get_dev(udev);
 920         hif_dev->udev = udev;
 921         hif_dev->interface = interface;
 922         hif_dev->device_id = id->idProduct;
 923 #ifdef CONFIG_PM
 924         udev->reset_resume = 1;
 925 #endif
 926         usb_set_intfdata(interface, hif_dev);
 927
 928         hif_dev->htc_handle = ath9k_htc_hw_alloc(hif_dev, &hif_usb,
 929                                                  &hif_dev->udev->dev);
 930         if (hif_dev->htc_handle == NULL) {
 931                 ret = -ENOMEM;
 932                 goto err_htc_hw_alloc;
 933         }
 934
 935         /* Find out which firmware to load */
 936
 937         if (id->driver_info & AR7010_DEVICE)
 938                 if (le16_to_cpu(udev->descriptor.bcdDevice) == 0x0202)
 939                         hif_dev->fw_name = FIRMWARE_AR7010_1_1;
 940                 else
 941                         hif_dev->fw_name = FIRMWARE_AR7010;
 942         else
 943                 hif_dev->fw_name = FIRMWARE_AR9271;
 944
 945         ret = ath9k_hif_usb_dev_init(hif_dev, id->driver_info);
 946         if (ret) {
 947                 ret = -EINVAL;
 948                 goto err_hif_init_usb;
 949         }
 950
 951         ret = ath9k_htc_hw_init(hif_dev->htc_handle,
 952                                 &hif_dev->udev->dev, hif_dev->device_id,
 953                                 hif_dev->udev->product, id->driver_info);
 954         if (ret) {
 955                 ret = -EINVAL;
 956                 goto err_htc_hw_init;
 957         }
 958
 959         dev_info(&hif_dev->udev->dev, "ath9k_htc: USB layer initialized\n");
 960
 961         return 0;
 962
 963 err_htc_hw_init:
 964         ath9k_hif_usb_dev_deinit(hif_dev);
 965 err_hif_init_usb:
 966         ath9k_htc_hw_free(hif_dev->htc_handle);
 967 err_htc_hw_alloc:
 968         usb_set_intfdata(interface, NULL);
 969         kfree(hif_dev);
 970         usb_put_dev(udev);
 971 err_alloc:
 972         return ret;
 973 }
 974
 975 static void ath9k_hif_usb_reboot(struct usb_device *udev)
 976 {
 977         u32 reboot_cmd = 0xffffffff;
 978         void *buf;
 979         int ret;
 980
 981         buf = kmemdup(&reboot_cmd, 4, GFP_KERNEL);
 982         if (!buf)
 983                 return;
 984
 985         ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, USB_REG_OUT_PIPE),
 986                            buf, 4, NULL, HZ);
 987         if (ret)
 988                 dev_err(&udev->dev, "ath9k_htc: USB reboot failed\n");
 989
 990         kfree(buf);
 991 }
 992
 993 static void ath9k_hif_usb_disconnect(struct usb_interface *interface)
 994 {
 995         struct usb_device *udev = interface_to_usbdev(interface);
 996         struct hif_device_usb *hif_dev = usb_get_intfdata(interface);
 997
 998         if (hif_dev) {
 999                 ath9k_htc_hw_deinit(hif_dev->htc_handle,
1000                     (udev->state == USB_STATE_NOTATTACHED) ? true : false);
1001                 ath9k_htc_hw_free(hif_dev->htc_handle);
1002                 ath9k_hif_usb_dev_deinit(hif_dev);
1003                 usb_set_intfdata(interface, NULL);
1004         }
1005
1006         if (hif_dev->flags & HIF_USB_START)
1007                 ath9k_hif_usb_reboot(udev);
1008
1009         kfree(hif_dev);
1010         dev_info(&udev->dev, "ath9k_htc: USB layer deinitialized\n");
1011         usb_put_dev(udev);
1012 }
1013
1014 #ifdef CONFIG_PM
1015 static int ath9k_hif_usb_suspend(struct usb_interface *interface,
1016                                  pm_message_t message)
1017 {
1018         struct hif_device_usb *hif_dev = usb_get_intfdata(interface);
1019
1020         ath9k_hif_usb_dealloc_urbs(hif_dev);
1021
1022         return 0;
1023 }
1024
1025 static int ath9k_hif_usb_resume(struct usb_interface *interface)
1026 {
1027         struct hif_device_usb *hif_dev = usb_get_intfdata(interface);
1028         struct htc_target *htc_handle = hif_dev->htc_handle;
1029         int ret;
1030
1031         ret = ath9k_hif_usb_alloc_urbs(hif_dev);
1032         if (ret)
1033                 return ret;
1034
1035         if (hif_dev->firmware) {
1036                 ret = ath9k_hif_usb_download_fw(hif_dev,
1037                                 htc_handle->drv_priv->ah->common.driver_info);
1038                 if (ret)
1039                         goto fail_resume;
1040         } else {
1041                 ath9k_hif_usb_dealloc_urbs(hif_dev);
1042                 return -EIO;
1043         }
1044
1045         mdelay(100);
1046
1047         ret = ath9k_htc_resume(htc_handle);
1048
1049         if (ret)
1050                 goto fail_resume;
1051
1052         return 0;
1053
1054 fail_resume:
1055         ath9k_hif_usb_dealloc_urbs(hif_dev);
1056
1057         return ret;
1058 }
1059 #endif
1060
1061 static struct usb_driver ath9k_hif_usb_driver = {
1062         .name = "ath9k_hif_usb",
1063         .probe = ath9k_hif_usb_probe,
1064         .disconnect = ath9k_hif_usb_disconnect,
1065 #ifdef CONFIG_PM
1066         .suspend = ath9k_hif_usb_suspend,
1067         .resume = ath9k_hif_usb_resume,
1068         .reset_resume = ath9k_hif_usb_resume,
1069 #endif
1070         .id_table = ath9k_hif_usb_ids,
1071         .soft_unbind = 1,
1072 };
1073
1074 int ath9k_hif_usb_init(void)
1075 {
1076         return usb_register(&ath9k_hif_usb_driver);
1077 }
1078
1079 void ath9k_hif_usb_exit(void)
1080 {
1081         usb_deregister(&ath9k_hif_usb_driver);
1082 }