drivers/net/wireless/mwifiex/usb.c

   1 /*
   2  * Marvell Wireless LAN device driver: USB specific handling
   3  *
   4  * Copyright (C) 2012-2014, Marvell International Ltd.
   5  *
   6  * This software file (the "File") is distributed by Marvell International
   7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
   8  * (the "License").  You may use, redistribute and/or modify this File in
   9  * accordance with the terms and conditions of the License, a copy of which
  10  * is available by writing to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
  12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  13  *
  14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
  17  * this warranty disclaimer.
  18  */
  19
  20 #include "main.h"
  21 #include "usb.h"
  22
  23 #define USB_VERSION     "1.0"
  24
  25 static u8 user_rmmod;
  26 static struct mwifiex_if_ops usb_ops;
  27 static struct semaphore add_remove_card_sem;
  28
  29 static struct usb_device_id mwifiex_usb_table[] = {
  30         /* 8766 */
  31         {USB_DEVICE(USB8XXX_VID, USB8766_PID_1)},
  32         {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8766_PID_2,
  33                                        USB_CLASS_VENDOR_SPEC,
  34                                        USB_SUBCLASS_VENDOR_SPEC, 0xff)},
  35         /* 8797 */
  36         {USB_DEVICE(USB8XXX_VID, USB8797_PID_1)},
  37         {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8797_PID_2,
  38                                        USB_CLASS_VENDOR_SPEC,
  39                                        USB_SUBCLASS_VENDOR_SPEC, 0xff)},
  40         /* 8801 */
  41         {USB_DEVICE(USB8XXX_VID, USB8801_PID_1)},
  42         {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8801_PID_2,
  43                                        USB_CLASS_VENDOR_SPEC,
  44                                        USB_SUBCLASS_VENDOR_SPEC, 0xff)},
  45         /* 8897 */
  46         {USB_DEVICE(USB8XXX_VID, USB8897_PID_1)},
  47         {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8897_PID_2,
  48                                        USB_CLASS_VENDOR_SPEC,
  49                                        USB_SUBCLASS_VENDOR_SPEC, 0xff)},
  50         /* 8997 */
  51         {USB_DEVICE(USB8XXX_VID, USB8997_PID_1)},
  52         {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8997_PID_2,
  53                                        USB_CLASS_VENDOR_SPEC,
  54                                        USB_SUBCLASS_VENDOR_SPEC, 0xff)},
  55         { }     /* Terminating entry */
  56 };
  57
  58 MODULE_DEVICE_TABLE(usb, mwifiex_usb_table);
  59
  60 static int mwifiex_usb_submit_rx_urb(struct urb_context *ctx, int size);
  61
  62 /* This function handles received packet. Necessary action is taken based on
  63  * cmd/event/data.
  64  */
  65 static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
  66                             struct sk_buff *skb, u8 ep)
  67 {
  68         u32 recv_type;
  69         __le32 tmp;
  70         int ret;
  71
  72         if (adapter->hs_activated)
  73                 mwifiex_process_hs_config(adapter);
  74
  75         if (skb->len < INTF_HEADER_LEN) {
  76                 mwifiex_dbg(adapter, ERROR,
  77                             "%s: invalid skb->len\n", __func__);
  78                 return -1;
  79         }
  80
  81         switch (ep) {
  82         case MWIFIEX_USB_EP_CMD_EVENT:
  83                 mwifiex_dbg(adapter, EVENT,
  84                             "%s: EP_CMD_EVENT\n", __func__);
  85                 skb_copy_from_linear_data(skb, &tmp, INTF_HEADER_LEN);
  86                 recv_type = le32_to_cpu(tmp);
  87                 skb_pull(skb, INTF_HEADER_LEN);
  88
  89                 switch (recv_type) {
  90                 case MWIFIEX_USB_TYPE_CMD:
  91                         if (skb->len > MWIFIEX_SIZE_OF_CMD_BUFFER) {
  92                                 mwifiex_dbg(adapter, ERROR,
  93                                             "CMD: skb->len too large\n");
  94                                 ret = -1;
  95                                 goto exit_restore_skb;
  96                         } else if (!adapter->curr_cmd) {
  97                                 mwifiex_dbg(adapter, WARN, "CMD: no curr_cmd\n");
  98                                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
  99                                         mwifiex_process_sleep_confirm_resp(
 100                                                         adapter, skb->data,
 101                                                         skb->len);
 102                                         ret = 0;
 103                                         goto exit_restore_skb;
 104                                 }
 105                                 ret = -1;
 106                                 goto exit_restore_skb;
 107                         }
 108
 109                         adapter->curr_cmd->resp_skb = skb;
 110                         adapter->cmd_resp_received = true;
 111                         break;
 112                 case MWIFIEX_USB_TYPE_EVENT:
 113                         if (skb->len < sizeof(u32)) {
 114                                 mwifiex_dbg(adapter, ERROR,
 115                                             "EVENT: skb->len too small\n");
 116                                 ret = -1;
 117                                 goto exit_restore_skb;
 118                         }
 119                         skb_copy_from_linear_data(skb, &tmp, sizeof(u32));
 120                         adapter->event_cause = le32_to_cpu(tmp);
 121                         mwifiex_dbg(adapter, EVENT,
 122                                     "event_cause %#x\n", adapter->event_cause);
 123
 124                         if (skb->len > MAX_EVENT_SIZE) {
 125                                 mwifiex_dbg(adapter, ERROR,
 126                                             "EVENT: event body too large\n");
 127                                 ret = -1;
 128                                 goto exit_restore_skb;
 129                         }
 130
 131                         memcpy(adapter->event_body, skb->data +
 132                                MWIFIEX_EVENT_HEADER_LEN, skb->len);
 133
 134                         adapter->event_received = true;
 135                         adapter->event_skb = skb;
 136                         break;
 137                 default:
 138                         mwifiex_dbg(adapter, ERROR,
 139                                     "unknown recv_type %#x\n", recv_type);
 140                         return -1;
 141                 }
 142                 break;
 143         case MWIFIEX_USB_EP_DATA:
 144                 mwifiex_dbg(adapter, DATA, "%s: EP_DATA\n", __func__);
 145                 if (skb->len > MWIFIEX_RX_DATA_BUF_SIZE) {
 146                         mwifiex_dbg(adapter, ERROR,
 147                                     "DATA: skb->len too large\n");
 148                         return -1;
 149                 }
 150
 151                 skb_queue_tail(&adapter->rx_data_q, skb);
 152                 adapter->data_received = true;
 153                 atomic_inc(&adapter->rx_pending);
 154                 break;
 155         default:
 156                 mwifiex_dbg(adapter, ERROR,
 157                             "%s: unknown endport %#x\n", __func__, ep);
 158                 return -1;
 159         }
 160
 161         return -EINPROGRESS;
 162
 163 exit_restore_skb:
 164         /* The buffer will be reused for further cmds/events */
 165         skb_push(skb, INTF_HEADER_LEN);
 166
 167         return ret;
 168 }
 169
 170 static void mwifiex_usb_rx_complete(struct urb *urb)
 171 {
 172         struct urb_context *context = (struct urb_context *)urb->context;
 173         struct mwifiex_adapter *adapter = context->adapter;
 174         struct sk_buff *skb = context->skb;
 175         struct usb_card_rec *card;
 176         int recv_length = urb->actual_length;
 177         int size, status;
 178
 179         if (!adapter || !adapter->card) {
 180                 pr_err("mwifiex adapter or card structure is not valid\n");
 181                 return;
 182         }
 183
 184         card = (struct usb_card_rec *)adapter->card;
 185         if (card->rx_cmd_ep == context->ep)
 186                 atomic_dec(&card->rx_cmd_urb_pending);
 187         else
 188                 atomic_dec(&card->rx_data_urb_pending);
 189
 190         if (recv_length) {
 191                 if (urb->status || (adapter->surprise_removed)) {
 192                         mwifiex_dbg(adapter, ERROR,
 193                                     "URB status is failed: %d\n", urb->status);
 194                         /* Do not free skb in case of command ep */
 195                         if (card->rx_cmd_ep != context->ep)
 196                                 dev_kfree_skb_any(skb);
 197                         goto setup_for_next;
 198                 }
 199                 if (skb->len > recv_length)
 200                         skb_trim(skb, recv_length);
 201                 else
 202                         skb_put(skb, recv_length - skb->len);
 203
 204                 status = mwifiex_usb_recv(adapter, skb, context->ep);
 205
 206                 mwifiex_dbg(adapter, INFO,
 207                             "info: recv_length=%d, status=%d\n",
 208                             recv_length, status);
 209                 if (status == -EINPROGRESS) {
 210                         mwifiex_queue_main_work(adapter);
 211
 212                         /* urb for data_ep is re-submitted now;
 213                          * urb for cmd_ep will be re-submitted in callback
 214                          * mwifiex_usb_recv_complete
 215                          */
 216                         if (card->rx_cmd_ep == context->ep)
 217                                 return;
 218                 } else {
 219                         if (status == -1)
 220                                 mwifiex_dbg(adapter, ERROR,
 221                                             "received data processing failed!\n");
 222
 223                         /* Do not free skb in case of command ep */
 224                         if (card->rx_cmd_ep != context->ep)
 225                                 dev_kfree_skb_any(skb);
 226                 }
 227         } else if (urb->status) {
 228                 if (!adapter->is_suspended) {
 229                         mwifiex_dbg(adapter, FATAL,
 230                                     "Card is removed: %d\n", urb->status);
 231                         adapter->surprise_removed = true;
 232                 }
 233                 dev_kfree_skb_any(skb);
 234                 return;
 235         } else {
 236                 /* Do not free skb in case of command ep */
 237                 if (card->rx_cmd_ep != context->ep)
 238                         dev_kfree_skb_any(skb);
 239
 240                 /* fall through setup_for_next */
 241         }
 242
 243 setup_for_next:
 244         if (card->rx_cmd_ep == context->ep)
 245                 size = MWIFIEX_RX_CMD_BUF_SIZE;
 246         else
 247                 size = MWIFIEX_RX_DATA_BUF_SIZE;
 248
 249         if (card->rx_cmd_ep == context->ep) {
 250                 mwifiex_usb_submit_rx_urb(context, size);
 251         } else {
 252                 if (atomic_read(&adapter->rx_pending) <= HIGH_RX_PENDING){
 253                         mwifiex_usb_submit_rx_urb(context, size);
 254                 }else{
 255                         context->skb = NULL;
 256                 }
 257         }
 258
 259         return;
 260 }
 261
 262 static void mwifiex_usb_tx_complete(struct urb *urb)
 263 {
 264         struct urb_context *context = (struct urb_context *)(urb->context);
 265         struct mwifiex_adapter *adapter = context->adapter;
 266         struct usb_card_rec *card = adapter->card;
 267
 268         mwifiex_dbg(adapter, INFO,
 269                     "%s: status: %d\n", __func__, urb->status);
 270
 271         if (context->ep == card->tx_cmd_ep) {
 272                 mwifiex_dbg(adapter, CMD,
 273                             "%s: CMD\n", __func__);
 274                 atomic_dec(&card->tx_cmd_urb_pending);
 275                 adapter->cmd_sent = false;
 276         } else {
 277                 mwifiex_dbg(adapter, DATA,
 278                             "%s: DATA\n", __func__);
 279                 atomic_dec(&card->tx_data_urb_pending);
 280                 mwifiex_write_data_complete(adapter, context->skb, 0,
 281                                             urb->status ? -1 : 0);
 282         }
 283
 284         mwifiex_queue_main_work(adapter);
 285
 286         return;
 287 }
 288
 289 static int mwifiex_usb_submit_rx_urb(struct urb_context *ctx, int size)
 290 {
 291         struct mwifiex_adapter *adapter = ctx->adapter;
 292         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
 293
 294         if (card->rx_cmd_ep != ctx->ep) {
 295                 ctx->skb = dev_alloc_skb(size);
 296                 if (!ctx->skb) {
 297                         mwifiex_dbg(adapter, ERROR,
 298                                     "%s: dev_alloc_skb failed\n", __func__);
 299                         return -ENOMEM;
 300                 }
 301         }
 302
 303         usb_fill_bulk_urb(ctx->urb, card->udev,
 304                           usb_rcvbulkpipe(card->udev, ctx->ep), ctx->skb->data,
 305                           size, mwifiex_usb_rx_complete, (void *)ctx);
 306
 307         if (card->rx_cmd_ep == ctx->ep)
 308                 atomic_inc(&card->rx_cmd_urb_pending);
 309         else
 310                 atomic_inc(&card->rx_data_urb_pending);
 311
 312         if (usb_submit_urb(ctx->urb, GFP_ATOMIC)) {
 313                 mwifiex_dbg(adapter, ERROR, "usb_submit_urb failed\n");
 314                 dev_kfree_skb_any(ctx->skb);
 315                 ctx->skb = NULL;
 316
 317                 if (card->rx_cmd_ep == ctx->ep)
 318                         atomic_dec(&card->rx_cmd_urb_pending);
 319                 else
 320                         atomic_dec(&card->rx_data_urb_pending);
 321
 322                 return -1;
 323         }
 324
 325         return 0;
 326 }
 327
 328 static void mwifiex_usb_free(struct usb_card_rec *card)
 329 {
 330         int i;
 331
 332         if (atomic_read(&card->rx_cmd_urb_pending) && card->rx_cmd.urb)
 333                 usb_kill_urb(card->rx_cmd.urb);
 334
 335         usb_free_urb(card->rx_cmd.urb);
 336         card->rx_cmd.urb = NULL;
 337
 338         if (atomic_read(&card->rx_data_urb_pending))
 339                 for (i = 0; i < MWIFIEX_RX_DATA_URB; i++)
 340                         if (card->rx_data_list[i].urb)
 341                                 usb_kill_urb(card->rx_data_list[i].urb);
 342
 343         for (i = 0; i < MWIFIEX_RX_DATA_URB; i++) {
 344                 usb_free_urb(card->rx_data_list[i].urb);
 345                 card->rx_data_list[i].urb = NULL;
 346         }
 347
 348         for (i = 0; i < MWIFIEX_TX_DATA_URB; i++) {
 349                 usb_free_urb(card->tx_data_list[i].urb);
 350                 card->tx_data_list[i].urb = NULL;
 351         }
 352
 353         usb_free_urb(card->tx_cmd.urb);
 354         card->tx_cmd.urb = NULL;
 355
 356         return;
 357 }
 358
 359 /* This function probes an mwifiex device and registers it. It allocates
 360  * the card structure, initiates the device registration and initialization
 361  * procedure by adding a logical interface.
 362  */
 363 static int mwifiex_usb_probe(struct usb_interface *intf,
 364                              const struct usb_device_id *id)
 365 {
 366         struct usb_device *udev = interface_to_usbdev(intf);
 367         struct usb_host_interface *iface_desc = intf->cur_altsetting;
 368         struct usb_endpoint_descriptor *epd;
 369         int ret, i;
 370         struct usb_card_rec *card;
 371         u16 id_vendor, id_product, bcd_device, bcd_usb;
 372
 373         card = kzalloc(sizeof(struct usb_card_rec), GFP_KERNEL);
 374         if (!card)
 375                 return -ENOMEM;
 376
 377         id_vendor = le16_to_cpu(udev->descriptor.idVendor);
 378         id_product = le16_to_cpu(udev->descriptor.idProduct);
 379         bcd_device = le16_to_cpu(udev->descriptor.bcdDevice);
 380         bcd_usb = le16_to_cpu(udev->descriptor.bcdUSB);
 381         pr_debug("info: VID/PID = %X/%X, Boot2 version = %X\n",
 382                  id_vendor, id_product, bcd_device);
 383
 384         /* PID_1 is used for firmware downloading only */
 385         switch (id_product) {
 386         case USB8766_PID_1:
 387         case USB8797_PID_1:
 388         case USB8801_PID_1:
 389         case USB8897_PID_1:
 390         case USB8997_PID_1:
 391                 card->usb_boot_state = USB8XXX_FW_DNLD;
 392                 break;
 393         case USB8766_PID_2:
 394         case USB8797_PID_2:
 395         case USB8801_PID_2:
 396         case USB8897_PID_2:
 397         case USB8997_PID_2:
 398                 card->usb_boot_state = USB8XXX_FW_READY;
 399                 break;
 400         default:
 401                 pr_warn("unknown id_product %#x\n", id_product);
 402                 card->usb_boot_state = USB8XXX_FW_DNLD;
 403                 break;
 404         }
 405
 406         card->udev = udev;
 407         card->intf = intf;
 408
 409         pr_debug("info: bcdUSB=%#x Device Class=%#x SubClass=%#x Protocol=%#x\n",
 410                  udev->descriptor.bcdUSB, udev->descriptor.bDeviceClass,
 411                  udev->descriptor.bDeviceSubClass,
 412                  udev->descriptor.bDeviceProtocol);
 413
 414         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 415                 epd = &iface_desc->endpoint[i].desc;
 416                 if (usb_endpoint_dir_in(epd) &&
 417                     usb_endpoint_num(epd) == MWIFIEX_USB_EP_CMD_EVENT &&
 418                     usb_endpoint_xfer_bulk(epd)) {
 419                         pr_debug("info: bulk IN: max pkt size: %d, addr: %d\n",
 420                                  le16_to_cpu(epd->wMaxPacketSize),
 421                                  epd->bEndpointAddress);
 422                         card->rx_cmd_ep = usb_endpoint_num(epd);
 423                         atomic_set(&card->rx_cmd_urb_pending, 0);
 424                 }
 425                 if (usb_endpoint_dir_in(epd) &&
 426                     usb_endpoint_num(epd) == MWIFIEX_USB_EP_DATA &&
 427                     usb_endpoint_xfer_bulk(epd)) {
 428                         pr_debug("info: bulk IN: max pkt size: %d, addr: %d\n",
 429                                  le16_to_cpu(epd->wMaxPacketSize),
 430                                  epd->bEndpointAddress);
 431                         card->rx_data_ep = usb_endpoint_num(epd);
 432                         atomic_set(&card->rx_data_urb_pending, 0);
 433                 }
 434                 if (usb_endpoint_dir_out(epd) &&
 435                     usb_endpoint_num(epd) == MWIFIEX_USB_EP_DATA &&
 436                     usb_endpoint_xfer_bulk(epd)) {
 437                         pr_debug("info: bulk OUT: max pkt size: %d, addr: %d\n",
 438                                  le16_to_cpu(epd->wMaxPacketSize),
 439                                  epd->bEndpointAddress);
 440                         card->tx_data_ep = usb_endpoint_num(epd);
 441                         atomic_set(&card->tx_data_urb_pending, 0);
 442                 }
 443                 if (usb_endpoint_dir_out(epd) &&
 444                     usb_endpoint_num(epd) == MWIFIEX_USB_EP_CMD_EVENT &&
 445                     usb_endpoint_xfer_bulk(epd)) {
 446                         pr_debug("info: bulk OUT: max pkt size: %d, addr: %d\n",
 447                                  le16_to_cpu(epd->wMaxPacketSize),
 448                                  epd->bEndpointAddress);
 449                         card->tx_cmd_ep = usb_endpoint_num(epd);
 450                         atomic_set(&card->tx_cmd_urb_pending, 0);
 451                         card->bulk_out_maxpktsize =
 452                                         le16_to_cpu(epd->wMaxPacketSize);
 453                 }
 454         }
 455
 456         usb_set_intfdata(intf, card);
 457
 458         ret = mwifiex_add_card(card, &add_remove_card_sem, &usb_ops,
 459                                MWIFIEX_USB);
 460         if (ret) {
 461                 pr_err("%s: mwifiex_add_card failed: %d\n", __func__, ret);
 462                 usb_reset_device(udev);
 463                 kfree(card);
 464                 return ret;
 465         }
 466
 467         usb_get_dev(udev);
 468
 469         return 0;
 470 }
 471
 472 /* Kernel needs to suspend all functions separately. Therefore all
 473  * registered functions must have drivers with suspend and resume
 474  * methods. Failing that the kernel simply removes the whole card.
 475  *
 476  * If already not suspended, this function allocates and sends a
 477  * 'host sleep activate' request to the firmware and turns off the traffic.
 478  */
 479 static int mwifiex_usb_suspend(struct usb_interface *intf, pm_message_t message)
 480 {
 481         struct usb_card_rec *card = usb_get_intfdata(intf);
 482         struct mwifiex_adapter *adapter;
 483         int i;
 484
 485         if (!card || !card->adapter) {
 486                 pr_err("%s: card or card->adapter is NULL\n", __func__);
 487                 return 0;
 488         }
 489         adapter = card->adapter;
 490
 491         if (unlikely(adapter->is_suspended))
 492                 mwifiex_dbg(adapter, WARN,
 493                             "Device already suspended\n");
 494
 495         mwifiex_enable_hs(adapter);
 496
 497         /* 'is_suspended' flag indicates device is suspended.
 498          * It must be set here before the usb_kill_urb() calls. Reason
 499          * is in the complete handlers, urb->status(= -ENOENT) and
 500          * this flag is used in combination to distinguish between a
 501          * 'suspended' state and a 'disconnect' one.
 502          */
 503         adapter->is_suspended = true;
 504         adapter->hs_enabling = false;
 505
 506         if (atomic_read(&card->rx_cmd_urb_pending) && card->rx_cmd.urb)
 507                 usb_kill_urb(card->rx_cmd.urb);
 508
 509         if (atomic_read(&card->rx_data_urb_pending))
 510                 for (i = 0; i < MWIFIEX_RX_DATA_URB; i++)
 511                         if (card->rx_data_list[i].urb)
 512                                 usb_kill_urb(card->rx_data_list[i].urb);
 513
 514         for (i = 0; i < MWIFIEX_TX_DATA_URB; i++)
 515                 if (card->tx_data_list[i].urb)
 516                         usb_kill_urb(card->tx_data_list[i].urb);
 517
 518         if (card->tx_cmd.urb)
 519                 usb_kill_urb(card->tx_cmd.urb);
 520
 521         return 0;
 522 }
 523
 524 /* Kernel needs to suspend all functions separately. Therefore all
 525  * registered functions must have drivers with suspend and resume
 526  * methods. Failing that the kernel simply removes the whole card.
 527  *
 528  * If already not resumed, this function turns on the traffic and
 529  * sends a 'host sleep cancel' request to the firmware.
 530  */
 531 static int mwifiex_usb_resume(struct usb_interface *intf)
 532 {
 533         struct usb_card_rec *card = usb_get_intfdata(intf);
 534         struct mwifiex_adapter *adapter;
 535         int i;
 536
 537         if (!card || !card->adapter) {
 538                 pr_err("%s: card or card->adapter is NULL\n", __func__);
 539                 return 0;
 540         }
 541         adapter = card->adapter;
 542
 543         if (unlikely(!adapter->is_suspended)) {
 544                 mwifiex_dbg(adapter, WARN,
 545                             "Device already resumed\n");
 546                 return 0;
 547         }
 548
 549         /* Indicate device resumed. The netdev queue will be resumed only
 550          * after the urbs have been re-submitted
 551          */
 552         adapter->is_suspended = false;
 553
 554         if (!atomic_read(&card->rx_data_urb_pending))
 555                 for (i = 0; i < MWIFIEX_RX_DATA_URB; i++)
 556                         mwifiex_usb_submit_rx_urb(&card->rx_data_list[i],
 557                                                   MWIFIEX_RX_DATA_BUF_SIZE);
 558
 559         if (!atomic_read(&card->rx_cmd_urb_pending)) {
 560                 card->rx_cmd.skb = dev_alloc_skb(MWIFIEX_RX_CMD_BUF_SIZE);
 561                 if (card->rx_cmd.skb)
 562                         mwifiex_usb_submit_rx_urb(&card->rx_cmd,
 563                                                   MWIFIEX_RX_CMD_BUF_SIZE);
 564         }
 565
 566         /* Disable Host Sleep */
 567         if (adapter->hs_activated)
 568                 mwifiex_cancel_hs(mwifiex_get_priv(adapter,
 569                                                    MWIFIEX_BSS_ROLE_ANY),
 570                                   MWIFIEX_ASYNC_CMD);
 571
 572         return 0;
 573 }
 574
 575 static void mwifiex_usb_disconnect(struct usb_interface *intf)
 576 {
 577         struct usb_card_rec *card = usb_get_intfdata(intf);
 578         struct mwifiex_adapter *adapter;
 579
 580         if (!card || !card->adapter) {
 581                 pr_err("%s: card or card->adapter is NULL\n", __func__);
 582                 return;
 583         }
 584
 585         adapter = card->adapter;
 586         if (!adapter->priv_num)
 587                 return;
 588
 589         if (user_rmmod) {
 590 #ifdef CONFIG_PM
 591                 if (adapter->is_suspended)
 592                         mwifiex_usb_resume(intf);
 593 #endif
 594
 595                 mwifiex_deauthenticate_all(adapter);
 596
 597                 mwifiex_init_shutdown_fw(mwifiex_get_priv(adapter,
 598                                                           MWIFIEX_BSS_ROLE_ANY),
 599                                          MWIFIEX_FUNC_SHUTDOWN);
 600         }
 601
 602         mwifiex_usb_free(card);
 603
 604         mwifiex_dbg(adapter, FATAL,
 605                     "%s: removing card\n", __func__);
 606         mwifiex_remove_card(adapter, &add_remove_card_sem);
 607
 608         usb_set_intfdata(intf, NULL);
 609         usb_put_dev(interface_to_usbdev(intf));
 610         kfree(card);
 611
 612         return;
 613 }
 614
 615 static struct usb_driver mwifiex_usb_driver = {
 616         .name = "mwifiex_usb",
 617         .probe = mwifiex_usb_probe,
 618         .disconnect = mwifiex_usb_disconnect,
 619         .id_table = mwifiex_usb_table,
 620         .suspend = mwifiex_usb_suspend,
 621         .resume = mwifiex_usb_resume,
 622         .soft_unbind = 1,
 623 };
 624
 625 static int mwifiex_usb_tx_init(struct mwifiex_adapter *adapter)
 626 {
 627         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
 628         int i;
 629
 630         card->tx_cmd.adapter = adapter;
 631         card->tx_cmd.ep = card->tx_cmd_ep;
 632
 633         card->tx_cmd.urb = usb_alloc_urb(0, GFP_KERNEL);
 634         if (!card->tx_cmd.urb) {
 635                 mwifiex_dbg(adapter, ERROR,
 636                             "tx_cmd.urb allocation failed\n");
 637                 return -ENOMEM;
 638         }
 639
 640         card->tx_data_ix = 0;
 641
 642         for (i = 0; i < MWIFIEX_TX_DATA_URB; i++) {
 643                 card->tx_data_list[i].adapter = adapter;
 644                 card->tx_data_list[i].ep = card->tx_data_ep;
 645
 646                 card->tx_data_list[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 647                 if (!card->tx_data_list[i].urb) {
 648                         mwifiex_dbg(adapter, ERROR,
 649                                     "tx_data_list[] urb allocation failed\n");
 650                         return -ENOMEM;
 651                 }
 652         }
 653
 654         return 0;
 655 }
 656
 657 static int mwifiex_usb_rx_init(struct mwifiex_adapter *adapter)
 658 {
 659         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
 660         int i;
 661
 662         card->rx_cmd.adapter = adapter;
 663         card->rx_cmd.ep = card->rx_cmd_ep;
 664
 665         card->rx_cmd.urb = usb_alloc_urb(0, GFP_KERNEL);
 666         if (!card->rx_cmd.urb) {
 667                 mwifiex_dbg(adapter, ERROR, "rx_cmd.urb allocation failed\n");
 668                 return -ENOMEM;
 669         }
 670
 671         card->rx_cmd.skb = dev_alloc_skb(MWIFIEX_RX_CMD_BUF_SIZE);
 672         if (!card->rx_cmd.skb)
 673                 return -ENOMEM;
 674
 675         if (mwifiex_usb_submit_rx_urb(&card->rx_cmd, MWIFIEX_RX_CMD_BUF_SIZE))
 676                 return -1;
 677
 678         for (i = 0; i < MWIFIEX_RX_DATA_URB; i++) {
 679                 card->rx_data_list[i].adapter = adapter;
 680                 card->rx_data_list[i].ep = card->rx_data_ep;
 681
 682                 card->rx_data_list[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 683                 if (!card->rx_data_list[i].urb) {
 684                         mwifiex_dbg(adapter, ERROR,
 685                                     "rx_data_list[] urb allocation failed\n");
 686                         return -1;
 687                 }
 688                 if (mwifiex_usb_submit_rx_urb(&card->rx_data_list[i],
 689                                               MWIFIEX_RX_DATA_BUF_SIZE))
 690                         return -1;
 691         }
 692
 693         return 0;
 694 }
 695
 696 static int mwifiex_write_data_sync(struct mwifiex_adapter *adapter, u8 *pbuf,
 697                                    u32 *len, u8 ep, u32 timeout)
 698 {
 699         struct usb_card_rec *card = adapter->card;
 700         int actual_length, ret;
 701
 702         if (!(*len % card->bulk_out_maxpktsize))
 703                 (*len)++;
 704
 705         /* Send the data block */
 706         ret = usb_bulk_msg(card->udev, usb_sndbulkpipe(card->udev, ep), pbuf,
 707                            *len, &actual_length, timeout);
 708         if (ret) {
 709                 mwifiex_dbg(adapter, ERROR,
 710                             "usb_bulk_msg for tx failed: %d\n", ret);
 711                 return ret;
 712         }
 713
 714         *len = actual_length;
 715
 716         return ret;
 717 }
 718
 719 static int mwifiex_read_data_sync(struct mwifiex_adapter *adapter, u8 *pbuf,
 720                                   u32 *len, u8 ep, u32 timeout)
 721 {
 722         struct usb_card_rec *card = adapter->card;
 723         int actual_length, ret;
 724
 725         /* Receive the data response */
 726         ret = usb_bulk_msg(card->udev, usb_rcvbulkpipe(card->udev, ep), pbuf,
 727                            *len, &actual_length, timeout);
 728         if (ret) {
 729                 mwifiex_dbg(adapter, ERROR,
 730                             "usb_bulk_msg for rx failed: %d\n", ret);
 731                 return ret;
 732         }
 733
 734         *len = actual_length;
 735
 736         return ret;
 737 }
 738
 739 /* This function write a command/data packet to card. */
 740 static int mwifiex_usb_host_to_card(struct mwifiex_adapter *adapter, u8 ep,
 741                                     struct sk_buff *skb,
 742                                     struct mwifiex_tx_param *tx_param)
 743 {
 744         struct usb_card_rec *card = adapter->card;
 745         struct urb_context *context;
 746         u8 *data = (u8 *)skb->data;
 747         struct urb *tx_urb;
 748
 749         if (adapter->is_suspended) {
 750                 mwifiex_dbg(adapter, ERROR,
 751                             "%s: not allowed while suspended\n", __func__);
 752                 return -1;
 753         }
 754
 755         if (adapter->surprise_removed) {
 756                 mwifiex_dbg(adapter, ERROR, "%s: device removed\n", __func__);
 757                 return -1;
 758         }
 759
 760         if (ep == card->tx_data_ep &&
 761             atomic_read(&card->tx_data_urb_pending) >= MWIFIEX_TX_DATA_URB) {
 762                 return -EBUSY;
 763         }
 764
 765         mwifiex_dbg(adapter, INFO, "%s: ep=%d\n", __func__, ep);
 766
 767         if (ep == card->tx_cmd_ep) {
 768                 context = &card->tx_cmd;
 769         } else {
 770                 if (card->tx_data_ix >= MWIFIEX_TX_DATA_URB)
 771                         card->tx_data_ix = 0;
 772                 context = &card->tx_data_list[card->tx_data_ix++];
 773         }
 774
 775         context->adapter = adapter;
 776         context->ep = ep;
 777         context->skb = skb;
 778         tx_urb = context->urb;
 779
 780         usb_fill_bulk_urb(tx_urb, card->udev, usb_sndbulkpipe(card->udev, ep),
 781                           data, skb->len, mwifiex_usb_tx_complete,
 782                           (void *)context);
 783
 784         tx_urb->transfer_flags |= URB_ZERO_PACKET;
 785
 786         if (ep == card->tx_cmd_ep)
 787                 atomic_inc(&card->tx_cmd_urb_pending);
 788         else
 789                 atomic_inc(&card->tx_data_urb_pending);
 790
 791         if (usb_submit_urb(tx_urb, GFP_ATOMIC)) {
 792                 mwifiex_dbg(adapter, ERROR,
 793                             "%s: usb_submit_urb failed\n", __func__);
 794                 if (ep == card->tx_cmd_ep) {
 795                         atomic_dec(&card->tx_cmd_urb_pending);
 796                 } else {
 797                         atomic_dec(&card->tx_data_urb_pending);
 798                         if (card->tx_data_ix)
 799                                 card->tx_data_ix--;
 800                         else
 801                                 card->tx_data_ix = MWIFIEX_TX_DATA_URB;
 802                 }
 803
 804                 return -1;
 805         } else {
 806                 if (ep == card->tx_data_ep &&
 807                     atomic_read(&card->tx_data_urb_pending) ==
 808                                                         MWIFIEX_TX_DATA_URB)
 809                         return -ENOSR;
 810         }
 811
 812         return -EINPROGRESS;
 813 }
 814
 815 /* This function register usb device and initialize parameter. */
 816 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
 817 {
 818         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
 819
 820         card->adapter = adapter;
 821         adapter->dev = &card->udev->dev;
 822
 823         switch (le16_to_cpu(card->udev->descriptor.idProduct)) {
 824         case USB8997_PID_1:
 825         case USB8997_PID_2:
 826                 adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K;
 827                 strcpy(adapter->fw_name, USB8997_DEFAULT_FW_NAME);
 828                 adapter->ext_scan = true;
 829                 break;
 830         case USB8897_PID_1:
 831         case USB8897_PID_2:
 832                 adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K;
 833                 strcpy(adapter->fw_name, USB8897_DEFAULT_FW_NAME);
 834                 adapter->ext_scan = true;
 835                 break;
 836         case USB8766_PID_1:
 837         case USB8766_PID_2:
 838                 adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
 839                 strcpy(adapter->fw_name, USB8766_DEFAULT_FW_NAME);
 840                 adapter->ext_scan = true;
 841                 break;
 842         case USB8801_PID_1:
 843         case USB8801_PID_2:
 844                 adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
 845                 strcpy(adapter->fw_name, USB8801_DEFAULT_FW_NAME);
 846                 adapter->ext_scan = false;
 847                 break;
 848         case USB8797_PID_1:
 849         case USB8797_PID_2:
 850         default:
 851                 adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
 852                 strcpy(adapter->fw_name, USB8797_DEFAULT_FW_NAME);
 853                 break;
 854         }
 855
 856         return 0;
 857 }
 858
 859 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
 860 {
 861         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
 862
 863         card->adapter = NULL;
 864 }
 865
 866 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
 867                                     struct mwifiex_fw_image *fw)
 868 {
 869         int ret = 0;
 870         u8 *firmware = fw->fw_buf, *recv_buff;
 871         u32 retries = USB8XXX_FW_MAX_RETRY, dlen;
 872         u32 fw_seqnum = 0, tlen = 0, dnld_cmd = 0;
 873         struct fw_data *fwdata;
 874         struct fw_sync_header sync_fw;
 875         u8 check_winner = 1;
 876
 877         if (!firmware) {
 878                 mwifiex_dbg(adapter, ERROR,
 879                             "No firmware image found! Terminating download\n");
 880                 ret = -1;
 881                 goto fw_exit;
 882         }
 883
 884         /* Allocate memory for transmit */
 885         fwdata = kzalloc(FW_DNLD_TX_BUF_SIZE, GFP_KERNEL);
 886         if (!fwdata) {
 887                 ret = -ENOMEM;
 888                 goto fw_exit;
 889         }
 890
 891         /* Allocate memory for receive */
 892         recv_buff = kzalloc(FW_DNLD_RX_BUF_SIZE, GFP_KERNEL);
 893         if (!recv_buff)
 894                 goto cleanup;
 895
 896         do {
 897                 /* Send pseudo data to check winner status first */
 898                 if (check_winner) {
 899                         memset(&fwdata->fw_hdr, 0, sizeof(struct fw_header));
 900                         dlen = 0;
 901                 } else {
 902                         /* copy the header of the fw_data to get the length */
 903                         memcpy(&fwdata->fw_hdr, &firmware[tlen],
 904                                sizeof(struct fw_header));
 905
 906                         dlen = le32_to_cpu(fwdata->fw_hdr.data_len);
 907                         dnld_cmd = le32_to_cpu(fwdata->fw_hdr.dnld_cmd);
 908                         tlen += sizeof(struct fw_header);
 909
 910                         memcpy(fwdata->data, &firmware[tlen], dlen);
 911
 912                         fwdata->seq_num = cpu_to_le32(fw_seqnum);
 913                         tlen += dlen;
 914                 }
 915
 916                 /* If the send/receive fails or CRC occurs then retry */
 917                 while (retries--) {
 918                         u8 *buf = (u8 *)fwdata;
 919                         u32 len = FW_DATA_XMIT_SIZE;
 920
 921                         /* send the firmware block */
 922                         ret = mwifiex_write_data_sync(adapter, buf, &len,
 923                                                 MWIFIEX_USB_EP_CMD_EVENT,
 924                                                 MWIFIEX_USB_TIMEOUT);
 925                         if (ret) {
 926                                 mwifiex_dbg(adapter, ERROR,
 927                                             "write_data_sync: failed: %d\n",
 928                                             ret);
 929                                 continue;
 930                         }
 931
 932                         buf = recv_buff;
 933                         len = FW_DNLD_RX_BUF_SIZE;
 934
 935                         /* Receive the firmware block response */
 936                         ret = mwifiex_read_data_sync(adapter, buf, &len,
 937                                                 MWIFIEX_USB_EP_CMD_EVENT,
 938                                                 MWIFIEX_USB_TIMEOUT);
 939                         if (ret) {
 940                                 mwifiex_dbg(adapter, ERROR,
 941                                             "read_data_sync: failed: %d\n",
 942                                             ret);
 943                                 continue;
 944                         }
 945
 946                         memcpy(&sync_fw, recv_buff,
 947                                sizeof(struct fw_sync_header));
 948
 949                         /* check 1st firmware block resp for highest bit set */
 950                         if (check_winner) {
 951                                 if (le32_to_cpu(sync_fw.cmd) & 0x80000000) {
 952                                         mwifiex_dbg(adapter, WARN,
 953                                                     "USB is not the winner %#x\n",
 954                                                     sync_fw.cmd);
 955
 956                                         /* returning success */
 957                                         ret = 0;
 958                                         goto cleanup;
 959                                 }
 960
 961                                 mwifiex_dbg(adapter, MSG,
 962                                             "start to download FW...\n");
 963
 964                                 check_winner = 0;
 965                                 break;
 966                         }
 967
 968                         /* check the firmware block response for CRC errors */
 969                         if (sync_fw.cmd) {
 970                                 mwifiex_dbg(adapter, ERROR,
 971                                             "FW received block with CRC %#x\n",
 972                                             sync_fw.cmd);
 973                                 ret = -1;
 974                                 continue;
 975                         }
 976
 977                         retries = USB8XXX_FW_MAX_RETRY;
 978                         break;
 979                 }
 980                 fw_seqnum++;
 981         } while ((dnld_cmd != FW_HAS_LAST_BLOCK) && retries);
 982
 983 cleanup:
 984         mwifiex_dbg(adapter, MSG,
 985                     "info: FW download over, size %d bytes\n", tlen);
 986
 987         kfree(recv_buff);
 988         kfree(fwdata);
 989
 990         if (retries)
 991                 ret = 0;
 992 fw_exit:
 993         return ret;
 994 }
 995
 996 static int mwifiex_usb_dnld_fw(struct mwifiex_adapter *adapter,
 997                         struct mwifiex_fw_image *fw)
 998 {
 999         int ret;
1000         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
1001
1002         if (card->usb_boot_state == USB8XXX_FW_DNLD) {
1003                 ret = mwifiex_prog_fw_w_helper(adapter, fw);
1004                 if (ret)
1005                         return -1;
1006
1007                 /* Boot state changes after successful firmware download */
1008                 if (card->usb_boot_state == USB8XXX_FW_DNLD)
1009                         return -1;
1010         }
1011
1012         ret = mwifiex_usb_rx_init(adapter);
1013         if (!ret)
1014                 ret = mwifiex_usb_tx_init(adapter);
1015
1016         return ret;
1017 }
1018
1019 static void mwifiex_submit_rx_urb(struct mwifiex_adapter *adapter, u8 ep)
1020 {
1021         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
1022
1023         skb_push(card->rx_cmd.skb, INTF_HEADER_LEN);
1024         if ((ep == card->rx_cmd_ep) &&
1025             (!atomic_read(&card->rx_cmd_urb_pending)))
1026                 mwifiex_usb_submit_rx_urb(&card->rx_cmd,
1027                                           MWIFIEX_RX_CMD_BUF_SIZE);
1028
1029         return;
1030 }
1031
1032 static int mwifiex_usb_cmd_event_complete(struct mwifiex_adapter *adapter,
1033                                        struct sk_buff *skb)
1034 {
1035         mwifiex_submit_rx_urb(adapter, MWIFIEX_USB_EP_CMD_EVENT);
1036
1037         return 0;
1038 }
1039
1040 /* This function wakes up the card. */
1041 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
1042 {
1043         /* Simulation of HS_AWAKE event */
1044         adapter->pm_wakeup_fw_try = false;
1045         del_timer(&adapter->wakeup_timer);
1046         adapter->pm_wakeup_card_req = false;
1047         adapter->ps_state = PS_STATE_AWAKE;
1048
1049         return 0;
1050 }
1051
1052 static void mwifiex_usb_submit_rem_rx_urbs(struct mwifiex_adapter *adapter)
1053 {
1054         struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
1055         int i;
1056         struct urb_context *ctx;
1057
1058         for (i = 0; i < MWIFIEX_RX_DATA_URB; i++) {
1059                 if (card->rx_data_list[i].skb)
1060                         continue;
1061                 ctx = &card->rx_data_list[i];
1062                 mwifiex_usb_submit_rx_urb(ctx, MWIFIEX_RX_DATA_BUF_SIZE);
1063         }
1064 }
1065
1066 /* This function is called after the card has woken up. */
1067 static inline int
1068 mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
1069 {
1070         return 0;
1071 }
1072
1073 static struct mwifiex_if_ops usb_ops = {
1074         .register_dev =         mwifiex_register_dev,
1075         .unregister_dev =       mwifiex_unregister_dev,
1076         .wakeup =               mwifiex_pm_wakeup_card,
1077         .wakeup_complete =      mwifiex_pm_wakeup_card_complete,
1078
1079         /* USB specific */
1080         .dnld_fw =              mwifiex_usb_dnld_fw,
1081         .cmdrsp_complete =      mwifiex_usb_cmd_event_complete,
1082         .event_complete =       mwifiex_usb_cmd_event_complete,
1083         .host_to_card =         mwifiex_usb_host_to_card,
1084         .submit_rem_rx_urbs =   mwifiex_usb_submit_rem_rx_urbs,
1085 };
1086
1087 /* This function initializes the USB driver module.
1088  *
1089  * This initiates the semaphore and registers the device with
1090  * USB bus.
1091  */
1092 static int mwifiex_usb_init_module(void)
1093 {
1094         int ret;
1095
1096         pr_debug("Marvell USB8797 Driver\n");
1097
1098         sema_init(&add_remove_card_sem, 1);
1099
1100         ret = usb_register(&mwifiex_usb_driver);
1101         if (ret)
1102                 pr_err("Driver register failed!\n");
1103         else
1104                 pr_debug("info: Driver registered successfully!\n");
1105
1106         return ret;
1107 }
1108
1109 /* This function cleans up the USB driver.
1110  *
1111  * The following major steps are followed in .disconnect for cleanup:
1112  *      - Resume the device if its suspended
1113  *      - Disconnect the device if connected
1114  *      - Shutdown the firmware
1115  *      - Unregister the device from USB bus.
1116  */
1117 static void mwifiex_usb_cleanup_module(void)
1118 {
1119         if (!down_interruptible(&add_remove_card_sem))
1120                 up(&add_remove_card_sem);
1121
1122         /* set the flag as user is removing this module */
1123         user_rmmod = 1;
1124
1125         usb_deregister(&mwifiex_usb_driver);
1126 }
1127
1128 module_init(mwifiex_usb_init_module);
1129 module_exit(mwifiex_usb_cleanup_module);
1130
1131 MODULE_AUTHOR("Marvell International Ltd.");
1132 MODULE_DESCRIPTION("Marvell WiFi-Ex USB Driver version" USB_VERSION);
1133 MODULE_VERSION(USB_VERSION);
1134 MODULE_LICENSE("GPL v2");
1135 MODULE_FIRMWARE(USB8766_DEFAULT_FW_NAME);
1136 MODULE_FIRMWARE(USB8797_DEFAULT_FW_NAME);
1137 MODULE_FIRMWARE(USB8801_DEFAULT_FW_NAME);
1138 MODULE_FIRMWARE(USB8897_DEFAULT_FW_NAME);
1139 MODULE_FIRMWARE(USB8997_DEFAULT_FW_NAME);