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