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