1/* 2 * Copyright (C) 2008, cozybit Inc. 3 * Copyright (C) 2003-2006, Marvell International Ltd. 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or (at 8 * your option) any later version. 9 */ 10#define DRV_NAME "lbtf_usb" 11 12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14#include "libertas_tf.h" 15#include "if_usb.h" 16 17#include <linux/delay.h> 18#include <linux/module.h> 19#include <linux/firmware.h> 20#include <linux/netdevice.h> 21#include <linux/slab.h> 22#include <linux/usb.h> 23 24#define INSANEDEBUG 0 25#define lbtf_deb_usb2(...) do { if (INSANEDEBUG) lbtf_deb_usbd(__VA_ARGS__); } while (0) 26 27#define MESSAGE_HEADER_LEN 4 28 29static char *lbtf_fw_name = "lbtf_usb.bin"; 30module_param_named(fw_name, lbtf_fw_name, charp, 0644); 31 32MODULE_FIRMWARE("lbtf_usb.bin"); 33 34static struct usb_device_id if_usb_table[] = { 35 /* Enter the device signature inside */ 36 { USB_DEVICE(0x1286, 0x2001) }, 37 { USB_DEVICE(0x05a3, 0x8388) }, 38 {} /* Terminating entry */ 39}; 40 41MODULE_DEVICE_TABLE(usb, if_usb_table); 42 43static void if_usb_receive(struct urb *urb); 44static void if_usb_receive_fwload(struct urb *urb); 45static int if_usb_prog_firmware(struct if_usb_card *cardp); 46static int if_usb_host_to_card(struct lbtf_private *priv, uint8_t type, 47 uint8_t *payload, uint16_t nb); 48static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, 49 uint16_t nb, u8 data); 50static void if_usb_free(struct if_usb_card *cardp); 51static int if_usb_submit_rx_urb(struct if_usb_card *cardp); 52static int if_usb_reset_device(struct if_usb_card *cardp); 53 54/** 55 * if_usb_wrike_bulk_callback - call back to handle URB status 56 * 57 * @param urb pointer to urb structure 58 */ 59static void if_usb_write_bulk_callback(struct urb *urb) 60{ 61 if (urb->status != 0) { 62 /* print the failure status number for debug */ 63 pr_info("URB in failure status: %d\n", urb->status); 64 } else { 65 lbtf_deb_usb2(&urb->dev->dev, "URB status is successful\n"); 66 lbtf_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n", 67 urb->actual_length); 68 } 69} 70 71/** 72 * if_usb_free - free tx/rx urb, skb and rx buffer 73 * 74 * @param cardp pointer if_usb_card 75 */ 76static void if_usb_free(struct if_usb_card *cardp) 77{ 78 lbtf_deb_enter(LBTF_DEB_USB); 79 80 /* Unlink tx & rx urb */ 81 usb_kill_urb(cardp->tx_urb); 82 usb_kill_urb(cardp->rx_urb); 83 usb_kill_urb(cardp->cmd_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 usb_free_urb(cardp->cmd_urb); 92 cardp->cmd_urb = NULL; 93 94 kfree(cardp->ep_out_buf); 95 cardp->ep_out_buf = NULL; 96 97 lbtf_deb_leave(LBTF_DEB_USB); 98} 99 100static void if_usb_setup_firmware(struct lbtf_private *priv) 101{ 102 struct if_usb_card *cardp = priv->card; 103 struct cmd_ds_set_boot2_ver b2_cmd; 104 105 lbtf_deb_enter(LBTF_DEB_USB); 106 107 if_usb_submit_rx_urb(cardp); 108 b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd)); 109 b2_cmd.action = 0; 110 b2_cmd.version = cardp->boot2_version; 111 112 if (lbtf_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd)) 113 lbtf_deb_usb("Setting boot2 version failed\n"); 114 115 lbtf_deb_leave(LBTF_DEB_USB); 116} 117 118static void if_usb_fw_timeo(unsigned long priv) 119{ 120 struct if_usb_card *cardp = (void *)priv; 121 122 lbtf_deb_enter(LBTF_DEB_USB); 123 if (!cardp->fwdnldover) { 124 /* Download timed out */ 125 cardp->priv->surpriseremoved = 1; 126 pr_err("Download timed out\n"); 127 } else { 128 lbtf_deb_usb("Download complete, no event. Assuming success\n"); 129 } 130 wake_up(&cardp->fw_wq); 131 lbtf_deb_leave(LBTF_DEB_USB); 132} 133 134/** 135 * if_usb_probe - sets the configuration values 136 * 137 * @ifnum interface number 138 * @id pointer to usb_device_id 139 * 140 * Returns: 0 on success, error code on failure 141 */ 142static int if_usb_probe(struct usb_interface *intf, 143 const struct usb_device_id *id) 144{ 145 struct usb_device *udev; 146 struct usb_host_interface *iface_desc; 147 struct usb_endpoint_descriptor *endpoint; 148 struct lbtf_private *priv; 149 struct if_usb_card *cardp; 150 int i; 151 152 lbtf_deb_enter(LBTF_DEB_USB); 153 udev = interface_to_usbdev(intf); 154 155 cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL); 156 if (!cardp) 157 goto error; 158 159 setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp); 160 init_waitqueue_head(&cardp->fw_wq); 161 162 cardp->udev = udev; 163 iface_desc = intf->cur_altsetting; 164 165 lbtf_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X" 166 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n", 167 le16_to_cpu(udev->descriptor.bcdUSB), 168 udev->descriptor.bDeviceClass, 169 udev->descriptor.bDeviceSubClass, 170 udev->descriptor.bDeviceProtocol); 171 172 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 173 endpoint = &iface_desc->endpoint[i].desc; 174 if (usb_endpoint_is_bulk_in(endpoint)) { 175 cardp->ep_in_size = 176 le16_to_cpu(endpoint->wMaxPacketSize); 177 cardp->ep_in = usb_endpoint_num(endpoint); 178 179 lbtf_deb_usbd(&udev->dev, "in_endpoint = %d\n", 180 cardp->ep_in); 181 lbtf_deb_usbd(&udev->dev, "Bulk in size is %d\n", 182 cardp->ep_in_size); 183 } else if (usb_endpoint_is_bulk_out(endpoint)) { 184 cardp->ep_out_size = 185 le16_to_cpu(endpoint->wMaxPacketSize); 186 cardp->ep_out = usb_endpoint_num(endpoint); 187 188 lbtf_deb_usbd(&udev->dev, "out_endpoint = %d\n", 189 cardp->ep_out); 190 lbtf_deb_usbd(&udev->dev, "Bulk out size is %d\n", 191 cardp->ep_out_size); 192 } 193 } 194 if (!cardp->ep_out_size || !cardp->ep_in_size) { 195 lbtf_deb_usbd(&udev->dev, "Endpoints not found\n"); 196 /* Endpoints not found */ 197 goto dealloc; 198 } 199 200 cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 201 if (!cardp->rx_urb) { 202 lbtf_deb_usbd(&udev->dev, "Rx URB allocation failed\n"); 203 goto dealloc; 204 } 205 206 cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL); 207 if (!cardp->tx_urb) { 208 lbtf_deb_usbd(&udev->dev, "Tx URB allocation failed\n"); 209 goto dealloc; 210 } 211 212 cardp->cmd_urb = usb_alloc_urb(0, GFP_KERNEL); 213 if (!cardp->cmd_urb) { 214 lbtf_deb_usbd(&udev->dev, "Cmd URB allocation failed\n"); 215 goto dealloc; 216 } 217 218 cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, 219 GFP_KERNEL); 220 if (!cardp->ep_out_buf) { 221 lbtf_deb_usbd(&udev->dev, "Could not allocate buffer\n"); 222 goto dealloc; 223 } 224 225 priv = lbtf_add_card(cardp, &udev->dev); 226 if (!priv) 227 goto dealloc; 228 229 cardp->priv = priv; 230 231 priv->hw_host_to_card = if_usb_host_to_card; 232 priv->hw_prog_firmware = if_usb_prog_firmware; 233 priv->hw_reset_device = if_usb_reset_device; 234 cardp->boot2_version = udev->descriptor.bcdDevice; 235 236 usb_get_dev(udev); 237 usb_set_intfdata(intf, cardp); 238 239 return 0; 240 241dealloc: 242 if_usb_free(cardp); 243error: 244lbtf_deb_leave(LBTF_DEB_MAIN); 245 return -ENOMEM; 246} 247 248/** 249 * if_usb_disconnect - free resource and cleanup 250 * 251 * @intf USB interface structure 252 */ 253static void if_usb_disconnect(struct usb_interface *intf) 254{ 255 struct if_usb_card *cardp = usb_get_intfdata(intf); 256 struct lbtf_private *priv = cardp->priv; 257 258 lbtf_deb_enter(LBTF_DEB_MAIN); 259 260 if_usb_reset_device(cardp); 261 262 if (priv) 263 lbtf_remove_card(priv); 264 265 /* Unlink and free urb */ 266 if_usb_free(cardp); 267 268 usb_set_intfdata(intf, NULL); 269 usb_put_dev(interface_to_usbdev(intf)); 270 271 lbtf_deb_leave(LBTF_DEB_MAIN); 272} 273 274/** 275 * if_usb_send_fw_pkt - This function downloads the FW 276 * 277 * @priv pointer to struct lbtf_private 278 * 279 * Returns: 0 280 */ 281static int if_usb_send_fw_pkt(struct if_usb_card *cardp) 282{ 283 struct fwdata *fwdata = cardp->ep_out_buf; 284 u8 *firmware = (u8 *) cardp->fw->data; 285 286 lbtf_deb_enter(LBTF_DEB_FW); 287 288 /* If we got a CRC failure on the last block, back 289 up and retry it */ 290 if (!cardp->CRC_OK) { 291 cardp->totalbytes = cardp->fwlastblksent; 292 cardp->fwseqnum--; 293 } 294 295 lbtf_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n", 296 cardp->totalbytes); 297 298 /* struct fwdata (which we sent to the card) has an 299 extra __le32 field in between the header and the data, 300 which is not in the struct fwheader in the actual 301 firmware binary. Insert the seqnum in the middle... */ 302 memcpy(&fwdata->hdr, &firmware[cardp->totalbytes], 303 sizeof(struct fwheader)); 304 305 cardp->fwlastblksent = cardp->totalbytes; 306 cardp->totalbytes += sizeof(struct fwheader); 307 308 memcpy(fwdata->data, &firmware[cardp->totalbytes], 309 le32_to_cpu(fwdata->hdr.datalength)); 310 311 lbtf_deb_usb2(&cardp->udev->dev, "Data length = %d\n", 312 le32_to_cpu(fwdata->hdr.datalength)); 313 314 fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum); 315 cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength); 316 317 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) + 318 le32_to_cpu(fwdata->hdr.datalength), 0); 319 320 if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) { 321 lbtf_deb_usb2(&cardp->udev->dev, "There are data to follow\n"); 322 lbtf_deb_usb2(&cardp->udev->dev, 323 "seqnum = %d totalbytes = %d\n", 324 cardp->fwseqnum, cardp->totalbytes); 325 } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) { 326 lbtf_deb_usb2(&cardp->udev->dev, 327 "Host has finished FW downloading\n"); 328 lbtf_deb_usb2(&cardp->udev->dev, "Donwloading FW JUMP BLOCK\n"); 329 330 /* Host has finished FW downloading 331 * Donwloading FW JUMP BLOCK 332 */ 333 cardp->fwfinalblk = 1; 334 } 335 336 lbtf_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n", 337 cardp->totalbytes); 338 339 lbtf_deb_leave(LBTF_DEB_FW); 340 return 0; 341} 342 343static int if_usb_reset_device(struct if_usb_card *cardp) 344{ 345 struct cmd_ds_802_11_reset *cmd = cardp->ep_out_buf + 4; 346 int ret; 347 348 lbtf_deb_enter(LBTF_DEB_USB); 349 350 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); 351 352 cmd->hdr.command = cpu_to_le16(CMD_802_11_RESET); 353 cmd->hdr.size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset)); 354 cmd->hdr.result = cpu_to_le16(0); 355 cmd->hdr.seqnum = cpu_to_le16(0x5a5a); 356 cmd->action = cpu_to_le16(CMD_ACT_HALT); 357 usb_tx_block(cardp, cardp->ep_out_buf, 358 4 + sizeof(struct cmd_ds_802_11_reset), 0); 359 360 msleep(100); 361 ret = usb_reset_device(cardp->udev); 362 msleep(100); 363 364 lbtf_deb_leave_args(LBTF_DEB_USB, "ret %d", ret); 365 366 return ret; 367} 368EXPORT_SYMBOL_GPL(if_usb_reset_device); 369 370/** 371 * usb_tx_block - transfer data to the device 372 * 373 * @priv pointer to struct lbtf_private 374 * @payload pointer to payload data 375 * @nb data length 376 * @data non-zero for data, zero for commands 377 * 378 * Returns: 0 on success, nonzero otherwise. 379 */ 380static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, 381 uint16_t nb, u8 data) 382{ 383 int ret = -1; 384 struct urb *urb; 385 386 lbtf_deb_enter(LBTF_DEB_USB); 387 /* check if device is removed */ 388 if (cardp->priv->surpriseremoved) { 389 lbtf_deb_usbd(&cardp->udev->dev, "Device removed\n"); 390 goto tx_ret; 391 } 392 393 if (data) 394 urb = cardp->tx_urb; 395 else 396 urb = cardp->cmd_urb; 397 398 usb_fill_bulk_urb(urb, cardp->udev, 399 usb_sndbulkpipe(cardp->udev, 400 cardp->ep_out), 401 payload, nb, if_usb_write_bulk_callback, cardp); 402 403 urb->transfer_flags |= URB_ZERO_PACKET; 404 405 if (usb_submit_urb(urb, GFP_ATOMIC)) { 406 lbtf_deb_usbd(&cardp->udev->dev, 407 "usb_submit_urb failed: %d\n", ret); 408 goto tx_ret; 409 } 410 411 lbtf_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n"); 412 413 ret = 0; 414 415tx_ret: 416 lbtf_deb_leave(LBTF_DEB_USB); 417 return ret; 418} 419 420static int __if_usb_submit_rx_urb(struct if_usb_card *cardp, 421 void (*callbackfn)(struct urb *urb)) 422{ 423 struct sk_buff *skb; 424 int ret = -1; 425 426 lbtf_deb_enter(LBTF_DEB_USB); 427 428 skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE); 429 if (!skb) { 430 pr_err("No free skb\n"); 431 lbtf_deb_leave(LBTF_DEB_USB); 432 return -1; 433 } 434 435 cardp->rx_skb = skb; 436 437 /* Fill the receive configuration URB and initialise the Rx call back */ 438 usb_fill_bulk_urb(cardp->rx_urb, cardp->udev, 439 usb_rcvbulkpipe(cardp->udev, cardp->ep_in), 440 skb_tail_pointer(skb), 441 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, cardp); 442 443 cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET; 444 445 lbtf_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", 446 cardp->rx_urb); 447 ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC); 448 if (ret) { 449 lbtf_deb_usbd(&cardp->udev->dev, 450 "Submit Rx URB failed: %d\n", ret); 451 kfree_skb(skb); 452 cardp->rx_skb = NULL; 453 lbtf_deb_leave(LBTF_DEB_USB); 454 return -1; 455 } else { 456 lbtf_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n"); 457 lbtf_deb_leave(LBTF_DEB_USB); 458 return 0; 459 } 460} 461 462static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp) 463{ 464 return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload); 465} 466 467static int if_usb_submit_rx_urb(struct if_usb_card *cardp) 468{ 469 return __if_usb_submit_rx_urb(cardp, &if_usb_receive); 470} 471 472static void if_usb_receive_fwload(struct urb *urb) 473{ 474 struct if_usb_card *cardp = urb->context; 475 struct sk_buff *skb = cardp->rx_skb; 476 struct fwsyncheader *syncfwheader; 477 struct bootcmdresp bcmdresp; 478 479 lbtf_deb_enter(LBTF_DEB_USB); 480 if (urb->status) { 481 lbtf_deb_usbd(&cardp->udev->dev, 482 "URB status is failed during fw load\n"); 483 kfree_skb(skb); 484 lbtf_deb_leave(LBTF_DEB_USB); 485 return; 486 } 487 488 if (cardp->fwdnldover) { 489 __le32 *tmp = (__le32 *)(skb->data); 490 491 if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) && 492 tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) { 493 /* Firmware ready event received */ 494 pr_info("Firmware ready event received\n"); 495 wake_up(&cardp->fw_wq); 496 } else { 497 lbtf_deb_usb("Waiting for confirmation; got %x %x\n", 498 le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1])); 499 if_usb_submit_rx_urb_fwload(cardp); 500 } 501 kfree_skb(skb); 502 lbtf_deb_leave(LBTF_DEB_USB); 503 return; 504 } 505 if (cardp->bootcmdresp <= 0) { 506 memcpy(&bcmdresp, skb->data, sizeof(bcmdresp)); 507 508 if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) { 509 kfree_skb(skb); 510 if_usb_submit_rx_urb_fwload(cardp); 511 cardp->bootcmdresp = 1; 512 /* Received valid boot command response */ 513 lbtf_deb_usbd(&cardp->udev->dev, 514 "Received valid boot command response\n"); 515 lbtf_deb_leave(LBTF_DEB_USB); 516 return; 517 } 518 if (bcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) { 519 if (bcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) || 520 bcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) || 521 bcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) { 522 if (!cardp->bootcmdresp) 523 pr_info("Firmware already seems alive; resetting\n"); 524 cardp->bootcmdresp = -1; 525 } else { 526 pr_info("boot cmd response wrong magic number (0x%x)\n", 527 le32_to_cpu(bcmdresp.magic)); 528 } 529 } else if (bcmdresp.cmd != BOOT_CMD_FW_BY_USB) { 530 pr_info("boot cmd response cmd_tag error (%d)\n", 531 bcmdresp.cmd); 532 } else if (bcmdresp.result != BOOT_CMD_RESP_OK) { 533 pr_info("boot cmd response result error (%d)\n", 534 bcmdresp.result); 535 } else { 536 cardp->bootcmdresp = 1; 537 lbtf_deb_usbd(&cardp->udev->dev, 538 "Received valid boot command response\n"); 539 } 540 541 kfree_skb(skb); 542 if_usb_submit_rx_urb_fwload(cardp); 543 lbtf_deb_leave(LBTF_DEB_USB); 544 return; 545 } 546 547 syncfwheader = kmemdup(skb->data, sizeof(struct fwsyncheader), 548 GFP_ATOMIC); 549 if (!syncfwheader) { 550 lbtf_deb_usbd(&cardp->udev->dev, 551 "Failure to allocate syncfwheader\n"); 552 kfree_skb(skb); 553 lbtf_deb_leave(LBTF_DEB_USB); 554 return; 555 } 556 557 if (!syncfwheader->cmd) { 558 lbtf_deb_usb2(&cardp->udev->dev, 559 "FW received Blk with correct CRC\n"); 560 lbtf_deb_usb2(&cardp->udev->dev, 561 "FW received Blk seqnum = %d\n", 562 le32_to_cpu(syncfwheader->seqnum)); 563 cardp->CRC_OK = 1; 564 } else { 565 lbtf_deb_usbd(&cardp->udev->dev, 566 "FW received Blk with CRC error\n"); 567 cardp->CRC_OK = 0; 568 } 569 570 kfree_skb(skb); 571 572 /* reschedule timer for 200ms hence */ 573 mod_timer(&cardp->fw_timeout, jiffies + (HZ/5)); 574 575 if (cardp->fwfinalblk) { 576 cardp->fwdnldover = 1; 577 goto exit; 578 } 579 580 if_usb_send_fw_pkt(cardp); 581 582 exit: 583 if_usb_submit_rx_urb_fwload(cardp); 584 585 kfree(syncfwheader); 586 587 lbtf_deb_leave(LBTF_DEB_USB); 588} 589 590#define MRVDRV_MIN_PKT_LEN 30 591 592static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb, 593 struct if_usb_card *cardp, 594 struct lbtf_private *priv) 595{ 596 if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN 597 || recvlength < MRVDRV_MIN_PKT_LEN) { 598 lbtf_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n"); 599 kfree_skb(skb); 600 return; 601 } 602 603 skb_put(skb, recvlength); 604 skb_pull(skb, MESSAGE_HEADER_LEN); 605 lbtf_rx(priv, skb); 606} 607 608static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff, 609 struct sk_buff *skb, 610 struct if_usb_card *cardp, 611 struct lbtf_private *priv) 612{ 613 if (recvlength > LBS_CMD_BUFFER_SIZE) { 614 lbtf_deb_usbd(&cardp->udev->dev, 615 "The receive buffer is too large\n"); 616 kfree_skb(skb); 617 return; 618 } 619 620 BUG_ON(!in_interrupt()); 621 622 spin_lock(&priv->driver_lock); 623 memcpy(priv->cmd_resp_buff, recvbuff + MESSAGE_HEADER_LEN, 624 recvlength - MESSAGE_HEADER_LEN); 625 kfree_skb(skb); 626 lbtf_cmd_response_rx(priv); 627 spin_unlock(&priv->driver_lock); 628} 629 630/** 631 * if_usb_receive - read data received from the device. 632 * 633 * @urb pointer to struct urb 634 */ 635static void if_usb_receive(struct urb *urb) 636{ 637 struct if_usb_card *cardp = urb->context; 638 struct sk_buff *skb = cardp->rx_skb; 639 struct lbtf_private *priv = cardp->priv; 640 int recvlength = urb->actual_length; 641 uint8_t *recvbuff = NULL; 642 uint32_t recvtype = 0; 643 __le32 *pkt = (__le32 *) skb->data; 644 645 lbtf_deb_enter(LBTF_DEB_USB); 646 647 if (recvlength) { 648 if (urb->status) { 649 lbtf_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n", 650 urb->status); 651 kfree_skb(skb); 652 goto setup_for_next; 653 } 654 655 recvbuff = skb->data; 656 recvtype = le32_to_cpu(pkt[0]); 657 lbtf_deb_usbd(&cardp->udev->dev, 658 "Recv length = 0x%x, Recv type = 0x%X\n", 659 recvlength, recvtype); 660 } else if (urb->status) { 661 kfree_skb(skb); 662 lbtf_deb_leave(LBTF_DEB_USB); 663 return; 664 } 665 666 switch (recvtype) { 667 case CMD_TYPE_DATA: 668 process_cmdtypedata(recvlength, skb, cardp, priv); 669 break; 670 671 case CMD_TYPE_REQUEST: 672 process_cmdrequest(recvlength, recvbuff, skb, cardp, priv); 673 break; 674 675 case CMD_TYPE_INDICATION: 676 { 677 /* Event cause handling */ 678 u32 event_cause = le32_to_cpu(pkt[1]); 679 lbtf_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", 680 event_cause); 681 682 /* Icky undocumented magic special case */ 683 if (event_cause & 0xffff0000) { 684 u16 tmp; 685 u8 retrycnt; 686 u8 failure; 687 688 tmp = event_cause >> 16; 689 retrycnt = tmp & 0x00ff; 690 failure = (tmp & 0xff00) >> 8; 691 lbtf_send_tx_feedback(priv, retrycnt, failure); 692 } else if (event_cause == LBTF_EVENT_BCN_SENT) 693 lbtf_bcn_sent(priv); 694 else 695 lbtf_deb_usbd(&cardp->udev->dev, 696 "Unsupported notification %d received\n", 697 event_cause); 698 kfree_skb(skb); 699 break; 700 } 701 default: 702 lbtf_deb_usbd(&cardp->udev->dev, 703 "libertastf: unknown command type 0x%X\n", recvtype); 704 kfree_skb(skb); 705 break; 706 } 707 708setup_for_next: 709 if_usb_submit_rx_urb(cardp); 710 lbtf_deb_leave(LBTF_DEB_USB); 711} 712 713/** 714 * if_usb_host_to_card - Download data to the device 715 * 716 * @priv pointer to struct lbtf_private structure 717 * @type type of data 718 * @buf pointer to data buffer 719 * @len number of bytes 720 * 721 * Returns: 0 on success, nonzero otherwise 722 */ 723static int if_usb_host_to_card(struct lbtf_private *priv, uint8_t type, 724 uint8_t *payload, uint16_t nb) 725{ 726 struct if_usb_card *cardp = priv->card; 727 u8 data = 0; 728 729 lbtf_deb_usbd(&cardp->udev->dev, "*** type = %u\n", type); 730 lbtf_deb_usbd(&cardp->udev->dev, "size after = %d\n", nb); 731 732 if (type == MVMS_CMD) { 733 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); 734 } else { 735 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA); 736 data = 1; 737 } 738 739 memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb); 740 741 return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN, 742 data); 743} 744 745/** 746 * if_usb_issue_boot_command - Issue boot command to Boot2. 747 * 748 * @ivalue 1 boots from FW by USB-Download, 2 boots from FW in EEPROM. 749 * 750 * Returns: 0 751 */ 752static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue) 753{ 754 struct bootcmd *bootcmd = cardp->ep_out_buf; 755 756 /* Prepare command */ 757 bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER); 758 bootcmd->cmd = ivalue; 759 memset(bootcmd->pad, 0, sizeof(bootcmd->pad)); 760 761 /* Issue command */ 762 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd), 0); 763 764 return 0; 765} 766 767 768/** 769 * check_fwfile_format - Check the validity of Boot2/FW image. 770 * 771 * @data pointer to image 772 * @totlen image length 773 * 774 * Returns: 0 if the image is valid, nonzero otherwise. 775 */ 776static int check_fwfile_format(const u8 *data, u32 totlen) 777{ 778 u32 bincmd, exit; 779 u32 blksize, offset, len; 780 int ret; 781 782 ret = 1; 783 exit = len = 0; 784 785 do { 786 struct fwheader *fwh = (void *) data; 787 788 bincmd = le32_to_cpu(fwh->dnldcmd); 789 blksize = le32_to_cpu(fwh->datalength); 790 switch (bincmd) { 791 case FW_HAS_DATA_TO_RECV: 792 offset = sizeof(struct fwheader) + blksize; 793 data += offset; 794 len += offset; 795 if (len >= totlen) 796 exit = 1; 797 break; 798 case FW_HAS_LAST_BLOCK: 799 exit = 1; 800 ret = 0; 801 break; 802 default: 803 exit = 1; 804 break; 805 } 806 } while (!exit); 807 808 if (ret) 809 pr_err("firmware file format check FAIL\n"); 810 else 811 lbtf_deb_fw("firmware file format check PASS\n"); 812 813 return ret; 814} 815 816 817static int if_usb_prog_firmware(struct if_usb_card *cardp) 818{ 819 int i = 0; 820 static int reset_count = 10; 821 int ret = 0; 822 823 lbtf_deb_enter(LBTF_DEB_USB); 824 825 kparam_block_sysfs_write(fw_name); 826 ret = request_firmware(&cardp->fw, lbtf_fw_name, &cardp->udev->dev); 827 if (ret < 0) { 828 pr_err("request_firmware() failed with %#x\n", ret); 829 pr_err("firmware %s not found\n", lbtf_fw_name); 830 kparam_unblock_sysfs_write(fw_name); 831 goto done; 832 } 833 kparam_unblock_sysfs_write(fw_name); 834 835 if (check_fwfile_format(cardp->fw->data, cardp->fw->size)) 836 goto release_fw; 837 838restart: 839 if (if_usb_submit_rx_urb_fwload(cardp) < 0) { 840 lbtf_deb_usbd(&cardp->udev->dev, "URB submission is failed\n"); 841 ret = -1; 842 goto release_fw; 843 } 844 845 cardp->bootcmdresp = 0; 846 do { 847 int j = 0; 848 i++; 849 /* Issue Boot command = 1, Boot from Download-FW */ 850 if_usb_issue_boot_command(cardp, BOOT_CMD_FW_BY_USB); 851 /* wait for command response */ 852 do { 853 j++; 854 msleep_interruptible(100); 855 } while (cardp->bootcmdresp == 0 && j < 10); 856 } while (cardp->bootcmdresp == 0 && i < 5); 857 858 if (cardp->bootcmdresp <= 0) { 859 if (--reset_count >= 0) { 860 if_usb_reset_device(cardp); 861 goto restart; 862 } 863 return -1; 864 } 865 866 i = 0; 867 868 cardp->totalbytes = 0; 869 cardp->fwlastblksent = 0; 870 cardp->CRC_OK = 1; 871 cardp->fwdnldover = 0; 872 cardp->fwseqnum = -1; 873 cardp->totalbytes = 0; 874 cardp->fwfinalblk = 0; 875 876 /* Send the first firmware packet... */ 877 if_usb_send_fw_pkt(cardp); 878 879 /* ... and wait for the process to complete */ 880 wait_event_interruptible(cardp->fw_wq, cardp->priv->surpriseremoved || 881 cardp->fwdnldover); 882 883 del_timer_sync(&cardp->fw_timeout); 884 usb_kill_urb(cardp->rx_urb); 885 886 if (!cardp->fwdnldover) { 887 pr_info("failed to load fw, resetting device!\n"); 888 if (--reset_count >= 0) { 889 if_usb_reset_device(cardp); 890 goto restart; 891 } 892 893 pr_info("FW download failure, time = %d ms\n", i * 100); 894 ret = -1; 895 goto release_fw; 896 } 897 898 cardp->priv->fw_ready = 1; 899 900 release_fw: 901 release_firmware(cardp->fw); 902 cardp->fw = NULL; 903 904 if_usb_setup_firmware(cardp->priv); 905 906 done: 907 lbtf_deb_leave_args(LBTF_DEB_USB, "ret %d", ret); 908 return ret; 909} 910EXPORT_SYMBOL_GPL(if_usb_prog_firmware); 911 912 913#define if_usb_suspend NULL 914#define if_usb_resume NULL 915 916static struct usb_driver if_usb_driver = { 917 .name = DRV_NAME, 918 .probe = if_usb_probe, 919 .disconnect = if_usb_disconnect, 920 .id_table = if_usb_table, 921 .suspend = if_usb_suspend, 922 .resume = if_usb_resume, 923 .disable_hub_initiated_lpm = 1, 924}; 925 926module_usb_driver(if_usb_driver); 927 928MODULE_DESCRIPTION("8388 USB WLAN Thinfirm Driver"); 929MODULE_AUTHOR("Cozybit Inc."); 930MODULE_LICENSE("GPL"); 931