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