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