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