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