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