drivers/net/wireless/marvell/libertas/if_usb.c

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