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 296 error: 297 return r; 298 } 299 300 /** 301 * if_usb_disconnect - free resource and cleanup 302 * @intf: USB interface structure 303 * returns: N/A 304 */ 305 static void if_usb_disconnect(struct usb_interface *intf) 306 { 307 struct if_usb_card *cardp = usb_get_intfdata(intf); 308 struct lbs_private *priv = cardp->priv; 309 310 cardp->surprise_removed = 1; 311 312 if (priv) { 313 lbs_stop_card(priv); 314 lbs_remove_card(priv); 315 } 316 317 /* Unlink and free urb */ 318 if_usb_free(cardp); 319 320 usb_set_intfdata(intf, NULL); 321 usb_put_dev(interface_to_usbdev(intf)); 322 } 323 324 /** 325 * if_usb_send_fw_pkt - download FW 326 * @cardp: pointer to &struct if_usb_card 327 * returns: 0 328 */ 329 static int if_usb_send_fw_pkt(struct if_usb_card *cardp) 330 { 331 struct fwdata *fwdata = cardp->ep_out_buf; 332 const uint8_t *firmware = cardp->fw->data; 333 334 /* If we got a CRC failure on the last block, back 335 up and retry it */ 336 if (!cardp->CRC_OK) { 337 cardp->totalbytes = cardp->fwlastblksent; 338 cardp->fwseqnum--; 339 } 340 341 lbs_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n", 342 cardp->totalbytes); 343 344 /* struct fwdata (which we sent to the card) has an 345 extra __le32 field in between the header and the data, 346 which is not in the struct fwheader in the actual 347 firmware binary. Insert the seqnum in the middle... */ 348 memcpy(&fwdata->hdr, &firmware[cardp->totalbytes], 349 sizeof(struct fwheader)); 350 351 cardp->fwlastblksent = cardp->totalbytes; 352 cardp->totalbytes += sizeof(struct fwheader); 353 354 memcpy(fwdata->data, &firmware[cardp->totalbytes], 355 le32_to_cpu(fwdata->hdr.datalength)); 356 357 lbs_deb_usb2(&cardp->udev->dev, "Data length = %d\n", 358 le32_to_cpu(fwdata->hdr.datalength)); 359 360 fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum); 361 cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength); 362 363 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) + 364 le32_to_cpu(fwdata->hdr.datalength)); 365 366 if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) { 367 lbs_deb_usb2(&cardp->udev->dev, "There are data to follow\n"); 368 lbs_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n", 369 cardp->fwseqnum, cardp->totalbytes); 370 } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) { 371 lbs_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n"); 372 lbs_deb_usb2(&cardp->udev->dev, "Downloading FW JUMP BLOCK\n"); 373 374 cardp->fwfinalblk = 1; 375 } 376 377 lbs_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n", 378 cardp->totalbytes); 379 380 return 0; 381 } 382 383 static int if_usb_reset_device(struct if_usb_card *cardp) 384 { 385 struct cmd_header *cmd = cardp->ep_out_buf + 4; 386 int ret; 387 388 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); 389 390 cmd->command = cpu_to_le16(CMD_802_11_RESET); 391 cmd->size = cpu_to_le16(sizeof(cmd)); 392 cmd->result = cpu_to_le16(0); 393 cmd->seqnum = cpu_to_le16(0x5a5a); 394 usb_tx_block(cardp, cardp->ep_out_buf, 4 + sizeof(struct cmd_header)); 395 396 msleep(100); 397 ret = usb_reset_device(cardp->udev); 398 msleep(100); 399 400 #ifdef CONFIG_OLPC 401 if (ret && machine_is_olpc()) 402 if_usb_reset_olpc_card(NULL); 403 #endif 404 405 return ret; 406 } 407 408 /** 409 * usb_tx_block - transfer the data to the device 410 * @cardp: pointer to &struct if_usb_card 411 * @payload: pointer to payload data 412 * @nb: data length 413 * returns: 0 for success or negative error code 414 */ 415 static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, uint16_t nb) 416 { 417 int ret; 418 419 /* check if device is removed */ 420 if (cardp->surprise_removed) { 421 lbs_deb_usbd(&cardp->udev->dev, "Device removed\n"); 422 ret = -ENODEV; 423 goto tx_ret; 424 } 425 426 usb_fill_bulk_urb(cardp->tx_urb, cardp->udev, 427 usb_sndbulkpipe(cardp->udev, 428 cardp->ep_out), 429 payload, nb, if_usb_write_bulk_callback, cardp); 430 431 cardp->tx_urb->transfer_flags |= URB_ZERO_PACKET; 432 433 if ((ret = usb_submit_urb(cardp->tx_urb, GFP_ATOMIC))) { 434 lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret); 435 } else { 436 lbs_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n"); 437 ret = 0; 438 } 439 440 tx_ret: 441 return ret; 442 } 443 444 static int __if_usb_submit_rx_urb(struct if_usb_card *cardp, 445 void (*callbackfn)(struct urb *urb)) 446 { 447 struct sk_buff *skb; 448 int ret = -1; 449 450 if (!(skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE))) { 451 pr_err("No free skb\n"); 452 goto rx_ret; 453 } 454 455 cardp->rx_skb = skb; 456 457 /* Fill the receive configuration URB and initialise the Rx call back */ 458 usb_fill_bulk_urb(cardp->rx_urb, cardp->udev, 459 usb_rcvbulkpipe(cardp->udev, cardp->ep_in), 460 skb->data + IPFIELD_ALIGN_OFFSET, 461 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, 462 cardp); 463 464 lbs_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); 465 if ((ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC))) { 466 lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret); 467 kfree_skb(skb); 468 cardp->rx_skb = NULL; 469 ret = -1; 470 } else { 471 lbs_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n"); 472 ret = 0; 473 } 474 475 rx_ret: 476 return ret; 477 } 478 479 static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp) 480 { 481 return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload); 482 } 483 484 static int if_usb_submit_rx_urb(struct if_usb_card *cardp) 485 { 486 return __if_usb_submit_rx_urb(cardp, &if_usb_receive); 487 } 488 489 static void if_usb_receive_fwload(struct urb *urb) 490 { 491 struct if_usb_card *cardp = urb->context; 492 struct sk_buff *skb = cardp->rx_skb; 493 struct fwsyncheader *syncfwheader; 494 struct bootcmdresp bootcmdresp; 495 496 if (urb->status) { 497 lbs_deb_usbd(&cardp->udev->dev, 498 "URB status is failed during fw load\n"); 499 kfree_skb(skb); 500 return; 501 } 502 503 if (cardp->fwdnldover) { 504 __le32 *tmp = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET); 505 506 if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) && 507 tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) { 508 pr_info("Firmware ready event received\n"); 509 wake_up(&cardp->fw_wq); 510 } else { 511 lbs_deb_usb("Waiting for confirmation; got %x %x\n", 512 le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1])); 513 if_usb_submit_rx_urb_fwload(cardp); 514 } 515 kfree_skb(skb); 516 return; 517 } 518 if (cardp->bootcmdresp <= 0) { 519 memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET, 520 sizeof(bootcmdresp)); 521 522 if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) { 523 kfree_skb(skb); 524 if_usb_submit_rx_urb_fwload(cardp); 525 cardp->bootcmdresp = BOOT_CMD_RESP_OK; 526 lbs_deb_usbd(&cardp->udev->dev, 527 "Received valid boot command response\n"); 528 return; 529 } 530 if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) { 531 if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) || 532 bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) || 533 bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) { 534 if (!cardp->bootcmdresp) 535 pr_info("Firmware already seems alive; resetting\n"); 536 cardp->bootcmdresp = -1; 537 } else { 538 pr_info("boot cmd response wrong magic number (0x%x)\n", 539 le32_to_cpu(bootcmdresp.magic)); 540 } 541 } else if ((bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) && 542 (bootcmdresp.cmd != BOOT_CMD_UPDATE_FW) && 543 (bootcmdresp.cmd != BOOT_CMD_UPDATE_BOOT2)) { 544 pr_info("boot cmd response cmd_tag error (%d)\n", 545 bootcmdresp.cmd); 546 } else if (bootcmdresp.result != BOOT_CMD_RESP_OK) { 547 pr_info("boot cmd response result error (%d)\n", 548 bootcmdresp.result); 549 } else { 550 cardp->bootcmdresp = 1; 551 lbs_deb_usbd(&cardp->udev->dev, 552 "Received valid boot command response\n"); 553 } 554 kfree_skb(skb); 555 if_usb_submit_rx_urb_fwload(cardp); 556 return; 557 } 558 559 syncfwheader = kmemdup(skb->data + IPFIELD_ALIGN_OFFSET, 560 sizeof(struct fwsyncheader), GFP_ATOMIC); 561 if (!syncfwheader) { 562 lbs_deb_usbd(&cardp->udev->dev, "Failure to allocate syncfwheader\n"); 563 kfree_skb(skb); 564 return; 565 } 566 567 if (!syncfwheader->cmd) { 568 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n"); 569 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n", 570 le32_to_cpu(syncfwheader->seqnum)); 571 cardp->CRC_OK = 1; 572 } else { 573 lbs_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n"); 574 cardp->CRC_OK = 0; 575 } 576 577 kfree_skb(skb); 578 579 /* Give device 5s to either write firmware to its RAM or eeprom */ 580 mod_timer(&cardp->fw_timeout, jiffies + (HZ*5)); 581 582 if (cardp->fwfinalblk) { 583 cardp->fwdnldover = 1; 584 goto exit; 585 } 586 587 if_usb_send_fw_pkt(cardp); 588 589 exit: 590 if_usb_submit_rx_urb_fwload(cardp); 591 592 kfree(syncfwheader); 593 } 594 595 #define MRVDRV_MIN_PKT_LEN 30 596 597 static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb, 598 struct if_usb_card *cardp, 599 struct lbs_private *priv) 600 { 601 if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN 602 || recvlength < MRVDRV_MIN_PKT_LEN) { 603 lbs_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n"); 604 kfree_skb(skb); 605 return; 606 } 607 608 skb_reserve(skb, IPFIELD_ALIGN_OFFSET); 609 skb_put(skb, recvlength); 610 skb_pull(skb, MESSAGE_HEADER_LEN); 611 612 lbs_process_rxed_packet(priv, skb); 613 } 614 615 static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff, 616 struct sk_buff *skb, 617 struct if_usb_card *cardp, 618 struct lbs_private *priv) 619 { 620 unsigned long flags; 621 u8 i; 622 623 if (recvlength > LBS_CMD_BUFFER_SIZE) { 624 lbs_deb_usbd(&cardp->udev->dev, 625 "The receive buffer is too large\n"); 626 kfree_skb(skb); 627 return; 628 } 629 630 spin_lock_irqsave(&priv->driver_lock, flags); 631 632 i = (priv->resp_idx == 0) ? 1 : 0; 633 BUG_ON(priv->resp_len[i]); 634 priv->resp_len[i] = (recvlength - MESSAGE_HEADER_LEN); 635 memcpy(priv->resp_buf[i], recvbuff + MESSAGE_HEADER_LEN, 636 priv->resp_len[i]); 637 kfree_skb(skb); 638 lbs_notify_command_response(priv, i); 639 640 spin_unlock_irqrestore(&priv->driver_lock, flags); 641 642 lbs_deb_usbd(&cardp->udev->dev, 643 "Wake up main thread to handle cmd response\n"); 644 } 645 646 /** 647 * if_usb_receive - read the packet into the upload buffer, 648 * wake up the main thread and initialise the Rx callack 649 * 650 * @urb: pointer to &struct urb 651 * returns: N/A 652 */ 653 static void if_usb_receive(struct urb *urb) 654 { 655 struct if_usb_card *cardp = urb->context; 656 struct sk_buff *skb = cardp->rx_skb; 657 struct lbs_private *priv = cardp->priv; 658 int recvlength = urb->actual_length; 659 uint8_t *recvbuff = NULL; 660 uint32_t recvtype = 0; 661 __le32 *pkt = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET); 662 uint32_t event; 663 664 if (recvlength) { 665 if (urb->status) { 666 lbs_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n", 667 urb->status); 668 kfree_skb(skb); 669 goto setup_for_next; 670 } 671 672 recvbuff = skb->data + IPFIELD_ALIGN_OFFSET; 673 recvtype = le32_to_cpu(pkt[0]); 674 lbs_deb_usbd(&cardp->udev->dev, 675 "Recv length = 0x%x, Recv type = 0x%X\n", 676 recvlength, recvtype); 677 } else if (urb->status) { 678 kfree_skb(skb); 679 return; 680 } 681 682 switch (recvtype) { 683 case CMD_TYPE_DATA: 684 process_cmdtypedata(recvlength, skb, cardp, priv); 685 break; 686 687 case CMD_TYPE_REQUEST: 688 process_cmdrequest(recvlength, recvbuff, skb, cardp, priv); 689 break; 690 691 case CMD_TYPE_INDICATION: 692 /* Event handling */ 693 event = le32_to_cpu(pkt[1]); 694 lbs_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", event); 695 kfree_skb(skb); 696 697 /* Icky undocumented magic special case */ 698 if (event & 0xffff0000) { 699 u32 trycount = (event & 0xffff0000) >> 16; 700 701 lbs_send_tx_feedback(priv, trycount); 702 } else 703 lbs_queue_event(priv, event & 0xFF); 704 break; 705 706 default: 707 lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n", 708 recvtype); 709 kfree_skb(skb); 710 break; 711 } 712 713 setup_for_next: 714 if_usb_submit_rx_urb(cardp); 715 } 716 717 /** 718 * if_usb_host_to_card - downloads data to FW 719 * @priv: pointer to &struct lbs_private structure 720 * @type: type of data 721 * @payload: pointer to data buffer 722 * @nb: number of bytes 723 * returns: 0 for success or negative error code 724 */ 725 static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type, 726 uint8_t *payload, uint16_t nb) 727 { 728 struct if_usb_card *cardp = priv->card; 729 730 lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type); 731 lbs_deb_usbd(&cardp->udev->dev,"size after = %d\n", nb); 732 733 if (type == MVMS_CMD) { 734 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); 735 priv->dnld_sent = DNLD_CMD_SENT; 736 } else { 737 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA); 738 priv->dnld_sent = DNLD_DATA_SENT; 739 } 740 741 memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb); 742 743 return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN); 744 } 745 746 /** 747 * if_usb_issue_boot_command - issues Boot command to the Boot2 code 748 * @cardp: pointer to &if_usb_card 749 * @ivalue: 1:Boot from FW by USB-Download 750 * 2:Boot from FW in EEPROM 751 * returns: 0 for success or negative error code 752 */ 753 static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue) 754 { 755 struct bootcmd *bootcmd = cardp->ep_out_buf; 756 757 /* Prepare command */ 758 bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER); 759 bootcmd->cmd = ivalue; 760 memset(bootcmd->pad, 0, sizeof(bootcmd->pad)); 761 762 /* Issue command */ 763 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd)); 764 765 return 0; 766 } 767 768 769 /** 770 * check_fwfile_format - check the validity of Boot2/FW image 771 * 772 * @data: pointer to image 773 * @totlen: image length 774 * returns: 0 (good) or 1 (failure) 775 */ 776 static int check_fwfile_format(const uint8_t *data, uint32_t totlen) 777 { 778 uint32_t bincmd, exit; 779 uint32_t blksize, offset, len; 780 int ret; 781 782 ret = 1; 783 exit = len = 0; 784 785 do { 786 struct fwheader *fwh = (void *)data; 787 788 bincmd = le32_to_cpu(fwh->dnldcmd); 789 blksize = le32_to_cpu(fwh->datalength); 790 switch (bincmd) { 791 case FW_HAS_DATA_TO_RECV: 792 offset = sizeof(struct fwheader) + blksize; 793 data += offset; 794 len += offset; 795 if (len >= totlen) 796 exit = 1; 797 break; 798 case FW_HAS_LAST_BLOCK: 799 exit = 1; 800 ret = 0; 801 break; 802 default: 803 exit = 1; 804 break; 805 } 806 } while (!exit); 807 808 if (ret) 809 pr_err("firmware file format check FAIL\n"); 810 else 811 lbs_deb_fw("firmware file format check PASS\n"); 812 813 return ret; 814 } 815 816 static void if_usb_prog_firmware(struct lbs_private *priv, int ret, 817 const struct firmware *fw, 818 const struct firmware *unused) 819 { 820 struct if_usb_card *cardp = priv->card; 821 int i = 0; 822 static int reset_count = 10; 823 824 if (ret) { 825 pr_err("failed to find firmware (%d)\n", ret); 826 goto done; 827 } 828 829 cardp->fw = fw; 830 if (check_fwfile_format(cardp->fw->data, cardp->fw->size)) { 831 ret = -EINVAL; 832 goto done; 833 } 834 835 /* Cancel any pending usb business */ 836 usb_kill_urb(cardp->rx_urb); 837 usb_kill_urb(cardp->tx_urb); 838 839 cardp->fwlastblksent = 0; 840 cardp->fwdnldover = 0; 841 cardp->totalbytes = 0; 842 cardp->fwfinalblk = 0; 843 cardp->bootcmdresp = 0; 844 845 restart: 846 if (if_usb_submit_rx_urb_fwload(cardp) < 0) { 847 lbs_deb_usbd(&cardp->udev->dev, "URB submission is failed\n"); 848 ret = -EIO; 849 goto done; 850 } 851 852 cardp->bootcmdresp = 0; 853 do { 854 int j = 0; 855 i++; 856 if_usb_issue_boot_command(cardp, BOOT_CMD_FW_BY_USB); 857 /* wait for command response */ 858 do { 859 j++; 860 msleep_interruptible(100); 861 } while (cardp->bootcmdresp == 0 && j < 10); 862 } while (cardp->bootcmdresp == 0 && i < 5); 863 864 if (cardp->bootcmdresp == BOOT_CMD_RESP_NOT_SUPPORTED) { 865 /* Return to normal operation */ 866 ret = -EOPNOTSUPP; 867 usb_kill_urb(cardp->rx_urb); 868 usb_kill_urb(cardp->tx_urb); 869 if (if_usb_submit_rx_urb(cardp) < 0) 870 ret = -EIO; 871 goto done; 872 } else if (cardp->bootcmdresp <= 0) { 873 if (--reset_count >= 0) { 874 if_usb_reset_device(cardp); 875 goto restart; 876 } 877 ret = -EIO; 878 goto done; 879 } 880 881 i = 0; 882 883 cardp->totalbytes = 0; 884 cardp->fwlastblksent = 0; 885 cardp->CRC_OK = 1; 886 cardp->fwdnldover = 0; 887 cardp->fwseqnum = -1; 888 cardp->totalbytes = 0; 889 cardp->fwfinalblk = 0; 890 891 /* Send the first firmware packet... */ 892 if_usb_send_fw_pkt(cardp); 893 894 /* ... and wait for the process to complete */ 895 wait_event_interruptible(cardp->fw_wq, cardp->surprise_removed || cardp->fwdnldover); 896 897 del_timer_sync(&cardp->fw_timeout); 898 usb_kill_urb(cardp->rx_urb); 899 900 if (!cardp->fwdnldover) { 901 pr_info("failed to load fw, resetting device!\n"); 902 if (--reset_count >= 0) { 903 if_usb_reset_device(cardp); 904 goto restart; 905 } 906 907 pr_info("FW download failure, time = %d ms\n", i * 100); 908 ret = -EIO; 909 goto done; 910 } 911 912 cardp->priv->fw_ready = 1; 913 if_usb_submit_rx_urb(cardp); 914 915 if (lbs_start_card(priv)) 916 goto done; 917 918 if_usb_setup_firmware(priv); 919 920 /* 921 * EHS_REMOVE_WAKEUP is not supported on all versions of the firmware. 922 */ 923 priv->wol_criteria = EHS_REMOVE_WAKEUP; 924 if (lbs_host_sleep_cfg(priv, priv->wol_criteria, NULL)) 925 priv->ehs_remove_supported = false; 926 927 done: 928 cardp->fw = NULL; 929 } 930 931 932 #ifdef CONFIG_PM 933 static int if_usb_suspend(struct usb_interface *intf, pm_message_t message) 934 { 935 struct if_usb_card *cardp = usb_get_intfdata(intf); 936 struct lbs_private *priv = cardp->priv; 937 int ret; 938 939 if (priv->psstate != PS_STATE_FULL_POWER) { 940 ret = -1; 941 goto out; 942 } 943 944 #ifdef CONFIG_OLPC 945 if (machine_is_olpc()) { 946 if (priv->wol_criteria == EHS_REMOVE_WAKEUP) 947 olpc_ec_wakeup_clear(EC_SCI_SRC_WLAN); 948 else 949 olpc_ec_wakeup_set(EC_SCI_SRC_WLAN); 950 } 951 #endif 952 953 ret = lbs_suspend(priv); 954 if (ret) 955 goto out; 956 957 /* Unlink tx & rx urb */ 958 usb_kill_urb(cardp->tx_urb); 959 usb_kill_urb(cardp->rx_urb); 960 961 out: 962 return ret; 963 } 964 965 static int if_usb_resume(struct usb_interface *intf) 966 { 967 struct if_usb_card *cardp = usb_get_intfdata(intf); 968 struct lbs_private *priv = cardp->priv; 969 970 if_usb_submit_rx_urb(cardp); 971 972 lbs_resume(priv); 973 974 return 0; 975 } 976 #else 977 #define if_usb_suspend NULL 978 #define if_usb_resume NULL 979 #endif 980 981 static struct usb_driver if_usb_driver = { 982 .name = DRV_NAME, 983 .probe = if_usb_probe, 984 .disconnect = if_usb_disconnect, 985 .id_table = if_usb_table, 986 .suspend = if_usb_suspend, 987 .resume = if_usb_resume, 988 .reset_resume = if_usb_resume, 989 .disable_hub_initiated_lpm = 1, 990 }; 991 992 module_usb_driver(if_usb_driver); 993 994 MODULE_DESCRIPTION("8388 USB WLAN Driver"); 995 MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc."); 996 MODULE_LICENSE("GPL"); 997