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