drivers/net/wireless/libertas/if_usb.c

   1 /**
   2   * This file contains functions used in USB interface module.
   3   */
   4 #include <linux/delay.h>
   5 #include <linux/moduleparam.h>
   6 #include <linux/firmware.h>
   7 #include <linux/netdevice.h>
   8 #include <linux/slab.h>
   9 #include <linux/usb.h>
  10
  11 #ifdef CONFIG_OLPC
  12 #include <asm/olpc.h>
  13 #endif
  14
  15 #define DRV_NAME "usb8xxx"
  16
  17 #include "host.h"
  18 #include "decl.h"
  19 #include "defs.h"
  20 #include "dev.h"
  21 #include "cmd.h"
  22 #include "if_usb.h"
  23
  24 #define INSANEDEBUG     0
  25 #define lbs_deb_usb2(...) do { if (INSANEDEBUG) lbs_deb_usbd(__VA_ARGS__); } while (0)
  26
  27 #define MESSAGE_HEADER_LEN      4
  28
  29 static char *lbs_fw_name = "usb8388.bin";
  30 module_param_named(fw_name, lbs_fw_name, charp, 0644);
  31
  32 MODULE_FIRMWARE("usb8388.bin");
  33
  34 static struct usb_device_id if_usb_table[] = {
  35         /* Enter the device signature inside */
  36         { USB_DEVICE(0x1286, 0x2001) },
  37         { USB_DEVICE(0x05a3, 0x8388) },
  38         {}      /* Terminating entry */
  39 };
  40
  41 MODULE_DEVICE_TABLE(usb, if_usb_table);
  42
  43 static void if_usb_receive(struct urb *urb);
  44 static void if_usb_receive_fwload(struct urb *urb);
  45 static int __if_usb_prog_firmware(struct if_usb_card *cardp,
  46                                         const char *fwname, int cmd);
  47 static int if_usb_prog_firmware(struct if_usb_card *cardp,
  48                                         const char *fwname, int cmd);
  49 static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
  50                                uint8_t *payload, uint16_t nb);
  51 static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload,
  52                         uint16_t nb);
  53 static void if_usb_free(struct if_usb_card *cardp);
  54 static int if_usb_submit_rx_urb(struct if_usb_card *cardp);
  55 static int if_usb_reset_device(struct if_usb_card *cardp);
  56
  57 /* sysfs hooks */
  58
  59 /**
  60  *  Set function to write firmware to device's persistent memory
  61  */
  62 static ssize_t if_usb_firmware_set(struct device *dev,
  63                 struct device_attribute *attr, const char *buf, size_t count)
  64 {
  65         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
  66         struct if_usb_card *cardp = priv->card;
  67         int ret;
  68
  69         ret = if_usb_prog_firmware(cardp, buf, BOOT_CMD_UPDATE_FW);
  70         if (ret == 0)
  71                 return count;
  72
  73         return ret;
  74 }
  75
  76 /**
  77  * lbs_flash_fw attribute to be exported per ethX interface through sysfs
  78  * (/sys/class/net/ethX/lbs_flash_fw).  Use this like so to write firmware to
  79  * the device's persistent memory:
  80  * echo usb8388-5.126.0.p5.bin > /sys/class/net/ethX/lbs_flash_fw
  81  */
  82 static DEVICE_ATTR(lbs_flash_fw, 0200, NULL, if_usb_firmware_set);
  83
  84 /**
  85  *  Set function to write firmware to device's persistent memory
  86  */
  87 static ssize_t if_usb_boot2_set(struct device *dev,
  88                 struct device_attribute *attr, const char *buf, size_t count)
  89 {
  90         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
  91         struct if_usb_card *cardp = priv->card;
  92         int ret;
  93
  94         ret = if_usb_prog_firmware(cardp, buf, BOOT_CMD_UPDATE_BOOT2);
  95         if (ret == 0)
  96                 return count;
  97
  98         return ret;
  99 }
 100
 101 /**
 102  * lbs_flash_boot2 attribute to be exported per ethX interface through sysfs
 103  * (/sys/class/net/ethX/lbs_flash_boot2).  Use this like so to write firmware
 104  * to the device's persistent memory:
 105  * echo usb8388-5.126.0.p5.bin > /sys/class/net/ethX/lbs_flash_boot2
 106  */
 107 static DEVICE_ATTR(lbs_flash_boot2, 0200, NULL, if_usb_boot2_set);
 108
 109 /**
 110  *  @brief  call back function to handle the status of the URB
 111  *  @param urb          pointer to urb structure
 112  *  @return             N/A
 113  */
 114 static void if_usb_write_bulk_callback(struct urb *urb)
 115 {
 116         struct if_usb_card *cardp = (struct if_usb_card *) urb->context;
 117
 118         /* handle the transmission complete validations */
 119
 120         if (urb->status == 0) {
 121                 struct lbs_private *priv = cardp->priv;
 122
 123                 lbs_deb_usb2(&urb->dev->dev, "URB status is successful\n");
 124                 lbs_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n",
 125                              urb->actual_length);
 126
 127                 /* Boot commands such as UPDATE_FW and UPDATE_BOOT2 are not
 128                  * passed up to the lbs level.
 129                  */
 130                 if (priv && priv->dnld_sent != DNLD_BOOTCMD_SENT)
 131                         lbs_host_to_card_done(priv);
 132         } else {
 133                 /* print the failure status number for debug */
 134                 lbs_pr_info("URB in failure status: %d\n", urb->status);
 135         }
 136
 137         return;
 138 }
 139
 140 /**
 141  *  @brief  free tx/rx urb, skb and rx buffer
 142  *  @param cardp        pointer if_usb_card
 143  *  @return             N/A
 144  */
 145 static void if_usb_free(struct if_usb_card *cardp)
 146 {
 147         lbs_deb_enter(LBS_DEB_USB);
 148
 149         /* Unlink tx & rx urb */
 150         usb_kill_urb(cardp->tx_urb);
 151         usb_kill_urb(cardp->rx_urb);
 152
 153         usb_free_urb(cardp->tx_urb);
 154         cardp->tx_urb = NULL;
 155
 156         usb_free_urb(cardp->rx_urb);
 157         cardp->rx_urb = NULL;
 158
 159         kfree(cardp->ep_out_buf);
 160         cardp->ep_out_buf = NULL;
 161
 162         lbs_deb_leave(LBS_DEB_USB);
 163 }
 164
 165 static void if_usb_setup_firmware(struct lbs_private *priv)
 166 {
 167         struct if_usb_card *cardp = priv->card;
 168         struct cmd_ds_set_boot2_ver b2_cmd;
 169         struct cmd_ds_802_11_fw_wake_method wake_method;
 170
 171         b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd));
 172         b2_cmd.action = 0;
 173         b2_cmd.version = cardp->boot2_version;
 174
 175         if (lbs_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd))
 176                 lbs_deb_usb("Setting boot2 version failed\n");
 177
 178         priv->wol_gpio = 2; /* Wake via GPIO2... */
 179         priv->wol_gap = 20; /* ... after 20ms    */
 180         lbs_host_sleep_cfg(priv, EHS_WAKE_ON_UNICAST_DATA,
 181                         (struct wol_config *) NULL);
 182
 183         wake_method.hdr.size = cpu_to_le16(sizeof(wake_method));
 184         wake_method.action = cpu_to_le16(CMD_ACT_GET);
 185         if (lbs_cmd_with_response(priv, CMD_802_11_FW_WAKE_METHOD, &wake_method)) {
 186                 lbs_pr_info("Firmware does not seem to support PS mode\n");
 187                 priv->fwcapinfo &= ~FW_CAPINFO_PS;
 188         } else {
 189                 if (le16_to_cpu(wake_method.method) == CMD_WAKE_METHOD_COMMAND_INT) {
 190                         lbs_deb_usb("Firmware seems to support PS with wake-via-command\n");
 191                 } else {
 192                         /* The versions which boot up this way don't seem to
 193                            work even if we set it to the command interrupt */
 194                         priv->fwcapinfo &= ~FW_CAPINFO_PS;
 195                         lbs_pr_info("Firmware doesn't wake via command interrupt; disabling PS mode\n");
 196                 }
 197         }
 198 }
 199
 200 static void if_usb_fw_timeo(unsigned long priv)
 201 {
 202         struct if_usb_card *cardp = (void *)priv;
 203
 204         if (cardp->fwdnldover) {
 205                 lbs_deb_usb("Download complete, no event. Assuming success\n");
 206         } else {
 207                 lbs_pr_err("Download timed out\n");
 208                 cardp->surprise_removed = 1;
 209         }
 210         wake_up(&cardp->fw_wq);
 211 }
 212
 213 #ifdef CONFIG_OLPC
 214 static void if_usb_reset_olpc_card(struct lbs_private *priv)
 215 {
 216         printk(KERN_CRIT "Resetting OLPC wireless via EC...\n");
 217         olpc_ec_cmd(0x25, NULL, 0, NULL, 0);
 218 }
 219 #endif
 220
 221 /**
 222  *  @brief sets the configuration values
 223  *  @param ifnum        interface number
 224  *  @param id           pointer to usb_device_id
 225  *  @return             0 on success, error code on failure
 226  */
 227 static int if_usb_probe(struct usb_interface *intf,
 228                         const struct usb_device_id *id)
 229 {
 230         struct usb_device *udev;
 231         struct usb_host_interface *iface_desc;
 232         struct usb_endpoint_descriptor *endpoint;
 233         struct lbs_private *priv;
 234         struct if_usb_card *cardp;
 235         int i;
 236
 237         udev = interface_to_usbdev(intf);
 238
 239         cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL);
 240         if (!cardp) {
 241                 lbs_pr_err("Out of memory allocating private data.\n");
 242                 goto error;
 243         }
 244
 245         setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp);
 246         init_waitqueue_head(&cardp->fw_wq);
 247
 248         cardp->udev = udev;
 249         iface_desc = intf->cur_altsetting;
 250
 251         lbs_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X"
 252                      " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
 253                      le16_to_cpu(udev->descriptor.bcdUSB),
 254                      udev->descriptor.bDeviceClass,
 255                      udev->descriptor.bDeviceSubClass,
 256                      udev->descriptor.bDeviceProtocol);
 257
 258         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 259                 endpoint = &iface_desc->endpoint[i].desc;
 260                 if (usb_endpoint_is_bulk_in(endpoint)) {
 261                         cardp->ep_in_size = le16_to_cpu(endpoint->wMaxPacketSize);
 262                         cardp->ep_in = usb_endpoint_num(endpoint);
 263
 264                         lbs_deb_usbd(&udev->dev, "in_endpoint = %d\n", cardp->ep_in);
 265                         lbs_deb_usbd(&udev->dev, "Bulk in size is %d\n", cardp->ep_in_size);
 266
 267                 } else if (usb_endpoint_is_bulk_out(endpoint)) {
 268                         cardp->ep_out_size = le16_to_cpu(endpoint->wMaxPacketSize);
 269                         cardp->ep_out = usb_endpoint_num(endpoint);
 270
 271                         lbs_deb_usbd(&udev->dev, "out_endpoint = %d\n", cardp->ep_out);
 272                         lbs_deb_usbd(&udev->dev, "Bulk out size is %d\n", cardp->ep_out_size);
 273                 }
 274         }
 275         if (!cardp->ep_out_size || !cardp->ep_in_size) {
 276                 lbs_deb_usbd(&udev->dev, "Endpoints not found\n");
 277                 goto dealloc;
 278         }
 279         if (!(cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
 280                 lbs_deb_usbd(&udev->dev, "Rx URB allocation failed\n");
 281                 goto dealloc;
 282         }
 283         if (!(cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
 284                 lbs_deb_usbd(&udev->dev, "Tx URB allocation failed\n");
 285                 goto dealloc;
 286         }
 287         cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, GFP_KERNEL);
 288         if (!cardp->ep_out_buf) {
 289                 lbs_deb_usbd(&udev->dev, "Could not allocate buffer\n");
 290                 goto dealloc;
 291         }
 292
 293         /* Upload firmware */
 294         if (__if_usb_prog_firmware(cardp, lbs_fw_name, BOOT_CMD_FW_BY_USB)) {
 295                 lbs_deb_usbd(&udev->dev, "FW upload failed\n");
 296                 goto err_prog_firmware;
 297         }
 298
 299         if (!(priv = lbs_add_card(cardp, &udev->dev)))
 300                 goto err_prog_firmware;
 301
 302         cardp->priv = priv;
 303         cardp->priv->fw_ready = 1;
 304
 305         priv->hw_host_to_card = if_usb_host_to_card;
 306         priv->enter_deep_sleep = NULL;
 307         priv->exit_deep_sleep = NULL;
 308         priv->reset_deep_sleep_wakeup = NULL;
 309 #ifdef CONFIG_OLPC
 310         if (machine_is_olpc())
 311                 priv->reset_card = if_usb_reset_olpc_card;
 312 #endif
 313
 314         cardp->boot2_version = udev->descriptor.bcdDevice;
 315
 316         if_usb_submit_rx_urb(cardp);
 317
 318         if (lbs_start_card(priv))
 319                 goto err_start_card;
 320
 321         if_usb_setup_firmware(priv);
 322
 323         usb_get_dev(udev);
 324         usb_set_intfdata(intf, cardp);
 325
 326         if (device_create_file(&priv->dev->dev, &dev_attr_lbs_flash_fw))
 327                 lbs_pr_err("cannot register lbs_flash_fw attribute\n");
 328
 329         if (device_create_file(&priv->dev->dev, &dev_attr_lbs_flash_boot2))
 330                 lbs_pr_err("cannot register lbs_flash_boot2 attribute\n");
 331
 332         return 0;
 333
 334 err_start_card:
 335         lbs_remove_card(priv);
 336 err_prog_firmware:
 337         if_usb_reset_device(cardp);
 338 dealloc:
 339         if_usb_free(cardp);
 340
 341 error:
 342         return -ENOMEM;
 343 }
 344
 345 /**
 346  *  @brief free resource and cleanup
 347  *  @param intf         USB interface structure
 348  *  @return             N/A
 349  */
 350 static void if_usb_disconnect(struct usb_interface *intf)
 351 {
 352         struct if_usb_card *cardp = usb_get_intfdata(intf);
 353         struct lbs_private *priv = (struct lbs_private *) cardp->priv;
 354
 355         lbs_deb_enter(LBS_DEB_MAIN);
 356
 357         device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_boot2);
 358         device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_fw);
 359
 360         cardp->surprise_removed = 1;
 361
 362         if (priv) {
 363                 priv->surpriseremoved = 1;
 364                 lbs_stop_card(priv);
 365                 lbs_remove_card(priv);
 366         }
 367
 368         /* Unlink and free urb */
 369         if_usb_free(cardp);
 370
 371         usb_set_intfdata(intf, NULL);
 372         usb_put_dev(interface_to_usbdev(intf));
 373
 374         lbs_deb_leave(LBS_DEB_MAIN);
 375 }
 376
 377 /**
 378  *  @brief  This function download FW
 379  *  @param priv         pointer to struct lbs_private
 380  *  @return             0
 381  */
 382 static int if_usb_send_fw_pkt(struct if_usb_card *cardp)
 383 {
 384         struct fwdata *fwdata = cardp->ep_out_buf;
 385         const uint8_t *firmware = cardp->fw->data;
 386
 387         /* If we got a CRC failure on the last block, back
 388            up and retry it */
 389         if (!cardp->CRC_OK) {
 390                 cardp->totalbytes = cardp->fwlastblksent;
 391                 cardp->fwseqnum--;
 392         }
 393
 394         lbs_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n",
 395                      cardp->totalbytes);
 396
 397         /* struct fwdata (which we sent to the card) has an
 398            extra __le32 field in between the header and the data,
 399            which is not in the struct fwheader in the actual
 400            firmware binary. Insert the seqnum in the middle... */
 401         memcpy(&fwdata->hdr, &firmware[cardp->totalbytes],
 402                sizeof(struct fwheader));
 403
 404         cardp->fwlastblksent = cardp->totalbytes;
 405         cardp->totalbytes += sizeof(struct fwheader);
 406
 407         memcpy(fwdata->data, &firmware[cardp->totalbytes],
 408                le32_to_cpu(fwdata->hdr.datalength));
 409
 410         lbs_deb_usb2(&cardp->udev->dev, "Data length = %d\n",
 411                      le32_to_cpu(fwdata->hdr.datalength));
 412
 413         fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum);
 414         cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength);
 415
 416         usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) +
 417                      le32_to_cpu(fwdata->hdr.datalength));
 418
 419         if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) {
 420                 lbs_deb_usb2(&cardp->udev->dev, "There are data to follow\n");
 421                 lbs_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n",
 422                              cardp->fwseqnum, cardp->totalbytes);
 423         } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) {
 424                 lbs_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n");
 425                 lbs_deb_usb2(&cardp->udev->dev, "Donwloading FW JUMP BLOCK\n");
 426
 427                 cardp->fwfinalblk = 1;
 428         }
 429
 430         lbs_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n",
 431                      cardp->totalbytes);
 432
 433         return 0;
 434 }
 435
 436 static int if_usb_reset_device(struct if_usb_card *cardp)
 437 {
 438         struct cmd_ds_command *cmd = cardp->ep_out_buf + 4;
 439         int ret;
 440
 441         lbs_deb_enter(LBS_DEB_USB);
 442
 443         *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
 444
 445         cmd->command = cpu_to_le16(CMD_802_11_RESET);
 446         cmd->size = cpu_to_le16(sizeof(struct cmd_header));
 447         cmd->result = cpu_to_le16(0);
 448         cmd->seqnum = cpu_to_le16(0x5a5a);
 449         usb_tx_block(cardp, cardp->ep_out_buf, 4 + sizeof(struct cmd_header));
 450
 451         msleep(100);
 452         ret = usb_reset_device(cardp->udev);
 453         msleep(100);
 454
 455 #ifdef CONFIG_OLPC
 456         if (ret && machine_is_olpc())
 457                 if_usb_reset_olpc_card(NULL);
 458 #endif
 459
 460         lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
 461
 462         return ret;
 463 }
 464
 465 /**
 466  *  @brief This function transfer the data to the device.
 467  *  @param priv         pointer to struct lbs_private
 468  *  @param payload      pointer to payload data
 469  *  @param nb           data length
 470  *  @return             0 or -1
 471  */
 472 static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, uint16_t nb)
 473 {
 474         int ret = -1;
 475
 476         /* check if device is removed */
 477         if (cardp->surprise_removed) {
 478                 lbs_deb_usbd(&cardp->udev->dev, "Device removed\n");
 479                 goto tx_ret;
 480         }
 481
 482         usb_fill_bulk_urb(cardp->tx_urb, cardp->udev,
 483                           usb_sndbulkpipe(cardp->udev,
 484                                           cardp->ep_out),
 485                           payload, nb, if_usb_write_bulk_callback, cardp);
 486
 487         cardp->tx_urb->transfer_flags |= URB_ZERO_PACKET;
 488
 489         if ((ret = usb_submit_urb(cardp->tx_urb, GFP_ATOMIC))) {
 490                 lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret);
 491                 ret = -1;
 492         } else {
 493                 lbs_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n");
 494                 ret = 0;
 495         }
 496
 497 tx_ret:
 498         return ret;
 499 }
 500
 501 static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
 502                                   void (*callbackfn)(struct urb *urb))
 503 {
 504         struct sk_buff *skb;
 505         int ret = -1;
 506
 507         if (!(skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE))) {
 508                 lbs_pr_err("No free skb\n");
 509                 goto rx_ret;
 510         }
 511
 512         cardp->rx_skb = skb;
 513
 514         /* Fill the receive configuration URB and initialise the Rx call back */
 515         usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
 516                           usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
 517                           skb->data + IPFIELD_ALIGN_OFFSET,
 518                           MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn,
 519                           cardp);
 520
 521         cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
 522
 523         lbs_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb);
 524         if ((ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC))) {
 525                 lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret);
 526                 kfree_skb(skb);
 527                 cardp->rx_skb = NULL;
 528                 ret = -1;
 529         } else {
 530                 lbs_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n");
 531                 ret = 0;
 532         }
 533
 534 rx_ret:
 535         return ret;
 536 }
 537
 538 static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp)
 539 {
 540         return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload);
 541 }
 542
 543 static int if_usb_submit_rx_urb(struct if_usb_card *cardp)
 544 {
 545         return __if_usb_submit_rx_urb(cardp, &if_usb_receive);
 546 }
 547
 548 static void if_usb_receive_fwload(struct urb *urb)
 549 {
 550         struct if_usb_card *cardp = urb->context;
 551         struct sk_buff *skb = cardp->rx_skb;
 552         struct fwsyncheader *syncfwheader;
 553         struct bootcmdresp bootcmdresp;
 554
 555         if (urb->status) {
 556                 lbs_deb_usbd(&cardp->udev->dev,
 557                              "URB status is failed during fw load\n");
 558                 kfree_skb(skb);
 559                 return;
 560         }
 561
 562         if (cardp->fwdnldover) {
 563                 __le32 *tmp = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
 564
 565                 if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) &&
 566                     tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) {
 567                         lbs_pr_info("Firmware ready event received\n");
 568                         wake_up(&cardp->fw_wq);
 569                 } else {
 570                         lbs_deb_usb("Waiting for confirmation; got %x %x\n",
 571                                     le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1]));
 572                         if_usb_submit_rx_urb_fwload(cardp);
 573                 }
 574                 kfree_skb(skb);
 575                 return;
 576         }
 577         if (cardp->bootcmdresp <= 0) {
 578                 memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET,
 579                         sizeof(bootcmdresp));
 580
 581                 if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) {
 582                         kfree_skb(skb);
 583                         if_usb_submit_rx_urb_fwload(cardp);
 584                         cardp->bootcmdresp = BOOT_CMD_RESP_OK;
 585                         lbs_deb_usbd(&cardp->udev->dev,
 586                                      "Received valid boot command response\n");
 587                         return;
 588                 }
 589                 if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) {
 590                         if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) ||
 591                             bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) ||
 592                             bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) {
 593                                 if (!cardp->bootcmdresp)
 594                                         lbs_pr_info("Firmware already seems alive; resetting\n");
 595                                 cardp->bootcmdresp = -1;
 596                         } else {
 597                                 lbs_pr_info("boot cmd response wrong magic number (0x%x)\n",
 598                                             le32_to_cpu(bootcmdresp.magic));
 599                         }
 600                 } else if ((bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) &&
 601                            (bootcmdresp.cmd != BOOT_CMD_UPDATE_FW) &&
 602                            (bootcmdresp.cmd != BOOT_CMD_UPDATE_BOOT2)) {
 603                         lbs_pr_info("boot cmd response cmd_tag error (%d)\n",
 604                                     bootcmdresp.cmd);
 605                 } else if (bootcmdresp.result != BOOT_CMD_RESP_OK) {
 606                         lbs_pr_info("boot cmd response result error (%d)\n",
 607                                     bootcmdresp.result);
 608                 } else {
 609                         cardp->bootcmdresp = 1;
 610                         lbs_deb_usbd(&cardp->udev->dev,
 611                                      "Received valid boot command response\n");
 612                 }
 613                 kfree_skb(skb);
 614                 if_usb_submit_rx_urb_fwload(cardp);
 615                 return;
 616         }
 617
 618         syncfwheader = kmalloc(sizeof(struct fwsyncheader), GFP_ATOMIC);
 619         if (!syncfwheader) {
 620                 lbs_deb_usbd(&cardp->udev->dev, "Failure to allocate syncfwheader\n");
 621                 kfree_skb(skb);
 622                 return;
 623         }
 624
 625         memcpy(syncfwheader, skb->data + IPFIELD_ALIGN_OFFSET,
 626                sizeof(struct fwsyncheader));
 627
 628         if (!syncfwheader->cmd) {
 629                 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n");
 630                 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n",
 631                              le32_to_cpu(syncfwheader->seqnum));
 632                 cardp->CRC_OK = 1;
 633         } else {
 634                 lbs_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n");
 635                 cardp->CRC_OK = 0;
 636         }
 637
 638         kfree_skb(skb);
 639
 640         /* Give device 5s to either write firmware to its RAM or eeprom */
 641         mod_timer(&cardp->fw_timeout, jiffies + (HZ*5));
 642
 643         if (cardp->fwfinalblk) {
 644                 cardp->fwdnldover = 1;
 645                 goto exit;
 646         }
 647
 648         if_usb_send_fw_pkt(cardp);
 649
 650  exit:
 651         if_usb_submit_rx_urb_fwload(cardp);
 652
 653         kfree(syncfwheader);
 654
 655         return;
 656 }
 657
 658 #define MRVDRV_MIN_PKT_LEN      30
 659
 660 static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb,
 661                                        struct if_usb_card *cardp,
 662                                        struct lbs_private *priv)
 663 {
 664         if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN
 665             || recvlength < MRVDRV_MIN_PKT_LEN) {
 666                 lbs_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n");
 667                 kfree_skb(skb);
 668                 return;
 669         }
 670
 671         skb_reserve(skb, IPFIELD_ALIGN_OFFSET);
 672         skb_put(skb, recvlength);
 673         skb_pull(skb, MESSAGE_HEADER_LEN);
 674
 675         lbs_process_rxed_packet(priv, skb);
 676 }
 677
 678 static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
 679                                       struct sk_buff *skb,
 680                                       struct if_usb_card *cardp,
 681                                       struct lbs_private *priv)
 682 {
 683         u8 i;
 684
 685         if (recvlength > LBS_CMD_BUFFER_SIZE) {
 686                 lbs_deb_usbd(&cardp->udev->dev,
 687                              "The receive buffer is too large\n");
 688                 kfree_skb(skb);
 689                 return;
 690         }
 691
 692         BUG_ON(!in_interrupt());
 693
 694         spin_lock(&priv->driver_lock);
 695
 696         i = (priv->resp_idx == 0) ? 1 : 0;
 697         BUG_ON(priv->resp_len[i]);
 698         priv->resp_len[i] = (recvlength - MESSAGE_HEADER_LEN);
 699         memcpy(priv->resp_buf[i], recvbuff + MESSAGE_HEADER_LEN,
 700                 priv->resp_len[i]);
 701         kfree_skb(skb);
 702         lbs_notify_command_response(priv, i);
 703
 704         spin_unlock(&priv->driver_lock);
 705
 706         lbs_deb_usbd(&cardp->udev->dev,
 707                     "Wake up main thread to handle cmd response\n");
 708 }
 709
 710 /**
 711  *  @brief This function reads of the packet into the upload buff,
 712  *  wake up the main thread and initialise the Rx callack.
 713  *
 714  *  @param urb          pointer to struct urb
 715  *  @return             N/A
 716  */
 717 static void if_usb_receive(struct urb *urb)
 718 {
 719         struct if_usb_card *cardp = urb->context;
 720         struct sk_buff *skb = cardp->rx_skb;
 721         struct lbs_private *priv = cardp->priv;
 722         int recvlength = urb->actual_length;
 723         uint8_t *recvbuff = NULL;
 724         uint32_t recvtype = 0;
 725         __le32 *pkt = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
 726         uint32_t event;
 727
 728         lbs_deb_enter(LBS_DEB_USB);
 729
 730         if (recvlength) {
 731                 if (urb->status) {
 732                         lbs_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n",
 733                                      urb->status);
 734                         kfree_skb(skb);
 735                         goto setup_for_next;
 736                 }
 737
 738                 recvbuff = skb->data + IPFIELD_ALIGN_OFFSET;
 739                 recvtype = le32_to_cpu(pkt[0]);
 740                 lbs_deb_usbd(&cardp->udev->dev,
 741                             "Recv length = 0x%x, Recv type = 0x%X\n",
 742                             recvlength, recvtype);
 743         } else if (urb->status) {
 744                 kfree_skb(skb);
 745                 goto rx_exit;
 746         }
 747
 748         switch (recvtype) {
 749         case CMD_TYPE_DATA:
 750                 process_cmdtypedata(recvlength, skb, cardp, priv);
 751                 break;
 752
 753         case CMD_TYPE_REQUEST:
 754                 process_cmdrequest(recvlength, recvbuff, skb, cardp, priv);
 755                 break;
 756
 757         case CMD_TYPE_INDICATION:
 758                 /* Event handling */
 759                 event = le32_to_cpu(pkt[1]);
 760                 lbs_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", event);
 761                 kfree_skb(skb);
 762
 763                 /* Icky undocumented magic special case */
 764                 if (event & 0xffff0000) {
 765                         u32 trycount = (event & 0xffff0000) >> 16;
 766
 767                         lbs_send_tx_feedback(priv, trycount);
 768                 } else
 769                         lbs_queue_event(priv, event & 0xFF);
 770                 break;
 771
 772         default:
 773                 lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n",
 774                              recvtype);
 775                 kfree_skb(skb);
 776                 break;
 777         }
 778
 779 setup_for_next:
 780         if_usb_submit_rx_urb(cardp);
 781 rx_exit:
 782         lbs_deb_leave(LBS_DEB_USB);
 783 }
 784
 785 /**
 786  *  @brief This function downloads data to FW
 787  *  @param priv         pointer to struct lbs_private structure
 788  *  @param type         type of data
 789  *  @param buf          pointer to data buffer
 790  *  @param len          number of bytes
 791  *  @return             0 or -1
 792  */
 793 static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
 794                                uint8_t *payload, uint16_t nb)
 795 {
 796         struct if_usb_card *cardp = priv->card;
 797
 798         lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type);
 799         lbs_deb_usbd(&cardp->udev->dev,"size after = %d\n", nb);
 800
 801         if (type == MVMS_CMD) {
 802                 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
 803                 priv->dnld_sent = DNLD_CMD_SENT;
 804         } else {
 805                 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA);
 806                 priv->dnld_sent = DNLD_DATA_SENT;
 807         }
 808
 809         memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb);
 810
 811         return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN);
 812 }
 813
 814 /**
 815  *  @brief This function issues Boot command to the Boot2 code
 816  *  @param ivalue   1:Boot from FW by USB-Download
 817  *                  2:Boot from FW in EEPROM
 818  *  @return             0
 819  */
 820 static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue)
 821 {
 822         struct bootcmd *bootcmd = cardp->ep_out_buf;
 823
 824         /* Prepare command */
 825         bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER);
 826         bootcmd->cmd = ivalue;
 827         memset(bootcmd->pad, 0, sizeof(bootcmd->pad));
 828
 829         /* Issue command */
 830         usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd));
 831
 832         return 0;
 833 }
 834
 835
 836 /**
 837  *  @brief This function checks the validity of Boot2/FW image.
 838  *
 839  *  @param data              pointer to image
 840  *         len               image length
 841  *  @return     0 or -1
 842  */
 843 static int check_fwfile_format(const uint8_t *data, uint32_t totlen)
 844 {
 845         uint32_t bincmd, exit;
 846         uint32_t blksize, offset, len;
 847         int ret;
 848
 849         ret = 1;
 850         exit = len = 0;
 851
 852         do {
 853                 struct fwheader *fwh = (void *)data;
 854
 855                 bincmd = le32_to_cpu(fwh->dnldcmd);
 856                 blksize = le32_to_cpu(fwh->datalength);
 857                 switch (bincmd) {
 858                 case FW_HAS_DATA_TO_RECV:
 859                         offset = sizeof(struct fwheader) + blksize;
 860                         data += offset;
 861                         len += offset;
 862                         if (len >= totlen)
 863                                 exit = 1;
 864                         break;
 865                 case FW_HAS_LAST_BLOCK:
 866                         exit = 1;
 867                         ret = 0;
 868                         break;
 869                 default:
 870                         exit = 1;
 871                         break;
 872                 }
 873         } while (!exit);
 874
 875         if (ret)
 876                 lbs_pr_err("firmware file format check FAIL\n");
 877         else
 878                 lbs_deb_fw("firmware file format check PASS\n");
 879
 880         return ret;
 881 }
 882
 883
 884 /**
 885 *  @brief This function programs the firmware subject to cmd
 886 *
 887 *  @param cardp             the if_usb_card descriptor
 888 *         fwname            firmware or boot2 image file name
 889 *         cmd               either BOOT_CMD_FW_BY_USB, BOOT_CMD_UPDATE_FW,
 890 *                           or BOOT_CMD_UPDATE_BOOT2.
 891 *  @return     0 or error code
 892 */
 893 static int if_usb_prog_firmware(struct if_usb_card *cardp,
 894                                 const char *fwname, int cmd)
 895 {
 896         struct lbs_private *priv = cardp->priv;
 897         unsigned long flags, caps;
 898         int ret;
 899
 900         caps = priv->fwcapinfo;
 901         if (((cmd == BOOT_CMD_UPDATE_FW) && !(caps & FW_CAPINFO_FIRMWARE_UPGRADE)) ||
 902             ((cmd == BOOT_CMD_UPDATE_BOOT2) && !(caps & FW_CAPINFO_BOOT2_UPGRADE)))
 903                 return -EOPNOTSUPP;
 904
 905         /* Ensure main thread is idle. */
 906         spin_lock_irqsave(&priv->driver_lock, flags);
 907         while (priv->cur_cmd != NULL || priv->dnld_sent != DNLD_RES_RECEIVED) {
 908                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 909                 if (wait_event_interruptible(priv->waitq,
 910                                 (priv->cur_cmd == NULL &&
 911                                 priv->dnld_sent == DNLD_RES_RECEIVED))) {
 912                         return -ERESTARTSYS;
 913                 }
 914                 spin_lock_irqsave(&priv->driver_lock, flags);
 915         }
 916         priv->dnld_sent = DNLD_BOOTCMD_SENT;
 917         spin_unlock_irqrestore(&priv->driver_lock, flags);
 918
 919         ret = __if_usb_prog_firmware(cardp, fwname, cmd);
 920
 921         spin_lock_irqsave(&priv->driver_lock, flags);
 922         priv->dnld_sent = DNLD_RES_RECEIVED;
 923         spin_unlock_irqrestore(&priv->driver_lock, flags);
 924
 925         wake_up_interruptible(&priv->waitq);
 926
 927         return ret;
 928 }
 929
 930 static int __if_usb_prog_firmware(struct if_usb_card *cardp,
 931                                         const char *fwname, int cmd)
 932 {
 933         int i = 0;
 934         static int reset_count = 10;
 935         int ret = 0;
 936
 937         lbs_deb_enter(LBS_DEB_USB);
 938
 939         ret = request_firmware(&cardp->fw, fwname, &cardp->udev->dev);
 940         if (ret < 0) {
 941                 lbs_pr_err("request_firmware() failed with %#x\n", ret);
 942                 lbs_pr_err("firmware %s not found\n", fwname);
 943                 goto done;
 944         }
 945
 946         if (check_fwfile_format(cardp->fw->data, cardp->fw->size)) {
 947                 ret = -EINVAL;
 948                 goto release_fw;
 949         }
 950
 951         /* Cancel any pending usb business */
 952         usb_kill_urb(cardp->rx_urb);
 953         usb_kill_urb(cardp->tx_urb);
 954
 955         cardp->fwlastblksent = 0;
 956         cardp->fwdnldover = 0;
 957         cardp->totalbytes = 0;
 958         cardp->fwfinalblk = 0;
 959         cardp->bootcmdresp = 0;
 960
 961 restart:
 962         if (if_usb_submit_rx_urb_fwload(cardp) < 0) {
 963                 lbs_deb_usbd(&cardp->udev->dev, "URB submission is failed\n");
 964                 ret = -EIO;
 965                 goto release_fw;
 966         }
 967
 968         cardp->bootcmdresp = 0;
 969         do {
 970                 int j = 0;
 971                 i++;
 972                 if_usb_issue_boot_command(cardp, cmd);
 973                 /* wait for command response */
 974                 do {
 975                         j++;
 976                         msleep_interruptible(100);
 977                 } while (cardp->bootcmdresp == 0 && j < 10);
 978         } while (cardp->bootcmdresp == 0 && i < 5);
 979
 980         if (cardp->bootcmdresp == BOOT_CMD_RESP_NOT_SUPPORTED) {
 981                 /* Return to normal operation */
 982                 ret = -EOPNOTSUPP;
 983                 usb_kill_urb(cardp->rx_urb);
 984                 usb_kill_urb(cardp->tx_urb);
 985                 if (if_usb_submit_rx_urb(cardp) < 0)
 986                         ret = -EIO;
 987                 goto release_fw;
 988         } else if (cardp->bootcmdresp <= 0) {
 989                 if (--reset_count >= 0) {
 990                         if_usb_reset_device(cardp);
 991                         goto restart;
 992                 }
 993                 ret = -EIO;
 994                 goto release_fw;
 995         }
 996
 997         i = 0;
 998
 999         cardp->totalbytes = 0;
1000         cardp->fwlastblksent = 0;
1001         cardp->CRC_OK = 1;
1002         cardp->fwdnldover = 0;
1003         cardp->fwseqnum = -1;
1004         cardp->totalbytes = 0;
1005         cardp->fwfinalblk = 0;
1006
1007         /* Send the first firmware packet... */
1008         if_usb_send_fw_pkt(cardp);
1009
1010         /* ... and wait for the process to complete */
1011         wait_event_interruptible(cardp->fw_wq, cardp->surprise_removed || cardp->fwdnldover);
1012
1013         del_timer_sync(&cardp->fw_timeout);
1014         usb_kill_urb(cardp->rx_urb);
1015
1016         if (!cardp->fwdnldover) {
1017                 lbs_pr_info("failed to load fw, resetting device!\n");
1018                 if (--reset_count >= 0) {
1019                         if_usb_reset_device(cardp);
1020                         goto restart;
1021                 }
1022
1023                 lbs_pr_info("FW download failure, time = %d ms\n", i * 100);
1024                 ret = -EIO;
1025                 goto release_fw;
1026         }
1027
1028  release_fw:
1029         release_firmware(cardp->fw);
1030         cardp->fw = NULL;
1031
1032  done:
1033         lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
1034         return ret;
1035 }
1036
1037
1038 #ifdef CONFIG_PM
1039 static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
1040 {
1041         struct if_usb_card *cardp = usb_get_intfdata(intf);
1042         struct lbs_private *priv = cardp->priv;
1043         int ret;
1044
1045         lbs_deb_enter(LBS_DEB_USB);
1046
1047         if (priv->psstate != PS_STATE_FULL_POWER)
1048                 return -1;
1049
1050         ret = lbs_suspend(priv);
1051         if (ret)
1052                 goto out;
1053
1054         /* Unlink tx & rx urb */
1055         usb_kill_urb(cardp->tx_urb);
1056         usb_kill_urb(cardp->rx_urb);
1057
1058  out:
1059         lbs_deb_leave(LBS_DEB_USB);
1060         return ret;
1061 }
1062
1063 static int if_usb_resume(struct usb_interface *intf)
1064 {
1065         struct if_usb_card *cardp = usb_get_intfdata(intf);
1066         struct lbs_private *priv = cardp->priv;
1067
1068         lbs_deb_enter(LBS_DEB_USB);
1069
1070         if_usb_submit_rx_urb(cardp);
1071
1072         lbs_resume(priv);
1073
1074         lbs_deb_leave(LBS_DEB_USB);
1075         return 0;
1076 }
1077 #else
1078 #define if_usb_suspend NULL
1079 #define if_usb_resume NULL
1080 #endif
1081
1082 static struct usb_driver if_usb_driver = {
1083         .name = DRV_NAME,
1084         .probe = if_usb_probe,
1085         .disconnect = if_usb_disconnect,
1086         .id_table = if_usb_table,
1087         .suspend = if_usb_suspend,
1088         .resume = if_usb_resume,
1089         .reset_resume = if_usb_resume,
1090 };
1091
1092 static int __init if_usb_init_module(void)
1093 {
1094         int ret = 0;
1095
1096         lbs_deb_enter(LBS_DEB_MAIN);
1097
1098         ret = usb_register(&if_usb_driver);
1099
1100         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1101         return ret;
1102 }
1103
1104 static void __exit if_usb_exit_module(void)
1105 {
1106         lbs_deb_enter(LBS_DEB_MAIN);
1107
1108         usb_deregister(&if_usb_driver);
1109
1110         lbs_deb_leave(LBS_DEB_MAIN);
1111 }
1112
1113 module_init(if_usb_init_module);
1114 module_exit(if_usb_exit_module);
1115
1116 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1117 MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc.");
1118 MODULE_LICENSE("GPL");