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