drivers/net/wireless/ath/ath6kl/usb.c

   1 /*
   2  * Copyright (c) 2007-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/usb.h>
  20
  21 #include "debug.h"
  22 #include "core.h"
  23
  24 /* constants */
  25 #define TX_URB_COUNT            32
  26 #define RX_URB_COUNT            32
  27 #define ATH6KL_USB_RX_BUFFER_SIZE  4096
  28
  29 /* tx/rx pipes for usb */
  30 enum ATH6KL_USB_PIPE_ID {
  31         ATH6KL_USB_PIPE_TX_CTRL = 0,
  32         ATH6KL_USB_PIPE_TX_DATA_LP,
  33         ATH6KL_USB_PIPE_TX_DATA_MP,
  34         ATH6KL_USB_PIPE_TX_DATA_HP,
  35         ATH6KL_USB_PIPE_RX_CTRL,
  36         ATH6KL_USB_PIPE_RX_DATA,
  37         ATH6KL_USB_PIPE_RX_DATA2,
  38         ATH6KL_USB_PIPE_RX_INT,
  39         ATH6KL_USB_PIPE_MAX
  40 };
  41
  42 #define ATH6KL_USB_PIPE_INVALID ATH6KL_USB_PIPE_MAX
  43
  44 struct ath6kl_usb_pipe {
  45         struct list_head urb_list_head;
  46         struct usb_anchor urb_submitted;
  47         u32 urb_alloc;
  48         u32 urb_cnt;
  49         u32 urb_cnt_thresh;
  50         unsigned int usb_pipe_handle;
  51         u32 flags;
  52         u8 ep_address;
  53         u8 logical_pipe_num;
  54         struct ath6kl_usb *ar_usb;
  55         u16 max_packet_size;
  56         struct work_struct io_complete_work;
  57         struct sk_buff_head io_comp_queue;
  58         struct usb_endpoint_descriptor *ep_desc;
  59 };
  60
  61 #define ATH6KL_USB_PIPE_FLAG_TX    (1 << 0)
  62
  63 /* usb device object */
  64 struct ath6kl_usb {
  65         /* protects pipe->urb_list_head and  pipe->urb_cnt */
  66         spinlock_t cs_lock;
  67
  68         struct usb_device *udev;
  69         struct usb_interface *interface;
  70         struct ath6kl_usb_pipe pipes[ATH6KL_USB_PIPE_MAX];
  71         u8 *diag_cmd_buffer;
  72         u8 *diag_resp_buffer;
  73         struct ath6kl *ar;
  74         struct workqueue_struct *wq;
  75 };
  76
  77 /* usb urb object */
  78 struct ath6kl_urb_context {
  79         struct list_head link;
  80         struct ath6kl_usb_pipe *pipe;
  81         struct sk_buff *skb;
  82         struct ath6kl *ar;
  83 };
  84
  85 /* USB endpoint definitions */
  86 #define ATH6KL_USB_EP_ADDR_APP_CTRL_IN          0x81
  87 #define ATH6KL_USB_EP_ADDR_APP_DATA_IN          0x82
  88 #define ATH6KL_USB_EP_ADDR_APP_DATA2_IN         0x83
  89 #define ATH6KL_USB_EP_ADDR_APP_INT_IN           0x84
  90
  91 #define ATH6KL_USB_EP_ADDR_APP_CTRL_OUT         0x01
  92 #define ATH6KL_USB_EP_ADDR_APP_DATA_LP_OUT      0x02
  93 #define ATH6KL_USB_EP_ADDR_APP_DATA_MP_OUT      0x03
  94 #define ATH6KL_USB_EP_ADDR_APP_DATA_HP_OUT      0x04
  95
  96 /* diagnostic command defnitions */
  97 #define ATH6KL_USB_CONTROL_REQ_SEND_BMI_CMD        1
  98 #define ATH6KL_USB_CONTROL_REQ_RECV_BMI_RESP       2
  99 #define ATH6KL_USB_CONTROL_REQ_DIAG_CMD            3
 100 #define ATH6KL_USB_CONTROL_REQ_DIAG_RESP           4
 101
 102 #define ATH6KL_USB_CTRL_DIAG_CC_READ               0
 103 #define ATH6KL_USB_CTRL_DIAG_CC_WRITE              1
 104
 105 struct ath6kl_usb_ctrl_diag_cmd_write {
 106         __le32 cmd;
 107         __le32 address;
 108         __le32 value;
 109         __le32 _pad[1];
 110 } __packed;
 111
 112 struct ath6kl_usb_ctrl_diag_cmd_read {
 113         __le32 cmd;
 114         __le32 address;
 115 } __packed;
 116
 117 struct ath6kl_usb_ctrl_diag_resp_read {
 118         __le32 value;
 119 } __packed;
 120
 121 /* function declarations */
 122 static void ath6kl_usb_recv_complete(struct urb *urb);
 123
 124 #define ATH6KL_USB_IS_BULK_EP(attr) (((attr) & 3) == 0x02)
 125 #define ATH6KL_USB_IS_INT_EP(attr)  (((attr) & 3) == 0x03)
 126 #define ATH6KL_USB_IS_ISOC_EP(attr)  (((attr) & 3) == 0x01)
 127 #define ATH6KL_USB_IS_DIR_IN(addr)  ((addr) & 0x80)
 128
 129 /* pipe/urb operations */
 130 static struct ath6kl_urb_context *
 131 ath6kl_usb_alloc_urb_from_pipe(struct ath6kl_usb_pipe *pipe)
 132 {
 133         struct ath6kl_urb_context *urb_context = NULL;
 134         unsigned long flags;
 135
 136         /* bail if this pipe is not initialized */
 137         if (!pipe->ar_usb)
 138                 return NULL;
 139
 140         spin_lock_irqsave(&pipe->ar_usb->cs_lock, flags);
 141         if (!list_empty(&pipe->urb_list_head)) {
 142                 urb_context =
 143                     list_first_entry(&pipe->urb_list_head,
 144                                      struct ath6kl_urb_context, link);
 145                 list_del(&urb_context->link);
 146                 pipe->urb_cnt--;
 147         }
 148         spin_unlock_irqrestore(&pipe->ar_usb->cs_lock, flags);
 149
 150         return urb_context;
 151 }
 152
 153 static void ath6kl_usb_free_urb_to_pipe(struct ath6kl_usb_pipe *pipe,
 154                                         struct ath6kl_urb_context *urb_context)
 155 {
 156         unsigned long flags;
 157
 158         /* bail if this pipe is not initialized */
 159         if (!pipe->ar_usb)
 160                 return;
 161
 162         spin_lock_irqsave(&pipe->ar_usb->cs_lock, flags);
 163         pipe->urb_cnt++;
 164
 165         list_add(&urb_context->link, &pipe->urb_list_head);
 166         spin_unlock_irqrestore(&pipe->ar_usb->cs_lock, flags);
 167 }
 168
 169 static void ath6kl_usb_cleanup_recv_urb(struct ath6kl_urb_context *urb_context)
 170 {
 171         dev_kfree_skb(urb_context->skb);
 172         urb_context->skb = NULL;
 173
 174         ath6kl_usb_free_urb_to_pipe(urb_context->pipe, urb_context);
 175 }
 176
 177 static inline struct ath6kl_usb *ath6kl_usb_priv(struct ath6kl *ar)
 178 {
 179         return ar->hif_priv;
 180 }
 181
 182 /* pipe resource allocation/cleanup */
 183 static int ath6kl_usb_alloc_pipe_resources(struct ath6kl_usb_pipe *pipe,
 184                                            int urb_cnt)
 185 {
 186         struct ath6kl_urb_context *urb_context;
 187         int status = 0, i;
 188
 189         INIT_LIST_HEAD(&pipe->urb_list_head);
 190         init_usb_anchor(&pipe->urb_submitted);
 191
 192         for (i = 0; i < urb_cnt; i++) {
 193                 urb_context = kzalloc(sizeof(struct ath6kl_urb_context),
 194                                       GFP_KERNEL);
 195                 if (urb_context == NULL) {
 196                         status = -ENOMEM;
 197                         goto fail_alloc_pipe_resources;
 198                 }
 199
 200                 urb_context->pipe = pipe;
 201
 202                 /*
 203                  * we are only allocate the urb contexts here, the actual URB
 204                  * is allocated from the kernel as needed to do a transaction
 205                  */
 206                 pipe->urb_alloc++;
 207                 ath6kl_usb_free_urb_to_pipe(pipe, urb_context);
 208         }
 209
 210         ath6kl_dbg(ATH6KL_DBG_USB,
 211                    "ath6kl usb: alloc resources lpipe:%d hpipe:0x%X urbs:%d\n",
 212                    pipe->logical_pipe_num, pipe->usb_pipe_handle,
 213                    pipe->urb_alloc);
 214
 215 fail_alloc_pipe_resources:
 216         return status;
 217 }
 218
 219 static void ath6kl_usb_free_pipe_resources(struct ath6kl_usb_pipe *pipe)
 220 {
 221         struct ath6kl_urb_context *urb_context;
 222
 223         if (pipe->ar_usb == NULL) {
 224                 /* nothing allocated for this pipe */
 225                 return;
 226         }
 227
 228         ath6kl_dbg(ATH6KL_DBG_USB,
 229                    "ath6kl usb: free resources lpipe:%d"
 230                    "hpipe:0x%X urbs:%d avail:%d\n",
 231                    pipe->logical_pipe_num, pipe->usb_pipe_handle,
 232                    pipe->urb_alloc, pipe->urb_cnt);
 233
 234         if (pipe->urb_alloc != pipe->urb_cnt) {
 235                 ath6kl_dbg(ATH6KL_DBG_USB,
 236                            "ath6kl usb: urb leak! lpipe:%d"
 237                            "hpipe:0x%X urbs:%d avail:%d\n",
 238                            pipe->logical_pipe_num, pipe->usb_pipe_handle,
 239                            pipe->urb_alloc, pipe->urb_cnt);
 240         }
 241
 242         while (true) {
 243                 urb_context = ath6kl_usb_alloc_urb_from_pipe(pipe);
 244                 if (urb_context == NULL)
 245                         break;
 246                 kfree(urb_context);
 247         }
 248 }
 249
 250 static void ath6kl_usb_cleanup_pipe_resources(struct ath6kl_usb *ar_usb)
 251 {
 252         int i;
 253
 254         for (i = 0; i < ATH6KL_USB_PIPE_MAX; i++)
 255                 ath6kl_usb_free_pipe_resources(&ar_usb->pipes[i]);
 256 }
 257
 258 static u8 ath6kl_usb_get_logical_pipe_num(struct ath6kl_usb *ar_usb,
 259                                           u8 ep_address, int *urb_count)
 260 {
 261         u8 pipe_num = ATH6KL_USB_PIPE_INVALID;
 262
 263         switch (ep_address) {
 264         case ATH6KL_USB_EP_ADDR_APP_CTRL_IN:
 265                 pipe_num = ATH6KL_USB_PIPE_RX_CTRL;
 266                 *urb_count = RX_URB_COUNT;
 267                 break;
 268         case ATH6KL_USB_EP_ADDR_APP_DATA_IN:
 269                 pipe_num = ATH6KL_USB_PIPE_RX_DATA;
 270                 *urb_count = RX_URB_COUNT;
 271                 break;
 272         case ATH6KL_USB_EP_ADDR_APP_INT_IN:
 273                 pipe_num = ATH6KL_USB_PIPE_RX_INT;
 274                 *urb_count = RX_URB_COUNT;
 275                 break;
 276         case ATH6KL_USB_EP_ADDR_APP_DATA2_IN:
 277                 pipe_num = ATH6KL_USB_PIPE_RX_DATA2;
 278                 *urb_count = RX_URB_COUNT;
 279                 break;
 280         case ATH6KL_USB_EP_ADDR_APP_CTRL_OUT:
 281                 pipe_num = ATH6KL_USB_PIPE_TX_CTRL;
 282                 *urb_count = TX_URB_COUNT;
 283                 break;
 284         case ATH6KL_USB_EP_ADDR_APP_DATA_LP_OUT:
 285                 pipe_num = ATH6KL_USB_PIPE_TX_DATA_LP;
 286                 *urb_count = TX_URB_COUNT;
 287                 break;
 288         case ATH6KL_USB_EP_ADDR_APP_DATA_MP_OUT:
 289                 pipe_num = ATH6KL_USB_PIPE_TX_DATA_MP;
 290                 *urb_count = TX_URB_COUNT;
 291                 break;
 292         case ATH6KL_USB_EP_ADDR_APP_DATA_HP_OUT:
 293                 pipe_num = ATH6KL_USB_PIPE_TX_DATA_HP;
 294                 *urb_count = TX_URB_COUNT;
 295                 break;
 296         default:
 297                 /* note: there may be endpoints not currently used */
 298                 break;
 299         }
 300
 301         return pipe_num;
 302 }
 303
 304 static int ath6kl_usb_setup_pipe_resources(struct ath6kl_usb *ar_usb)
 305 {
 306         struct usb_interface *interface = ar_usb->interface;
 307         struct usb_host_interface *iface_desc = interface->cur_altsetting;
 308         struct usb_endpoint_descriptor *endpoint;
 309         struct ath6kl_usb_pipe *pipe;
 310         int i, urbcount, status = 0;
 311         u8 pipe_num;
 312
 313         ath6kl_dbg(ATH6KL_DBG_USB, "setting up USB Pipes using interface\n");
 314
 315         /* walk descriptors and setup pipes */
 316         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 317                 endpoint = &iface_desc->endpoint[i].desc;
 318
 319                 if (ATH6KL_USB_IS_BULK_EP(endpoint->bmAttributes)) {
 320                         ath6kl_dbg(ATH6KL_DBG_USB,
 321                                    "%s Bulk Ep:0x%2.2X maxpktsz:%d\n",
 322                                    ATH6KL_USB_IS_DIR_IN
 323                                    (endpoint->bEndpointAddress) ?
 324                                    "RX" : "TX", endpoint->bEndpointAddress,
 325                                    le16_to_cpu(endpoint->wMaxPacketSize));
 326                 } else if (ATH6KL_USB_IS_INT_EP(endpoint->bmAttributes)) {
 327                         ath6kl_dbg(ATH6KL_DBG_USB,
 328                                    "%s Int Ep:0x%2.2X maxpktsz:%d interval:%d\n",
 329                                    ATH6KL_USB_IS_DIR_IN
 330                                    (endpoint->bEndpointAddress) ?
 331                                    "RX" : "TX", endpoint->bEndpointAddress,
 332                                    le16_to_cpu(endpoint->wMaxPacketSize),
 333                                    endpoint->bInterval);
 334                 } else if (ATH6KL_USB_IS_ISOC_EP(endpoint->bmAttributes)) {
 335                         /* TODO for ISO */
 336                         ath6kl_dbg(ATH6KL_DBG_USB,
 337                                    "%s ISOC Ep:0x%2.2X maxpktsz:%d interval:%d\n",
 338                                    ATH6KL_USB_IS_DIR_IN
 339                                    (endpoint->bEndpointAddress) ?
 340                                    "RX" : "TX", endpoint->bEndpointAddress,
 341                                    le16_to_cpu(endpoint->wMaxPacketSize),
 342                                    endpoint->bInterval);
 343                 }
 344
 345                 /* Ignore broken descriptors. */
 346                 if (usb_endpoint_maxp(endpoint) == 0)
 347                         continue;
 348
 349                 urbcount = 0;
 350
 351                 pipe_num =
 352                     ath6kl_usb_get_logical_pipe_num(ar_usb,
 353                                                     endpoint->bEndpointAddress,
 354                                                     &urbcount);
 355                 if (pipe_num == ATH6KL_USB_PIPE_INVALID)
 356                         continue;
 357
 358                 pipe = &ar_usb->pipes[pipe_num];
 359                 if (pipe->ar_usb != NULL) {
 360                         /* hmmm..pipe was already setup */
 361                         continue;
 362                 }
 363
 364                 pipe->ar_usb = ar_usb;
 365                 pipe->logical_pipe_num = pipe_num;
 366                 pipe->ep_address = endpoint->bEndpointAddress;
 367                 pipe->max_packet_size = le16_to_cpu(endpoint->wMaxPacketSize);
 368
 369                 if (ATH6KL_USB_IS_BULK_EP(endpoint->bmAttributes)) {
 370                         if (ATH6KL_USB_IS_DIR_IN(pipe->ep_address)) {
 371                                 pipe->usb_pipe_handle =
 372                                     usb_rcvbulkpipe(ar_usb->udev,
 373                                                     pipe->ep_address);
 374                         } else {
 375                                 pipe->usb_pipe_handle =
 376                                     usb_sndbulkpipe(ar_usb->udev,
 377                                                     pipe->ep_address);
 378                         }
 379                 } else if (ATH6KL_USB_IS_INT_EP(endpoint->bmAttributes)) {
 380                         if (ATH6KL_USB_IS_DIR_IN(pipe->ep_address)) {
 381                                 pipe->usb_pipe_handle =
 382                                     usb_rcvintpipe(ar_usb->udev,
 383                                                    pipe->ep_address);
 384                         } else {
 385                                 pipe->usb_pipe_handle =
 386                                     usb_sndintpipe(ar_usb->udev,
 387                                                    pipe->ep_address);
 388                         }
 389                 } else if (ATH6KL_USB_IS_ISOC_EP(endpoint->bmAttributes)) {
 390                         /* TODO for ISO */
 391                         if (ATH6KL_USB_IS_DIR_IN(pipe->ep_address)) {
 392                                 pipe->usb_pipe_handle =
 393                                     usb_rcvisocpipe(ar_usb->udev,
 394                                                     pipe->ep_address);
 395                         } else {
 396                                 pipe->usb_pipe_handle =
 397                                     usb_sndisocpipe(ar_usb->udev,
 398                                                     pipe->ep_address);
 399                         }
 400                 }
 401
 402                 pipe->ep_desc = endpoint;
 403
 404                 if (!ATH6KL_USB_IS_DIR_IN(pipe->ep_address))
 405                         pipe->flags |= ATH6KL_USB_PIPE_FLAG_TX;
 406
 407                 status = ath6kl_usb_alloc_pipe_resources(pipe, urbcount);
 408                 if (status != 0)
 409                         break;
 410         }
 411
 412         return status;
 413 }
 414
 415 /* pipe operations */
 416 static void ath6kl_usb_post_recv_transfers(struct ath6kl_usb_pipe *recv_pipe,
 417                                            int buffer_length)
 418 {
 419         struct ath6kl_urb_context *urb_context;
 420         struct urb *urb;
 421         int usb_status;
 422
 423         while (true) {
 424                 urb_context = ath6kl_usb_alloc_urb_from_pipe(recv_pipe);
 425                 if (urb_context == NULL)
 426                         break;
 427
 428                 urb_context->skb = dev_alloc_skb(buffer_length);
 429                 if (urb_context->skb == NULL)
 430                         goto err_cleanup_urb;
 431
 432                 urb = usb_alloc_urb(0, GFP_ATOMIC);
 433                 if (urb == NULL)
 434                         goto err_cleanup_urb;
 435
 436                 usb_fill_bulk_urb(urb,
 437                                   recv_pipe->ar_usb->udev,
 438                                   recv_pipe->usb_pipe_handle,
 439                                   urb_context->skb->data,
 440                                   buffer_length,
 441                                   ath6kl_usb_recv_complete, urb_context);
 442
 443                 ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 444                            "ath6kl usb: bulk recv submit:%d, 0x%X (ep:0x%2.2X), %d bytes buf:0x%p\n",
 445                            recv_pipe->logical_pipe_num,
 446                            recv_pipe->usb_pipe_handle, recv_pipe->ep_address,
 447                            buffer_length, urb_context->skb);
 448
 449                 usb_anchor_urb(urb, &recv_pipe->urb_submitted);
 450                 usb_status = usb_submit_urb(urb, GFP_ATOMIC);
 451
 452                 if (usb_status) {
 453                         ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 454                                    "ath6kl usb : usb bulk recv failed %d\n",
 455                                    usb_status);
 456                         usb_unanchor_urb(urb);
 457                         usb_free_urb(urb);
 458                         goto err_cleanup_urb;
 459                 }
 460                 usb_free_urb(urb);
 461         }
 462         return;
 463
 464 err_cleanup_urb:
 465         ath6kl_usb_cleanup_recv_urb(urb_context);
 466         return;
 467 }
 468
 469 static void ath6kl_usb_flush_all(struct ath6kl_usb *ar_usb)
 470 {
 471         int i;
 472
 473         for (i = 0; i < ATH6KL_USB_PIPE_MAX; i++) {
 474                 if (ar_usb->pipes[i].ar_usb != NULL)
 475                         usb_kill_anchored_urbs(&ar_usb->pipes[i].urb_submitted);
 476         }
 477
 478         /*
 479          * Flushing any pending I/O may schedule work this call will block
 480          * until all scheduled work runs to completion.
 481          */
 482         flush_workqueue(ar_usb->wq);
 483 }
 484
 485 static void ath6kl_usb_start_recv_pipes(struct ath6kl_usb *ar_usb)
 486 {
 487         /*
 488          * note: control pipe is no longer used
 489          * ar_usb->pipes[ATH6KL_USB_PIPE_RX_CTRL].urb_cnt_thresh =
 490          *      ar_usb->pipes[ATH6KL_USB_PIPE_RX_CTRL].urb_alloc/2;
 491          * ath6kl_usb_post_recv_transfers(&ar_usb->
 492          *              pipes[ATH6KL_USB_PIPE_RX_CTRL],
 493          *              ATH6KL_USB_RX_BUFFER_SIZE);
 494          */
 495
 496         ar_usb->pipes[ATH6KL_USB_PIPE_RX_DATA].urb_cnt_thresh = 1;
 497
 498         ath6kl_usb_post_recv_transfers(&ar_usb->pipes[ATH6KL_USB_PIPE_RX_DATA],
 499                                        ATH6KL_USB_RX_BUFFER_SIZE);
 500 }
 501
 502 /* hif usb rx/tx completion functions */
 503 static void ath6kl_usb_recv_complete(struct urb *urb)
 504 {
 505         struct ath6kl_urb_context *urb_context = urb->context;
 506         struct ath6kl_usb_pipe *pipe = urb_context->pipe;
 507         struct sk_buff *skb = NULL;
 508         int status = 0;
 509
 510         ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 511                    "%s: recv pipe: %d, stat:%d, len:%d urb:0x%p\n", __func__,
 512                    pipe->logical_pipe_num, urb->status, urb->actual_length,
 513                    urb);
 514
 515         if (urb->status != 0) {
 516                 status = -EIO;
 517                 switch (urb->status) {
 518                 case -ECONNRESET:
 519                 case -ENOENT:
 520                 case -ESHUTDOWN:
 521                         /*
 522                          * no need to spew these errors when device
 523                          * removed or urb killed due to driver shutdown
 524                          */
 525                         status = -ECANCELED;
 526                         break;
 527                 default:
 528                         ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 529                                    "%s recv pipe: %d (ep:0x%2.2X), failed:%d\n",
 530                                    __func__, pipe->logical_pipe_num,
 531                                    pipe->ep_address, urb->status);
 532                         break;
 533                 }
 534                 goto cleanup_recv_urb;
 535         }
 536
 537         if (urb->actual_length == 0)
 538                 goto cleanup_recv_urb;
 539
 540         skb = urb_context->skb;
 541
 542         /* we are going to pass it up */
 543         urb_context->skb = NULL;
 544         skb_put(skb, urb->actual_length);
 545
 546         /* note: queue implements a lock */
 547         skb_queue_tail(&pipe->io_comp_queue, skb);
 548         queue_work(pipe->ar_usb->wq, &pipe->io_complete_work);
 549
 550 cleanup_recv_urb:
 551         ath6kl_usb_cleanup_recv_urb(urb_context);
 552
 553         if (status == 0 &&
 554             pipe->urb_cnt >= pipe->urb_cnt_thresh) {
 555                 /* our free urbs are piling up, post more transfers */
 556                 ath6kl_usb_post_recv_transfers(pipe, ATH6KL_USB_RX_BUFFER_SIZE);
 557         }
 558 }
 559
 560 static void ath6kl_usb_usb_transmit_complete(struct urb *urb)
 561 {
 562         struct ath6kl_urb_context *urb_context = urb->context;
 563         struct ath6kl_usb_pipe *pipe = urb_context->pipe;
 564         struct sk_buff *skb;
 565
 566         ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 567                    "%s: pipe: %d, stat:%d, len:%d\n",
 568                    __func__, pipe->logical_pipe_num, urb->status,
 569                    urb->actual_length);
 570
 571         if (urb->status != 0) {
 572                 ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 573                            "%s:  pipe: %d, failed:%d\n",
 574                            __func__, pipe->logical_pipe_num, urb->status);
 575         }
 576
 577         skb = urb_context->skb;
 578         urb_context->skb = NULL;
 579         ath6kl_usb_free_urb_to_pipe(urb_context->pipe, urb_context);
 580
 581         /* note: queue implements a lock */
 582         skb_queue_tail(&pipe->io_comp_queue, skb);
 583         queue_work(pipe->ar_usb->wq, &pipe->io_complete_work);
 584 }
 585
 586 static void ath6kl_usb_io_comp_work(struct work_struct *work)
 587 {
 588         struct ath6kl_usb_pipe *pipe = container_of(work,
 589                                                     struct ath6kl_usb_pipe,
 590                                                     io_complete_work);
 591         struct ath6kl_usb *ar_usb;
 592         struct sk_buff *skb;
 593
 594         ar_usb = pipe->ar_usb;
 595
 596         while ((skb = skb_dequeue(&pipe->io_comp_queue))) {
 597                 if (pipe->flags & ATH6KL_USB_PIPE_FLAG_TX) {
 598                         ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 599                                    "ath6kl usb xmit callback buf:0x%p\n", skb);
 600                         ath6kl_core_tx_complete(ar_usb->ar, skb);
 601                 } else {
 602                         ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 603                                    "ath6kl usb recv callback buf:0x%p\n", skb);
 604                         ath6kl_core_rx_complete(ar_usb->ar, skb,
 605                                                 pipe->logical_pipe_num);
 606                 }
 607         }
 608 }
 609
 610 #define ATH6KL_USB_MAX_DIAG_CMD (sizeof(struct ath6kl_usb_ctrl_diag_cmd_write))
 611 #define ATH6KL_USB_MAX_DIAG_RESP (sizeof(struct ath6kl_usb_ctrl_diag_resp_read))
 612
 613 static void ath6kl_usb_destroy(struct ath6kl_usb *ar_usb)
 614 {
 615         ath6kl_usb_flush_all(ar_usb);
 616
 617         ath6kl_usb_cleanup_pipe_resources(ar_usb);
 618
 619         usb_set_intfdata(ar_usb->interface, NULL);
 620
 621         kfree(ar_usb->diag_cmd_buffer);
 622         kfree(ar_usb->diag_resp_buffer);
 623         destroy_workqueue(ar_usb->wq);
 624
 625         kfree(ar_usb);
 626 }
 627
 628 static struct ath6kl_usb *ath6kl_usb_create(struct usb_interface *interface)
 629 {
 630         struct usb_device *dev = interface_to_usbdev(interface);
 631         struct ath6kl_usb *ar_usb;
 632         struct ath6kl_usb_pipe *pipe;
 633         int status = 0;
 634         int i;
 635
 636         /* ath6kl_usb_destroy() needs ar_usb != NULL && ar_usb->wq != NULL. */
 637         ar_usb = kzalloc(sizeof(struct ath6kl_usb), GFP_KERNEL);
 638         if (ar_usb == NULL)
 639                 return NULL;
 640         ar_usb->wq = alloc_workqueue("ath6kl_wq", 0, 0);
 641         if (!ar_usb->wq) {
 642                 kfree(ar_usb);
 643                 return NULL;
 644         }
 645
 646         usb_set_intfdata(interface, ar_usb);
 647         spin_lock_init(&(ar_usb->cs_lock));
 648         ar_usb->udev = dev;
 649         ar_usb->interface = interface;
 650
 651         for (i = 0; i < ATH6KL_USB_PIPE_MAX; i++) {
 652                 pipe = &ar_usb->pipes[i];
 653                 INIT_WORK(&pipe->io_complete_work,
 654                           ath6kl_usb_io_comp_work);
 655                 skb_queue_head_init(&pipe->io_comp_queue);
 656         }
 657
 658         ar_usb->diag_cmd_buffer = kzalloc(ATH6KL_USB_MAX_DIAG_CMD, GFP_KERNEL);
 659         if (ar_usb->diag_cmd_buffer == NULL) {
 660                 status = -ENOMEM;
 661                 goto fail_ath6kl_usb_create;
 662         }
 663
 664         ar_usb->diag_resp_buffer = kzalloc(ATH6KL_USB_MAX_DIAG_RESP,
 665                                            GFP_KERNEL);
 666         if (ar_usb->diag_resp_buffer == NULL) {
 667                 status = -ENOMEM;
 668                 goto fail_ath6kl_usb_create;
 669         }
 670
 671         status = ath6kl_usb_setup_pipe_resources(ar_usb);
 672
 673 fail_ath6kl_usb_create:
 674         if (status != 0) {
 675                 ath6kl_usb_destroy(ar_usb);
 676                 ar_usb = NULL;
 677         }
 678         return ar_usb;
 679 }
 680
 681 static void ath6kl_usb_device_detached(struct usb_interface *interface)
 682 {
 683         struct ath6kl_usb *ar_usb;
 684
 685         ar_usb = usb_get_intfdata(interface);
 686         if (ar_usb == NULL)
 687                 return;
 688
 689         ath6kl_stop_txrx(ar_usb->ar);
 690
 691         /* Delay to wait for the target to reboot */
 692         mdelay(20);
 693         ath6kl_core_cleanup(ar_usb->ar);
 694         ath6kl_usb_destroy(ar_usb);
 695 }
 696
 697 /* exported hif usb APIs for htc pipe */
 698 static void hif_start(struct ath6kl *ar)
 699 {
 700         struct ath6kl_usb *device = ath6kl_usb_priv(ar);
 701         int i;
 702
 703         ath6kl_usb_start_recv_pipes(device);
 704
 705         /* set the TX resource avail threshold for each TX pipe */
 706         for (i = ATH6KL_USB_PIPE_TX_CTRL;
 707              i <= ATH6KL_USB_PIPE_TX_DATA_HP; i++) {
 708                 device->pipes[i].urb_cnt_thresh =
 709                     device->pipes[i].urb_alloc / 2;
 710         }
 711 }
 712
 713 static int ath6kl_usb_send(struct ath6kl *ar, u8 PipeID,
 714                            struct sk_buff *hdr_skb, struct sk_buff *skb)
 715 {
 716         struct ath6kl_usb *device = ath6kl_usb_priv(ar);
 717         struct ath6kl_usb_pipe *pipe = &device->pipes[PipeID];
 718         struct ath6kl_urb_context *urb_context;
 719         int usb_status, status = 0;
 720         struct urb *urb;
 721         u8 *data;
 722         u32 len;
 723
 724         ath6kl_dbg(ATH6KL_DBG_USB_BULK, "+%s pipe : %d, buf:0x%p\n",
 725                    __func__, PipeID, skb);
 726
 727         urb_context = ath6kl_usb_alloc_urb_from_pipe(pipe);
 728
 729         if (urb_context == NULL) {
 730                 /*
 731                  * TODO: it is possible to run out of urbs if
 732                  * 2 endpoints map to the same pipe ID
 733                  */
 734                 ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 735                            "%s pipe:%d no urbs left. URB Cnt : %d\n",
 736                            __func__, PipeID, pipe->urb_cnt);
 737                 status = -ENOMEM;
 738                 goto fail_hif_send;
 739         }
 740
 741         urb_context->skb = skb;
 742
 743         data = skb->data;
 744         len = skb->len;
 745
 746         urb = usb_alloc_urb(0, GFP_ATOMIC);
 747         if (urb == NULL) {
 748                 status = -ENOMEM;
 749                 ath6kl_usb_free_urb_to_pipe(urb_context->pipe,
 750                                             urb_context);
 751                 goto fail_hif_send;
 752         }
 753
 754         usb_fill_bulk_urb(urb,
 755                           device->udev,
 756                           pipe->usb_pipe_handle,
 757                           data,
 758                           len,
 759                           ath6kl_usb_usb_transmit_complete, urb_context);
 760
 761         if ((len % pipe->max_packet_size) == 0) {
 762                 /* hit a max packet boundary on this pipe */
 763                 urb->transfer_flags |= URB_ZERO_PACKET;
 764         }
 765
 766         ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 767                    "athusb bulk send submit:%d, 0x%X (ep:0x%2.2X), %d bytes\n",
 768                    pipe->logical_pipe_num, pipe->usb_pipe_handle,
 769                    pipe->ep_address, len);
 770
 771         usb_anchor_urb(urb, &pipe->urb_submitted);
 772         usb_status = usb_submit_urb(urb, GFP_ATOMIC);
 773
 774         if (usb_status) {
 775                 ath6kl_dbg(ATH6KL_DBG_USB_BULK,
 776                            "ath6kl usb : usb bulk transmit failed %d\n",
 777                            usb_status);
 778                 usb_unanchor_urb(urb);
 779                 ath6kl_usb_free_urb_to_pipe(urb_context->pipe,
 780                                             urb_context);
 781                 status = -EINVAL;
 782         }
 783         usb_free_urb(urb);
 784
 785 fail_hif_send:
 786         return status;
 787 }
 788
 789 static void hif_stop(struct ath6kl *ar)
 790 {
 791         struct ath6kl_usb *device = ath6kl_usb_priv(ar);
 792
 793         ath6kl_usb_flush_all(device);
 794 }
 795
 796 static void ath6kl_usb_get_default_pipe(struct ath6kl *ar,
 797                                         u8 *ul_pipe, u8 *dl_pipe)
 798 {
 799         *ul_pipe = ATH6KL_USB_PIPE_TX_CTRL;
 800         *dl_pipe = ATH6KL_USB_PIPE_RX_CTRL;
 801 }
 802
 803 static int ath6kl_usb_map_service_pipe(struct ath6kl *ar, u16 svc_id,
 804                                        u8 *ul_pipe, u8 *dl_pipe)
 805 {
 806         int status = 0;
 807
 808         switch (svc_id) {
 809         case HTC_CTRL_RSVD_SVC:
 810         case WMI_CONTROL_SVC:
 811                 *ul_pipe = ATH6KL_USB_PIPE_TX_CTRL;
 812                 /* due to large control packets, shift to data pipe */
 813                 *dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
 814                 break;
 815         case WMI_DATA_BE_SVC:
 816         case WMI_DATA_BK_SVC:
 817                 *ul_pipe = ATH6KL_USB_PIPE_TX_DATA_LP;
 818                 /*
 819                 * Disable rxdata2 directly, it will be enabled
 820                 * if FW enable rxdata2
 821                 */
 822                 *dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
 823                 break;
 824         case WMI_DATA_VI_SVC:
 825
 826                 if (test_bit(ATH6KL_FW_CAPABILITY_MAP_LP_ENDPOINT,
 827                              ar->fw_capabilities))
 828                         *ul_pipe = ATH6KL_USB_PIPE_TX_DATA_LP;
 829                 else
 830                         *ul_pipe = ATH6KL_USB_PIPE_TX_DATA_MP;
 831                 /*
 832                 * Disable rxdata2 directly, it will be enabled
 833                 * if FW enable rxdata2
 834                 */
 835                 *dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
 836                 break;
 837         case WMI_DATA_VO_SVC:
 838
 839                 if (test_bit(ATH6KL_FW_CAPABILITY_MAP_LP_ENDPOINT,
 840                              ar->fw_capabilities))
 841                         *ul_pipe = ATH6KL_USB_PIPE_TX_DATA_LP;
 842                 else
 843                         *ul_pipe = ATH6KL_USB_PIPE_TX_DATA_MP;
 844                 /*
 845                 * Disable rxdata2 directly, it will be enabled
 846                 * if FW enable rxdata2
 847                 */
 848                 *dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
 849                 break;
 850         default:
 851                 status = -EPERM;
 852                 break;
 853         }
 854
 855         return status;
 856 }
 857
 858 static u16 ath6kl_usb_get_free_queue_number(struct ath6kl *ar, u8 pipe_id)
 859 {
 860         struct ath6kl_usb *device = ath6kl_usb_priv(ar);
 861
 862         return device->pipes[pipe_id].urb_cnt;
 863 }
 864
 865 static void hif_detach_htc(struct ath6kl *ar)
 866 {
 867         struct ath6kl_usb *device = ath6kl_usb_priv(ar);
 868
 869         ath6kl_usb_flush_all(device);
 870 }
 871
 872 static int ath6kl_usb_submit_ctrl_out(struct ath6kl_usb *ar_usb,
 873                                    u8 req, u16 value, u16 index, void *data,
 874                                    u32 size)
 875 {
 876         u8 *buf = NULL;
 877         int ret;
 878
 879         if (size > 0) {
 880                 buf = kmemdup(data, size, GFP_KERNEL);
 881                 if (buf == NULL)
 882                         return -ENOMEM;
 883         }
 884
 885         /* note: if successful returns number of bytes transfered */
 886         ret = usb_control_msg(ar_usb->udev,
 887                               usb_sndctrlpipe(ar_usb->udev, 0),
 888                               req,
 889                               USB_DIR_OUT | USB_TYPE_VENDOR |
 890                               USB_RECIP_DEVICE, value, index, buf,
 891                               size, 1000);
 892
 893         if (ret < 0) {
 894                 ath6kl_warn("Failed to submit usb control message: %d\n", ret);
 895                 kfree(buf);
 896                 return ret;
 897         }
 898
 899         kfree(buf);
 900
 901         return 0;
 902 }
 903
 904 static int ath6kl_usb_submit_ctrl_in(struct ath6kl_usb *ar_usb,
 905                                   u8 req, u16 value, u16 index, void *data,
 906                                   u32 size)
 907 {
 908         u8 *buf = NULL;
 909         int ret;
 910
 911         if (size > 0) {
 912                 buf = kmalloc(size, GFP_KERNEL);
 913                 if (buf == NULL)
 914                         return -ENOMEM;
 915         }
 916
 917         /* note: if successful returns number of bytes transfered */
 918         ret = usb_control_msg(ar_usb->udev,
 919                                  usb_rcvctrlpipe(ar_usb->udev, 0),
 920                                  req,
 921                                  USB_DIR_IN | USB_TYPE_VENDOR |
 922                                  USB_RECIP_DEVICE, value, index, buf,
 923                                  size, 2000);
 924
 925         if (ret < 0) {
 926                 ath6kl_warn("Failed to read usb control message: %d\n", ret);
 927                 kfree(buf);
 928                 return ret;
 929         }
 930
 931         memcpy((u8 *) data, buf, size);
 932
 933         kfree(buf);
 934
 935         return 0;
 936 }
 937
 938 static int ath6kl_usb_ctrl_msg_exchange(struct ath6kl_usb *ar_usb,
 939                                      u8 req_val, u8 *req_buf, u32 req_len,
 940                                      u8 resp_val, u8 *resp_buf, u32 *resp_len)
 941 {
 942         int ret;
 943
 944         /* send command */
 945         ret = ath6kl_usb_submit_ctrl_out(ar_usb, req_val, 0, 0,
 946                                          req_buf, req_len);
 947
 948         if (ret != 0)
 949                 return ret;
 950
 951         if (resp_buf == NULL) {
 952                 /* no expected response */
 953                 return ret;
 954         }
 955
 956         /* get response */
 957         ret = ath6kl_usb_submit_ctrl_in(ar_usb, resp_val, 0, 0,
 958                                         resp_buf, *resp_len);
 959
 960         return ret;
 961 }
 962
 963 static int ath6kl_usb_diag_read32(struct ath6kl *ar, u32 address, u32 *data)
 964 {
 965         struct ath6kl_usb *ar_usb = ar->hif_priv;
 966         struct ath6kl_usb_ctrl_diag_resp_read *resp;
 967         struct ath6kl_usb_ctrl_diag_cmd_read *cmd;
 968         u32 resp_len;
 969         int ret;
 970
 971         cmd = (struct ath6kl_usb_ctrl_diag_cmd_read *) ar_usb->diag_cmd_buffer;
 972
 973         memset(cmd, 0, sizeof(*cmd));
 974         cmd->cmd = ATH6KL_USB_CTRL_DIAG_CC_READ;
 975         cmd->address = cpu_to_le32(address);
 976         resp_len = sizeof(*resp);
 977
 978         ret = ath6kl_usb_ctrl_msg_exchange(ar_usb,
 979                                 ATH6KL_USB_CONTROL_REQ_DIAG_CMD,
 980                                 (u8 *) cmd,
 981                                 sizeof(struct ath6kl_usb_ctrl_diag_cmd_write),
 982                                 ATH6KL_USB_CONTROL_REQ_DIAG_RESP,
 983                                 ar_usb->diag_resp_buffer, &resp_len);
 984
 985         if (ret) {
 986                 ath6kl_warn("diag read32 failed: %d\n", ret);
 987                 return ret;
 988         }
 989
 990         resp = (struct ath6kl_usb_ctrl_diag_resp_read *)
 991                 ar_usb->diag_resp_buffer;
 992
 993         *data = le32_to_cpu(resp->value);
 994
 995         return ret;
 996 }
 997
 998 static int ath6kl_usb_diag_write32(struct ath6kl *ar, u32 address, __le32 data)
 999 {
1000         struct ath6kl_usb *ar_usb = ar->hif_priv;
1001         struct ath6kl_usb_ctrl_diag_cmd_write *cmd;
1002         int ret;
1003
1004         cmd = (struct ath6kl_usb_ctrl_diag_cmd_write *) ar_usb->diag_cmd_buffer;
1005
1006         memset(cmd, 0, sizeof(struct ath6kl_usb_ctrl_diag_cmd_write));
1007         cmd->cmd = cpu_to_le32(ATH6KL_USB_CTRL_DIAG_CC_WRITE);
1008         cmd->address = cpu_to_le32(address);
1009         cmd->value = data;
1010
1011         ret = ath6kl_usb_ctrl_msg_exchange(ar_usb,
1012                                            ATH6KL_USB_CONTROL_REQ_DIAG_CMD,
1013                                            (u8 *) cmd,
1014                                            sizeof(*cmd),
1015                                            0, NULL, NULL);
1016         if (ret) {
1017                 ath6kl_warn("diag_write32 failed: %d\n", ret);
1018                 return ret;
1019         }
1020
1021         return 0;
1022 }
1023
1024 static int ath6kl_usb_bmi_read(struct ath6kl *ar, u8 *buf, u32 len)
1025 {
1026         struct ath6kl_usb *ar_usb = ar->hif_priv;
1027         int ret;
1028
1029         /* get response */
1030         ret = ath6kl_usb_submit_ctrl_in(ar_usb,
1031                                         ATH6KL_USB_CONTROL_REQ_RECV_BMI_RESP,
1032                                         0, 0, buf, len);
1033         if (ret) {
1034                 ath6kl_err("Unable to read the bmi data from the device: %d\n",
1035                            ret);
1036                 return ret;
1037         }
1038
1039         return 0;
1040 }
1041
1042 static int ath6kl_usb_bmi_write(struct ath6kl *ar, u8 *buf, u32 len)
1043 {
1044         struct ath6kl_usb *ar_usb = ar->hif_priv;
1045         int ret;
1046
1047         /* send command */
1048         ret = ath6kl_usb_submit_ctrl_out(ar_usb,
1049                                          ATH6KL_USB_CONTROL_REQ_SEND_BMI_CMD,
1050                                          0, 0, buf, len);
1051         if (ret) {
1052                 ath6kl_err("unable to send the bmi data to the device: %d\n",
1053                            ret);
1054                 return ret;
1055         }
1056
1057         return 0;
1058 }
1059
1060 static int ath6kl_usb_power_on(struct ath6kl *ar)
1061 {
1062         hif_start(ar);
1063         return 0;
1064 }
1065
1066 static int ath6kl_usb_power_off(struct ath6kl *ar)
1067 {
1068         hif_detach_htc(ar);
1069         return 0;
1070 }
1071
1072 static void ath6kl_usb_stop(struct ath6kl *ar)
1073 {
1074         hif_stop(ar);
1075 }
1076
1077 static void ath6kl_usb_cleanup_scatter(struct ath6kl *ar)
1078 {
1079         /*
1080          * USB doesn't support it. Just return.
1081          */
1082         return;
1083 }
1084
1085 static int ath6kl_usb_suspend(struct ath6kl *ar, struct cfg80211_wowlan *wow)
1086 {
1087         /*
1088          * cfg80211 suspend/WOW currently not supported for USB.
1089          */
1090         return 0;
1091 }
1092
1093 static int ath6kl_usb_resume(struct ath6kl *ar)
1094 {
1095         /*
1096          * cfg80211 resume currently not supported for USB.
1097          */
1098         return 0;
1099 }
1100
1101 static const struct ath6kl_hif_ops ath6kl_usb_ops = {
1102         .diag_read32 = ath6kl_usb_diag_read32,
1103         .diag_write32 = ath6kl_usb_diag_write32,
1104         .bmi_read = ath6kl_usb_bmi_read,
1105         .bmi_write = ath6kl_usb_bmi_write,
1106         .power_on = ath6kl_usb_power_on,
1107         .power_off = ath6kl_usb_power_off,
1108         .stop = ath6kl_usb_stop,
1109         .pipe_send = ath6kl_usb_send,
1110         .pipe_get_default = ath6kl_usb_get_default_pipe,
1111         .pipe_map_service = ath6kl_usb_map_service_pipe,
1112         .pipe_get_free_queue_number = ath6kl_usb_get_free_queue_number,
1113         .cleanup_scatter = ath6kl_usb_cleanup_scatter,
1114         .suspend = ath6kl_usb_suspend,
1115         .resume = ath6kl_usb_resume,
1116 };
1117
1118 /* ath6kl usb driver registered functions */
1119 static int ath6kl_usb_probe(struct usb_interface *interface,
1120                             const struct usb_device_id *id)
1121 {
1122         struct usb_device *dev = interface_to_usbdev(interface);
1123         struct ath6kl *ar;
1124         struct ath6kl_usb *ar_usb = NULL;
1125         int vendor_id, product_id;
1126         int ret = 0;
1127
1128         usb_get_dev(dev);
1129
1130         vendor_id = le16_to_cpu(dev->descriptor.idVendor);
1131         product_id = le16_to_cpu(dev->descriptor.idProduct);
1132
1133         ath6kl_dbg(ATH6KL_DBG_USB, "vendor_id = %04x\n", vendor_id);
1134         ath6kl_dbg(ATH6KL_DBG_USB, "product_id = %04x\n", product_id);
1135
1136         if (interface->cur_altsetting)
1137                 ath6kl_dbg(ATH6KL_DBG_USB, "USB Interface %d\n",
1138                            interface->cur_altsetting->desc.bInterfaceNumber);
1139
1140
1141         if (dev->speed == USB_SPEED_HIGH)
1142                 ath6kl_dbg(ATH6KL_DBG_USB, "USB 2.0 Host\n");
1143         else
1144                 ath6kl_dbg(ATH6KL_DBG_USB, "USB 1.1 Host\n");
1145
1146         ar_usb = ath6kl_usb_create(interface);
1147
1148         if (ar_usb == NULL) {
1149                 ret = -ENOMEM;
1150                 goto err_usb_put;
1151         }
1152
1153         ar = ath6kl_core_create(&ar_usb->udev->dev);
1154         if (ar == NULL) {
1155                 ath6kl_err("Failed to alloc ath6kl core\n");
1156                 ret = -ENOMEM;
1157                 goto err_usb_destroy;
1158         }
1159
1160         ar->hif_priv = ar_usb;
1161         ar->hif_type = ATH6KL_HIF_TYPE_USB;
1162         ar->hif_ops = &ath6kl_usb_ops;
1163         ar->mbox_info.block_size = 16;
1164         ar->bmi.max_data_size = 252;
1165
1166         ar_usb->ar = ar;
1167
1168         ret = ath6kl_core_init(ar, ATH6KL_HTC_TYPE_PIPE);
1169         if (ret) {
1170                 ath6kl_err("Failed to init ath6kl core: %d\n", ret);
1171                 goto err_core_free;
1172         }
1173
1174         return ret;
1175
1176 err_core_free:
1177         ath6kl_core_destroy(ar);
1178 err_usb_destroy:
1179         ath6kl_usb_destroy(ar_usb);
1180 err_usb_put:
1181         usb_put_dev(dev);
1182
1183         return ret;
1184 }
1185
1186 static void ath6kl_usb_remove(struct usb_interface *interface)
1187 {
1188         usb_put_dev(interface_to_usbdev(interface));
1189         ath6kl_usb_device_detached(interface);
1190 }
1191
1192 #ifdef CONFIG_PM
1193
1194 static int ath6kl_usb_pm_suspend(struct usb_interface *interface,
1195                               pm_message_t message)
1196 {
1197         struct ath6kl_usb *device;
1198         device = usb_get_intfdata(interface);
1199
1200         ath6kl_usb_flush_all(device);
1201         return 0;
1202 }
1203
1204 static int ath6kl_usb_pm_resume(struct usb_interface *interface)
1205 {
1206         struct ath6kl_usb *device;
1207         device = usb_get_intfdata(interface);
1208
1209         ath6kl_usb_post_recv_transfers(&device->pipes[ATH6KL_USB_PIPE_RX_DATA],
1210                                        ATH6KL_USB_RX_BUFFER_SIZE);
1211         ath6kl_usb_post_recv_transfers(&device->pipes[ATH6KL_USB_PIPE_RX_DATA2],
1212                                        ATH6KL_USB_RX_BUFFER_SIZE);
1213
1214         return 0;
1215 }
1216
1217 #else
1218
1219 #define ath6kl_usb_pm_suspend NULL
1220 #define ath6kl_usb_pm_resume NULL
1221
1222 #endif
1223
1224 /* table of devices that work with this driver */
1225 static const struct usb_device_id ath6kl_usb_ids[] = {
1226         {USB_DEVICE(0x0cf3, 0x9375)},
1227         {USB_DEVICE(0x0cf3, 0x9374)},
1228         {USB_DEVICE(0x04da, 0x390d)},
1229         { /* Terminating entry */ },
1230 };
1231
1232 MODULE_DEVICE_TABLE(usb, ath6kl_usb_ids);
1233
1234 static struct usb_driver ath6kl_usb_driver = {
1235         .name = "ath6kl_usb",
1236         .probe = ath6kl_usb_probe,
1237         .suspend = ath6kl_usb_pm_suspend,
1238         .resume = ath6kl_usb_pm_resume,
1239         .disconnect = ath6kl_usb_remove,
1240         .id_table = ath6kl_usb_ids,
1241         .supports_autosuspend = true,
1242         .disable_hub_initiated_lpm = 1,
1243 };
1244
1245 module_usb_driver(ath6kl_usb_driver);
1246
1247 MODULE_AUTHOR("Atheros Communications, Inc.");
1248 MODULE_DESCRIPTION("Driver support for Atheros AR600x USB devices");
1249 MODULE_LICENSE("Dual BSD/GPL");
1250 MODULE_FIRMWARE(AR6004_HW_1_0_FIRMWARE_FILE);
1251 MODULE_FIRMWARE(AR6004_HW_1_0_BOARD_DATA_FILE);
1252 MODULE_FIRMWARE(AR6004_HW_1_0_DEFAULT_BOARD_DATA_FILE);
1253 MODULE_FIRMWARE(AR6004_HW_1_1_FIRMWARE_FILE);
1254 MODULE_FIRMWARE(AR6004_HW_1_1_BOARD_DATA_FILE);
1255 MODULE_FIRMWARE(AR6004_HW_1_1_DEFAULT_BOARD_DATA_FILE);
1256 MODULE_FIRMWARE(AR6004_HW_1_2_FIRMWARE_FILE);
1257 MODULE_FIRMWARE(AR6004_HW_1_2_BOARD_DATA_FILE);
1258 MODULE_FIRMWARE(AR6004_HW_1_2_DEFAULT_BOARD_DATA_FILE);
1259 MODULE_FIRMWARE(AR6004_HW_1_3_FW_DIR "/" AR6004_HW_1_3_FIRMWARE_FILE);
1260 MODULE_FIRMWARE(AR6004_HW_1_3_BOARD_DATA_FILE);
1261 MODULE_FIRMWARE(AR6004_HW_1_3_DEFAULT_BOARD_DATA_FILE);