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