2 * Copyright (C) 2008, cozybit Inc.
3 * Copyright (C) 2003-2006, Marvell International Ltd.
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.
10 #define DRV_NAME "lbtf_usb"
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include "libertas_tf.h"
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>
25 #define lbtf_deb_usb2(...) do { if (INSANEDEBUG) lbtf_deb_usbd(__VA_ARGS__); } while (0)
27 #define MESSAGE_HEADER_LEN 4
29 static char *lbtf_fw_name
= "lbtf_usb.bin";
30 module_param_named(fw_name
, lbtf_fw_name
, charp
, 0644);
32 MODULE_FIRMWARE("lbtf_usb.bin");
34 static 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 */
41 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
43 static void if_usb_receive(struct urb
*urb
);
44 static void if_usb_receive_fwload(struct urb
*urb
);
45 static int if_usb_prog_firmware(struct if_usb_card
*cardp
);
46 static int if_usb_host_to_card(struct lbtf_private
*priv
, uint8_t type
,
47 uint8_t *payload
, uint16_t nb
);
48 static int usb_tx_block(struct if_usb_card
*cardp
, uint8_t *payload
,
49 uint16_t nb
, u8 data
);
50 static void if_usb_free(struct if_usb_card
*cardp
);
51 static int if_usb_submit_rx_urb(struct if_usb_card
*cardp
);
52 static int if_usb_reset_device(struct if_usb_card
*cardp
);
55 * if_usb_wrike_bulk_callback - call back to handle URB status
57 * @param urb pointer to urb structure
59 static void if_usb_write_bulk_callback(struct urb
*urb
)
61 if (urb
->status
!= 0) {
62 /* print the failure status number for debug */
63 pr_info("URB in failure status: %d\n", urb
->status
);
65 lbtf_deb_usb2(&urb
->dev
->dev
, "URB status is successful\n");
66 lbtf_deb_usb2(&urb
->dev
->dev
, "Actual length transmitted %d\n",
72 * if_usb_free - free tx/rx urb, skb and rx buffer
74 * @param cardp pointer if_usb_card
76 static void if_usb_free(struct if_usb_card
*cardp
)
78 lbtf_deb_enter(LBTF_DEB_USB
);
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
);
85 usb_free_urb(cardp
->tx_urb
);
88 usb_free_urb(cardp
->rx_urb
);
91 usb_free_urb(cardp
->cmd_urb
);
92 cardp
->cmd_urb
= NULL
;
94 kfree(cardp
->ep_out_buf
);
95 cardp
->ep_out_buf
= NULL
;
97 lbtf_deb_leave(LBTF_DEB_USB
);
100 static void if_usb_setup_firmware(struct lbtf_private
*priv
)
102 struct if_usb_card
*cardp
= priv
->card
;
103 struct cmd_ds_set_boot2_ver b2_cmd
;
105 lbtf_deb_enter(LBTF_DEB_USB
);
107 if_usb_submit_rx_urb(cardp
);
108 b2_cmd
.hdr
.size
= cpu_to_le16(sizeof(b2_cmd
));
110 b2_cmd
.version
= cardp
->boot2_version
;
112 if (lbtf_cmd_with_response(priv
, CMD_SET_BOOT2_VER
, &b2_cmd
))
113 lbtf_deb_usb("Setting boot2 version failed\n");
115 lbtf_deb_leave(LBTF_DEB_USB
);
118 static void if_usb_fw_timeo(unsigned long priv
)
120 struct if_usb_card
*cardp
= (void *)priv
;
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");
128 lbtf_deb_usb("Download complete, no event. Assuming success\n");
130 wake_up(&cardp
->fw_wq
);
131 lbtf_deb_leave(LBTF_DEB_USB
);
135 * if_usb_probe - sets the configuration values
137 * @ifnum interface number
138 * @id pointer to usb_device_id
140 * Returns: 0 on success, error code on failure
142 static int if_usb_probe(struct usb_interface
*intf
,
143 const struct usb_device_id
*id
)
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
;
152 lbtf_deb_enter(LBTF_DEB_USB
);
153 udev
= interface_to_usbdev(intf
);
155 cardp
= kzalloc(sizeof(struct if_usb_card
), GFP_KERNEL
);
157 pr_err("Out of memory allocating private data.\n");
161 setup_timer(&cardp
->fw_timeout
, if_usb_fw_timeo
, (unsigned long)cardp
);
162 init_waitqueue_head(&cardp
->fw_wq
);
165 iface_desc
= intf
->cur_altsetting
;
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
);
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
)) {
178 le16_to_cpu(endpoint
->wMaxPacketSize
);
179 cardp
->ep_in
= usb_endpoint_num(endpoint
);
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
)) {
185 le16_to_cpu(endpoint
->wMaxPacketSize
);
186 cardp
->ep_out
= usb_endpoint_num(endpoint
);
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",
193 if (!cardp
->ep_out_size
|| !cardp
->ep_in_size
) {
194 lbtf_deb_usbd(&udev
->dev
, "Endpoints not found\n");
195 /* Endpoints not found */
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");
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");
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");
217 cardp
->ep_out_buf
= kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
219 if (!cardp
->ep_out_buf
) {
220 lbtf_deb_usbd(&udev
->dev
, "Could not allocate buffer\n");
224 priv
= lbtf_add_card(cardp
, &udev
->dev
);
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
;
236 usb_set_intfdata(intf
, cardp
);
243 lbtf_deb_leave(LBTF_DEB_MAIN
);
248 * if_usb_disconnect - free resource and cleanup
250 * @intf USB interface structure
252 static void if_usb_disconnect(struct usb_interface
*intf
)
254 struct if_usb_card
*cardp
= usb_get_intfdata(intf
);
255 struct lbtf_private
*priv
= (struct lbtf_private
*) cardp
->priv
;
257 lbtf_deb_enter(LBTF_DEB_MAIN
);
259 if_usb_reset_device(cardp
);
262 lbtf_remove_card(priv
);
264 /* Unlink and free urb */
267 usb_set_intfdata(intf
, NULL
);
268 usb_put_dev(interface_to_usbdev(intf
));
270 lbtf_deb_leave(LBTF_DEB_MAIN
);
274 * if_usb_send_fw_pkt - This function downloads the FW
276 * @priv pointer to struct lbtf_private
280 static int if_usb_send_fw_pkt(struct if_usb_card
*cardp
)
282 struct fwdata
*fwdata
= cardp
->ep_out_buf
;
283 u8
*firmware
= (u8
*) cardp
->fw
->data
;
285 lbtf_deb_enter(LBTF_DEB_FW
);
287 /* If we got a CRC failure on the last block, back
289 if (!cardp
->CRC_OK
) {
290 cardp
->totalbytes
= cardp
->fwlastblksent
;
294 lbtf_deb_usb2(&cardp
->udev
->dev
, "totalbytes = %d\n",
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
));
304 cardp
->fwlastblksent
= cardp
->totalbytes
;
305 cardp
->totalbytes
+= sizeof(struct fwheader
);
307 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
308 le32_to_cpu(fwdata
->hdr
.datalength
));
310 lbtf_deb_usb2(&cardp
->udev
->dev
, "Data length = %d\n",
311 le32_to_cpu(fwdata
->hdr
.datalength
));
313 fwdata
->seqnum
= cpu_to_le32(++cardp
->fwseqnum
);
314 cardp
->totalbytes
+= le32_to_cpu(fwdata
->hdr
.datalength
);
316 usb_tx_block(cardp
, cardp
->ep_out_buf
, sizeof(struct fwdata
) +
317 le32_to_cpu(fwdata
->hdr
.datalength
), 0);
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");
327 /* Host has finished FW downloading
328 * Donwloading FW JUMP BLOCK
330 cardp
->fwfinalblk
= 1;
333 lbtf_deb_usb2(&cardp
->udev
->dev
, "Firmware download done; size %d\n",
336 lbtf_deb_leave(LBTF_DEB_FW
);
340 static int if_usb_reset_device(struct if_usb_card
*cardp
)
342 struct cmd_ds_802_11_reset
*cmd
= cardp
->ep_out_buf
+ 4;
345 lbtf_deb_enter(LBTF_DEB_USB
);
347 *(__le32
*)cardp
->ep_out_buf
= cpu_to_le32(CMD_TYPE_REQUEST
);
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);
358 ret
= usb_reset_device(cardp
->udev
);
361 lbtf_deb_leave_args(LBTF_DEB_USB
, "ret %d", ret
);
365 EXPORT_SYMBOL_GPL(if_usb_reset_device
);
368 * usb_tx_block - transfer data to the device
370 * @priv pointer to struct lbtf_private
371 * @payload pointer to payload data
373 * @data non-zero for data, zero for commands
375 * Returns: 0 on success, nonzero otherwise.
377 static int usb_tx_block(struct if_usb_card
*cardp
, uint8_t *payload
,
378 uint16_t nb
, u8 data
)
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");
393 urb
= cardp
->cmd_urb
;
395 usb_fill_bulk_urb(urb
, cardp
->udev
,
396 usb_sndbulkpipe(cardp
->udev
,
398 payload
, nb
, if_usb_write_bulk_callback
, cardp
);
400 urb
->transfer_flags
|= URB_ZERO_PACKET
;
402 if (usb_submit_urb(urb
, GFP_ATOMIC
)) {
403 lbtf_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed: %d\n", ret
);
407 lbtf_deb_usb2(&cardp
->udev
->dev
, "usb_submit_urb success\n");
412 lbtf_deb_leave(LBTF_DEB_USB
);
416 static int __if_usb_submit_rx_urb(struct if_usb_card
*cardp
,
417 void (*callbackfn
)(struct urb
*urb
))
422 lbtf_deb_enter(LBTF_DEB_USB
);
424 skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
);
426 pr_err("No free skb\n");
427 lbtf_deb_leave(LBTF_DEB_USB
);
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
);
439 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
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
);
444 lbtf_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed: %d\n", ret
);
446 cardp
->rx_skb
= NULL
;
447 lbtf_deb_leave(LBTF_DEB_USB
);
450 lbtf_deb_usb2(&cardp
->udev
->dev
, "Submit Rx URB success\n");
451 lbtf_deb_leave(LBTF_DEB_USB
);
456 static int if_usb_submit_rx_urb_fwload(struct if_usb_card
*cardp
)
458 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive_fwload
);
461 static int if_usb_submit_rx_urb(struct if_usb_card
*cardp
)
463 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive
);
466 static void if_usb_receive_fwload(struct urb
*urb
)
468 struct if_usb_card
*cardp
= urb
->context
;
469 struct sk_buff
*skb
= cardp
->rx_skb
;
470 struct fwsyncheader
*syncfwheader
;
471 struct bootcmdresp bcmdresp
;
473 lbtf_deb_enter(LBTF_DEB_USB
);
475 lbtf_deb_usbd(&cardp
->udev
->dev
,
476 "URB status is failed during fw load\n");
478 lbtf_deb_leave(LBTF_DEB_USB
);
482 if (cardp
->fwdnldover
) {
483 __le32
*tmp
= (__le32
*)(skb
->data
);
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
);
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
);
496 lbtf_deb_leave(LBTF_DEB_USB
);
499 if (cardp
->bootcmdresp
<= 0) {
500 memcpy(&bcmdresp
, skb
->data
, sizeof(bcmdresp
));
502 if (le16_to_cpu(cardp
->udev
->descriptor
.bcdDevice
) < 0x3106) {
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
);
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;
520 pr_info("boot cmd response wrong magic number (0x%x)\n",
521 le32_to_cpu(bcmdresp
.magic
));
523 } else if (bcmdresp
.cmd
!= BOOT_CMD_FW_BY_USB
) {
524 pr_info("boot cmd response cmd_tag error (%d)\n",
526 } else if (bcmdresp
.result
!= BOOT_CMD_RESP_OK
) {
527 pr_info("boot cmd response result error (%d)\n",
530 cardp
->bootcmdresp
= 1;
531 lbtf_deb_usbd(&cardp
->udev
->dev
,
532 "Received valid boot command response\n");
536 if_usb_submit_rx_urb_fwload(cardp
);
537 lbtf_deb_leave(LBTF_DEB_USB
);
541 syncfwheader
= kmemdup(skb
->data
, sizeof(struct fwsyncheader
),
544 lbtf_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
546 lbtf_deb_leave(LBTF_DEB_USB
);
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
));
556 lbtf_deb_usbd(&cardp
->udev
->dev
, "FW received Blk with CRC error\n");
562 /* reschedule timer for 200ms hence */
563 mod_timer(&cardp
->fw_timeout
, jiffies
+ (HZ
/5));
565 if (cardp
->fwfinalblk
) {
566 cardp
->fwdnldover
= 1;
570 if_usb_send_fw_pkt(cardp
);
573 if_usb_submit_rx_urb_fwload(cardp
);
577 lbtf_deb_leave(LBTF_DEB_USB
);
580 #define MRVDRV_MIN_PKT_LEN 30
582 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
583 struct if_usb_card
*cardp
,
584 struct lbtf_private
*priv
)
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");
593 skb_put(skb
, recvlength
);
594 skb_pull(skb
, MESSAGE_HEADER_LEN
);
598 static inline void process_cmdrequest(int recvlength
, uint8_t *recvbuff
,
600 struct if_usb_card
*cardp
,
601 struct lbtf_private
*priv
)
603 if (recvlength
> LBS_CMD_BUFFER_SIZE
) {
604 lbtf_deb_usbd(&cardp
->udev
->dev
,
605 "The receive buffer is too large\n");
610 BUG_ON(!in_interrupt());
612 spin_lock(&priv
->driver_lock
);
613 memcpy(priv
->cmd_resp_buff
, recvbuff
+ MESSAGE_HEADER_LEN
,
614 recvlength
- MESSAGE_HEADER_LEN
);
616 lbtf_cmd_response_rx(priv
);
617 spin_unlock(&priv
->driver_lock
);
621 * if_usb_receive - read data received from the device.
623 * @urb pointer to struct urb
625 static void if_usb_receive(struct urb
*urb
)
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
;
635 lbtf_deb_enter(LBTF_DEB_USB
);
639 lbtf_deb_usbd(&cardp
->udev
->dev
, "RX URB failed: %d\n",
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
) {
652 lbtf_deb_leave(LBTF_DEB_USB
);
658 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
661 case CMD_TYPE_REQUEST
:
662 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
665 case CMD_TYPE_INDICATION
:
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
);
671 /* Icky undocumented magic special case */
672 if (event_cause
& 0xffff0000) {
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
)
684 lbtf_deb_usbd(&cardp
->udev
->dev
,
685 "Unsupported notification %d received\n",
691 lbtf_deb_usbd(&cardp
->udev
->dev
,
692 "libertastf: unknown command type 0x%X\n", recvtype
);
698 if_usb_submit_rx_urb(cardp
);
699 lbtf_deb_leave(LBTF_DEB_USB
);
703 * if_usb_host_to_card - Download data to the device
705 * @priv pointer to struct lbtf_private structure
707 * @buf pointer to data buffer
708 * @len number of bytes
710 * Returns: 0 on success, nonzero otherwise
712 static int if_usb_host_to_card(struct lbtf_private
*priv
, uint8_t type
,
713 uint8_t *payload
, uint16_t nb
)
715 struct if_usb_card
*cardp
= priv
->card
;
718 lbtf_deb_usbd(&cardp
->udev
->dev
, "*** type = %u\n", type
);
719 lbtf_deb_usbd(&cardp
->udev
->dev
, "size after = %d\n", nb
);
721 if (type
== MVMS_CMD
) {
722 *(__le32
*)cardp
->ep_out_buf
= cpu_to_le32(CMD_TYPE_REQUEST
);
724 *(__le32
*)cardp
->ep_out_buf
= cpu_to_le32(CMD_TYPE_DATA
);
728 memcpy((cardp
->ep_out_buf
+ MESSAGE_HEADER_LEN
), payload
, nb
);
730 return usb_tx_block(cardp
, cardp
->ep_out_buf
, nb
+ MESSAGE_HEADER_LEN
,
735 * if_usb_issue_boot_command - Issue boot command to Boot2.
737 * @ivalue 1 boots from FW by USB-Download, 2 boots from FW in EEPROM.
741 static int if_usb_issue_boot_command(struct if_usb_card
*cardp
, int ivalue
)
743 struct bootcmd
*bootcmd
= cardp
->ep_out_buf
;
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
));
751 usb_tx_block(cardp
, cardp
->ep_out_buf
, sizeof(*bootcmd
), 0);
758 * check_fwfile_format - Check the validity of Boot2/FW image.
760 * @data pointer to image
761 * @totlen image length
763 * Returns: 0 if the image is valid, nonzero otherwise.
765 static int check_fwfile_format(const u8
*data
, u32 totlen
)
768 u32 blksize
, offset
, len
;
775 struct fwheader
*fwh
= (void *) data
;
777 bincmd
= le32_to_cpu(fwh
->dnldcmd
);
778 blksize
= le32_to_cpu(fwh
->datalength
);
780 case FW_HAS_DATA_TO_RECV
:
781 offset
= sizeof(struct fwheader
) + blksize
;
787 case FW_HAS_LAST_BLOCK
:
798 pr_err("firmware file format check FAIL\n");
800 lbtf_deb_fw("firmware file format check PASS\n");
806 static int if_usb_prog_firmware(struct if_usb_card
*cardp
)
809 static int reset_count
= 10;
812 lbtf_deb_enter(LBTF_DEB_USB
);
814 kparam_block_sysfs_write(fw_name
);
815 ret
= request_firmware(&cardp
->fw
, lbtf_fw_name
, &cardp
->udev
->dev
);
817 pr_err("request_firmware() failed with %#x\n", ret
);
818 pr_err("firmware %s not found\n", lbtf_fw_name
);
819 kparam_unblock_sysfs_write(fw_name
);
822 kparam_unblock_sysfs_write(fw_name
);
824 if (check_fwfile_format(cardp
->fw
->data
, cardp
->fw
->size
))
828 if (if_usb_submit_rx_urb_fwload(cardp
) < 0) {
829 lbtf_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
834 cardp
->bootcmdresp
= 0;
838 /* Issue Boot command = 1, Boot from Download-FW */
839 if_usb_issue_boot_command(cardp
, BOOT_CMD_FW_BY_USB
);
840 /* wait for command response */
843 msleep_interruptible(100);
844 } while (cardp
->bootcmdresp
== 0 && j
< 10);
845 } while (cardp
->bootcmdresp
== 0 && i
< 5);
847 if (cardp
->bootcmdresp
<= 0) {
848 if (--reset_count
>= 0) {
849 if_usb_reset_device(cardp
);
857 cardp
->totalbytes
= 0;
858 cardp
->fwlastblksent
= 0;
860 cardp
->fwdnldover
= 0;
861 cardp
->fwseqnum
= -1;
862 cardp
->totalbytes
= 0;
863 cardp
->fwfinalblk
= 0;
865 /* Send the first firmware packet... */
866 if_usb_send_fw_pkt(cardp
);
868 /* ... and wait for the process to complete */
869 wait_event_interruptible(cardp
->fw_wq
, cardp
->priv
->surpriseremoved
||
872 del_timer_sync(&cardp
->fw_timeout
);
873 usb_kill_urb(cardp
->rx_urb
);
875 if (!cardp
->fwdnldover
) {
876 pr_info("failed to load fw, resetting device!\n");
877 if (--reset_count
>= 0) {
878 if_usb_reset_device(cardp
);
882 pr_info("FW download failure, time = %d ms\n", i
* 100);
887 cardp
->priv
->fw_ready
= 1;
890 release_firmware(cardp
->fw
);
893 if_usb_setup_firmware(cardp
->priv
);
896 lbtf_deb_leave_args(LBTF_DEB_USB
, "ret %d", ret
);
899 EXPORT_SYMBOL_GPL(if_usb_prog_firmware
);
902 #define if_usb_suspend NULL
903 #define if_usb_resume NULL
905 static struct usb_driver if_usb_driver
= {
907 .probe
= if_usb_probe
,
908 .disconnect
= if_usb_disconnect
,
909 .id_table
= if_usb_table
,
910 .suspend
= if_usb_suspend
,
911 .resume
= if_usb_resume
,
914 static int __init
if_usb_init_module(void)
918 lbtf_deb_enter(LBTF_DEB_MAIN
);
920 ret
= usb_register(&if_usb_driver
);
922 lbtf_deb_leave_args(LBTF_DEB_MAIN
, "ret %d", ret
);
926 static void __exit
if_usb_exit_module(void)
928 lbtf_deb_enter(LBTF_DEB_MAIN
);
929 usb_deregister(&if_usb_driver
);
930 lbtf_deb_leave(LBTF_DEB_MAIN
);
933 module_init(if_usb_init_module
);
934 module_exit(if_usb_exit_module
);
936 MODULE_DESCRIPTION("8388 USB WLAN Thinfirm Driver");
937 MODULE_AUTHOR("Cozybit Inc.");
938 MODULE_LICENSE("GPL");