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/module.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",
183 lbtf_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
185 } else if (usb_endpoint_is_bulk_out(endpoint
)) {
187 le16_to_cpu(endpoint
->wMaxPacketSize
);
188 cardp
->ep_out
= usb_endpoint_num(endpoint
);
190 lbtf_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
192 lbtf_deb_usbd(&udev
->dev
, "Bulk out size is %d\n",
196 if (!cardp
->ep_out_size
|| !cardp
->ep_in_size
) {
197 lbtf_deb_usbd(&udev
->dev
, "Endpoints not found\n");
198 /* Endpoints not found */
202 cardp
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
203 if (!cardp
->rx_urb
) {
204 lbtf_deb_usbd(&udev
->dev
, "Rx URB allocation failed\n");
208 cardp
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
209 if (!cardp
->tx_urb
) {
210 lbtf_deb_usbd(&udev
->dev
, "Tx URB allocation failed\n");
214 cardp
->cmd_urb
= usb_alloc_urb(0, GFP_KERNEL
);
215 if (!cardp
->cmd_urb
) {
216 lbtf_deb_usbd(&udev
->dev
, "Cmd URB allocation failed\n");
220 cardp
->ep_out_buf
= kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
222 if (!cardp
->ep_out_buf
) {
223 lbtf_deb_usbd(&udev
->dev
, "Could not allocate buffer\n");
227 priv
= lbtf_add_card(cardp
, &udev
->dev
);
233 priv
->hw_host_to_card
= if_usb_host_to_card
;
234 priv
->hw_prog_firmware
= if_usb_prog_firmware
;
235 priv
->hw_reset_device
= if_usb_reset_device
;
236 cardp
->boot2_version
= udev
->descriptor
.bcdDevice
;
239 usb_set_intfdata(intf
, cardp
);
246 lbtf_deb_leave(LBTF_DEB_MAIN
);
251 * if_usb_disconnect - free resource and cleanup
253 * @intf USB interface structure
255 static void if_usb_disconnect(struct usb_interface
*intf
)
257 struct if_usb_card
*cardp
= usb_get_intfdata(intf
);
258 struct lbtf_private
*priv
= (struct lbtf_private
*) cardp
->priv
;
260 lbtf_deb_enter(LBTF_DEB_MAIN
);
262 if_usb_reset_device(cardp
);
265 lbtf_remove_card(priv
);
267 /* Unlink and free urb */
270 usb_set_intfdata(intf
, NULL
);
271 usb_put_dev(interface_to_usbdev(intf
));
273 lbtf_deb_leave(LBTF_DEB_MAIN
);
277 * if_usb_send_fw_pkt - This function downloads the FW
279 * @priv pointer to struct lbtf_private
283 static int if_usb_send_fw_pkt(struct if_usb_card
*cardp
)
285 struct fwdata
*fwdata
= cardp
->ep_out_buf
;
286 u8
*firmware
= (u8
*) cardp
->fw
->data
;
288 lbtf_deb_enter(LBTF_DEB_FW
);
290 /* If we got a CRC failure on the last block, back
292 if (!cardp
->CRC_OK
) {
293 cardp
->totalbytes
= cardp
->fwlastblksent
;
297 lbtf_deb_usb2(&cardp
->udev
->dev
, "totalbytes = %d\n",
300 /* struct fwdata (which we sent to the card) has an
301 extra __le32 field in between the header and the data,
302 which is not in the struct fwheader in the actual
303 firmware binary. Insert the seqnum in the middle... */
304 memcpy(&fwdata
->hdr
, &firmware
[cardp
->totalbytes
],
305 sizeof(struct fwheader
));
307 cardp
->fwlastblksent
= cardp
->totalbytes
;
308 cardp
->totalbytes
+= sizeof(struct fwheader
);
310 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
311 le32_to_cpu(fwdata
->hdr
.datalength
));
313 lbtf_deb_usb2(&cardp
->udev
->dev
, "Data length = %d\n",
314 le32_to_cpu(fwdata
->hdr
.datalength
));
316 fwdata
->seqnum
= cpu_to_le32(++cardp
->fwseqnum
);
317 cardp
->totalbytes
+= le32_to_cpu(fwdata
->hdr
.datalength
);
319 usb_tx_block(cardp
, cardp
->ep_out_buf
, sizeof(struct fwdata
) +
320 le32_to_cpu(fwdata
->hdr
.datalength
), 0);
322 if (fwdata
->hdr
.dnldcmd
== cpu_to_le32(FW_HAS_DATA_TO_RECV
)) {
323 lbtf_deb_usb2(&cardp
->udev
->dev
, "There are data to follow\n");
324 lbtf_deb_usb2(&cardp
->udev
->dev
,
325 "seqnum = %d totalbytes = %d\n",
326 cardp
->fwseqnum
, cardp
->totalbytes
);
327 } else if (fwdata
->hdr
.dnldcmd
== cpu_to_le32(FW_HAS_LAST_BLOCK
)) {
328 lbtf_deb_usb2(&cardp
->udev
->dev
,
329 "Host has finished FW downloading\n");
330 lbtf_deb_usb2(&cardp
->udev
->dev
, "Donwloading FW JUMP BLOCK\n");
332 /* Host has finished FW downloading
333 * Donwloading FW JUMP BLOCK
335 cardp
->fwfinalblk
= 1;
338 lbtf_deb_usb2(&cardp
->udev
->dev
, "Firmware download done; size %d\n",
341 lbtf_deb_leave(LBTF_DEB_FW
);
345 static int if_usb_reset_device(struct if_usb_card
*cardp
)
347 struct cmd_ds_802_11_reset
*cmd
= cardp
->ep_out_buf
+ 4;
350 lbtf_deb_enter(LBTF_DEB_USB
);
352 *(__le32
*)cardp
->ep_out_buf
= cpu_to_le32(CMD_TYPE_REQUEST
);
354 cmd
->hdr
.command
= cpu_to_le16(CMD_802_11_RESET
);
355 cmd
->hdr
.size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_reset
));
356 cmd
->hdr
.result
= cpu_to_le16(0);
357 cmd
->hdr
.seqnum
= cpu_to_le16(0x5a5a);
358 cmd
->action
= cpu_to_le16(CMD_ACT_HALT
);
359 usb_tx_block(cardp
, cardp
->ep_out_buf
,
360 4 + sizeof(struct cmd_ds_802_11_reset
), 0);
363 ret
= usb_reset_device(cardp
->udev
);
366 lbtf_deb_leave_args(LBTF_DEB_USB
, "ret %d", ret
);
370 EXPORT_SYMBOL_GPL(if_usb_reset_device
);
373 * usb_tx_block - transfer data to the device
375 * @priv pointer to struct lbtf_private
376 * @payload pointer to payload data
378 * @data non-zero for data, zero for commands
380 * Returns: 0 on success, nonzero otherwise.
382 static int usb_tx_block(struct if_usb_card
*cardp
, uint8_t *payload
,
383 uint16_t nb
, u8 data
)
388 lbtf_deb_enter(LBTF_DEB_USB
);
389 /* check if device is removed */
390 if (cardp
->priv
->surpriseremoved
) {
391 lbtf_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
398 urb
= cardp
->cmd_urb
;
400 usb_fill_bulk_urb(urb
, cardp
->udev
,
401 usb_sndbulkpipe(cardp
->udev
,
403 payload
, nb
, if_usb_write_bulk_callback
, cardp
);
405 urb
->transfer_flags
|= URB_ZERO_PACKET
;
407 if (usb_submit_urb(urb
, GFP_ATOMIC
)) {
408 lbtf_deb_usbd(&cardp
->udev
->dev
,
409 "usb_submit_urb failed: %d\n", ret
);
413 lbtf_deb_usb2(&cardp
->udev
->dev
, "usb_submit_urb success\n");
418 lbtf_deb_leave(LBTF_DEB_USB
);
422 static int __if_usb_submit_rx_urb(struct if_usb_card
*cardp
,
423 void (*callbackfn
)(struct urb
*urb
))
428 lbtf_deb_enter(LBTF_DEB_USB
);
430 skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
);
432 pr_err("No free skb\n");
433 lbtf_deb_leave(LBTF_DEB_USB
);
439 /* Fill the receive configuration URB and initialise the Rx call back */
440 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
441 usb_rcvbulkpipe(cardp
->udev
, cardp
->ep_in
),
442 skb_tail_pointer(skb
),
443 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
, cardp
);
445 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
447 lbtf_deb_usb2(&cardp
->udev
->dev
, "Pointer for rx_urb %p\n",
449 ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
);
451 lbtf_deb_usbd(&cardp
->udev
->dev
,
452 "Submit Rx URB failed: %d\n", ret
);
454 cardp
->rx_skb
= NULL
;
455 lbtf_deb_leave(LBTF_DEB_USB
);
458 lbtf_deb_usb2(&cardp
->udev
->dev
, "Submit Rx URB success\n");
459 lbtf_deb_leave(LBTF_DEB_USB
);
464 static int if_usb_submit_rx_urb_fwload(struct if_usb_card
*cardp
)
466 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive_fwload
);
469 static int if_usb_submit_rx_urb(struct if_usb_card
*cardp
)
471 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive
);
474 static void if_usb_receive_fwload(struct urb
*urb
)
476 struct if_usb_card
*cardp
= urb
->context
;
477 struct sk_buff
*skb
= cardp
->rx_skb
;
478 struct fwsyncheader
*syncfwheader
;
479 struct bootcmdresp bcmdresp
;
481 lbtf_deb_enter(LBTF_DEB_USB
);
483 lbtf_deb_usbd(&cardp
->udev
->dev
,
484 "URB status is failed during fw load\n");
486 lbtf_deb_leave(LBTF_DEB_USB
);
490 if (cardp
->fwdnldover
) {
491 __le32
*tmp
= (__le32
*)(skb
->data
);
493 if (tmp
[0] == cpu_to_le32(CMD_TYPE_INDICATION
) &&
494 tmp
[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY
)) {
495 /* Firmware ready event received */
496 pr_info("Firmware ready event received\n");
497 wake_up(&cardp
->fw_wq
);
499 lbtf_deb_usb("Waiting for confirmation; got %x %x\n",
500 le32_to_cpu(tmp
[0]), le32_to_cpu(tmp
[1]));
501 if_usb_submit_rx_urb_fwload(cardp
);
504 lbtf_deb_leave(LBTF_DEB_USB
);
507 if (cardp
->bootcmdresp
<= 0) {
508 memcpy(&bcmdresp
, skb
->data
, sizeof(bcmdresp
));
510 if (le16_to_cpu(cardp
->udev
->descriptor
.bcdDevice
) < 0x3106) {
512 if_usb_submit_rx_urb_fwload(cardp
);
513 cardp
->bootcmdresp
= 1;
514 /* Received valid boot command response */
515 lbtf_deb_usbd(&cardp
->udev
->dev
,
516 "Received valid boot command response\n");
517 lbtf_deb_leave(LBTF_DEB_USB
);
520 if (bcmdresp
.magic
!= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
)) {
521 if (bcmdresp
.magic
== cpu_to_le32(CMD_TYPE_REQUEST
) ||
522 bcmdresp
.magic
== cpu_to_le32(CMD_TYPE_DATA
) ||
523 bcmdresp
.magic
== cpu_to_le32(CMD_TYPE_INDICATION
)) {
524 if (!cardp
->bootcmdresp
)
525 pr_info("Firmware already seems alive; resetting\n");
526 cardp
->bootcmdresp
= -1;
528 pr_info("boot cmd response wrong magic number (0x%x)\n",
529 le32_to_cpu(bcmdresp
.magic
));
531 } else if (bcmdresp
.cmd
!= BOOT_CMD_FW_BY_USB
) {
532 pr_info("boot cmd response cmd_tag error (%d)\n",
534 } else if (bcmdresp
.result
!= BOOT_CMD_RESP_OK
) {
535 pr_info("boot cmd response result error (%d)\n",
538 cardp
->bootcmdresp
= 1;
539 lbtf_deb_usbd(&cardp
->udev
->dev
,
540 "Received valid boot command response\n");
544 if_usb_submit_rx_urb_fwload(cardp
);
545 lbtf_deb_leave(LBTF_DEB_USB
);
549 syncfwheader
= kmemdup(skb
->data
, sizeof(struct fwsyncheader
),
552 lbtf_deb_usbd(&cardp
->udev
->dev
,
553 "Failure to allocate syncfwheader\n");
555 lbtf_deb_leave(LBTF_DEB_USB
);
559 if (!syncfwheader
->cmd
) {
560 lbtf_deb_usb2(&cardp
->udev
->dev
,
561 "FW received Blk with correct CRC\n");
562 lbtf_deb_usb2(&cardp
->udev
->dev
,
563 "FW received Blk seqnum = %d\n",
564 le32_to_cpu(syncfwheader
->seqnum
));
567 lbtf_deb_usbd(&cardp
->udev
->dev
,
568 "FW received Blk with CRC error\n");
574 /* reschedule timer for 200ms hence */
575 mod_timer(&cardp
->fw_timeout
, jiffies
+ (HZ
/5));
577 if (cardp
->fwfinalblk
) {
578 cardp
->fwdnldover
= 1;
582 if_usb_send_fw_pkt(cardp
);
585 if_usb_submit_rx_urb_fwload(cardp
);
589 lbtf_deb_leave(LBTF_DEB_USB
);
592 #define MRVDRV_MIN_PKT_LEN 30
594 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
595 struct if_usb_card
*cardp
,
596 struct lbtf_private
*priv
)
598 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+ MESSAGE_HEADER_LEN
599 || recvlength
< MRVDRV_MIN_PKT_LEN
) {
600 lbtf_deb_usbd(&cardp
->udev
->dev
, "Packet length is Invalid\n");
605 skb_put(skb
, recvlength
);
606 skb_pull(skb
, MESSAGE_HEADER_LEN
);
610 static inline void process_cmdrequest(int recvlength
, uint8_t *recvbuff
,
612 struct if_usb_card
*cardp
,
613 struct lbtf_private
*priv
)
615 if (recvlength
> LBS_CMD_BUFFER_SIZE
) {
616 lbtf_deb_usbd(&cardp
->udev
->dev
,
617 "The receive buffer is too large\n");
622 BUG_ON(!in_interrupt());
624 spin_lock(&priv
->driver_lock
);
625 memcpy(priv
->cmd_resp_buff
, recvbuff
+ MESSAGE_HEADER_LEN
,
626 recvlength
- MESSAGE_HEADER_LEN
);
628 lbtf_cmd_response_rx(priv
);
629 spin_unlock(&priv
->driver_lock
);
633 * if_usb_receive - read data received from the device.
635 * @urb pointer to struct urb
637 static void if_usb_receive(struct urb
*urb
)
639 struct if_usb_card
*cardp
= urb
->context
;
640 struct sk_buff
*skb
= cardp
->rx_skb
;
641 struct lbtf_private
*priv
= cardp
->priv
;
642 int recvlength
= urb
->actual_length
;
643 uint8_t *recvbuff
= NULL
;
644 uint32_t recvtype
= 0;
645 __le32
*pkt
= (__le32
*) skb
->data
;
647 lbtf_deb_enter(LBTF_DEB_USB
);
651 lbtf_deb_usbd(&cardp
->udev
->dev
, "RX URB failed: %d\n",
657 recvbuff
= skb
->data
;
658 recvtype
= le32_to_cpu(pkt
[0]);
659 lbtf_deb_usbd(&cardp
->udev
->dev
,
660 "Recv length = 0x%x, Recv type = 0x%X\n",
661 recvlength
, recvtype
);
662 } else if (urb
->status
) {
664 lbtf_deb_leave(LBTF_DEB_USB
);
670 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
673 case CMD_TYPE_REQUEST
:
674 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
677 case CMD_TYPE_INDICATION
:
679 /* Event cause handling */
680 u32 event_cause
= le32_to_cpu(pkt
[1]);
681 lbtf_deb_usbd(&cardp
->udev
->dev
, "**EVENT** 0x%X\n",
684 /* Icky undocumented magic special case */
685 if (event_cause
& 0xffff0000) {
690 tmp
= event_cause
>> 16;
691 retrycnt
= tmp
& 0x00ff;
692 failure
= (tmp
& 0xff00) >> 8;
693 lbtf_send_tx_feedback(priv
, retrycnt
, failure
);
694 } else if (event_cause
== LBTF_EVENT_BCN_SENT
)
697 lbtf_deb_usbd(&cardp
->udev
->dev
,
698 "Unsupported notification %d received\n",
704 lbtf_deb_usbd(&cardp
->udev
->dev
,
705 "libertastf: unknown command type 0x%X\n", recvtype
);
711 if_usb_submit_rx_urb(cardp
);
712 lbtf_deb_leave(LBTF_DEB_USB
);
716 * if_usb_host_to_card - Download data to the device
718 * @priv pointer to struct lbtf_private structure
720 * @buf pointer to data buffer
721 * @len number of bytes
723 * Returns: 0 on success, nonzero otherwise
725 static int if_usb_host_to_card(struct lbtf_private
*priv
, uint8_t type
,
726 uint8_t *payload
, uint16_t nb
)
728 struct if_usb_card
*cardp
= priv
->card
;
731 lbtf_deb_usbd(&cardp
->udev
->dev
, "*** type = %u\n", type
);
732 lbtf_deb_usbd(&cardp
->udev
->dev
, "size after = %d\n", nb
);
734 if (type
== MVMS_CMD
) {
735 *(__le32
*)cardp
->ep_out_buf
= cpu_to_le32(CMD_TYPE_REQUEST
);
737 *(__le32
*)cardp
->ep_out_buf
= cpu_to_le32(CMD_TYPE_DATA
);
741 memcpy((cardp
->ep_out_buf
+ MESSAGE_HEADER_LEN
), payload
, nb
);
743 return usb_tx_block(cardp
, cardp
->ep_out_buf
, nb
+ MESSAGE_HEADER_LEN
,
748 * if_usb_issue_boot_command - Issue boot command to Boot2.
750 * @ivalue 1 boots from FW by USB-Download, 2 boots from FW in EEPROM.
754 static int if_usb_issue_boot_command(struct if_usb_card
*cardp
, int ivalue
)
756 struct bootcmd
*bootcmd
= cardp
->ep_out_buf
;
758 /* Prepare command */
759 bootcmd
->magic
= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
);
760 bootcmd
->cmd
= ivalue
;
761 memset(bootcmd
->pad
, 0, sizeof(bootcmd
->pad
));
764 usb_tx_block(cardp
, cardp
->ep_out_buf
, sizeof(*bootcmd
), 0);
771 * check_fwfile_format - Check the validity of Boot2/FW image.
773 * @data pointer to image
774 * @totlen image length
776 * Returns: 0 if the image is valid, nonzero otherwise.
778 static int check_fwfile_format(const u8
*data
, u32 totlen
)
781 u32 blksize
, offset
, len
;
788 struct fwheader
*fwh
= (void *) data
;
790 bincmd
= le32_to_cpu(fwh
->dnldcmd
);
791 blksize
= le32_to_cpu(fwh
->datalength
);
793 case FW_HAS_DATA_TO_RECV
:
794 offset
= sizeof(struct fwheader
) + blksize
;
800 case FW_HAS_LAST_BLOCK
:
811 pr_err("firmware file format check FAIL\n");
813 lbtf_deb_fw("firmware file format check PASS\n");
819 static int if_usb_prog_firmware(struct if_usb_card
*cardp
)
822 static int reset_count
= 10;
825 lbtf_deb_enter(LBTF_DEB_USB
);
827 kparam_block_sysfs_write(fw_name
);
828 ret
= request_firmware(&cardp
->fw
, lbtf_fw_name
, &cardp
->udev
->dev
);
830 pr_err("request_firmware() failed with %#x\n", ret
);
831 pr_err("firmware %s not found\n", lbtf_fw_name
);
832 kparam_unblock_sysfs_write(fw_name
);
835 kparam_unblock_sysfs_write(fw_name
);
837 if (check_fwfile_format(cardp
->fw
->data
, cardp
->fw
->size
))
841 if (if_usb_submit_rx_urb_fwload(cardp
) < 0) {
842 lbtf_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
847 cardp
->bootcmdresp
= 0;
851 /* Issue Boot command = 1, Boot from Download-FW */
852 if_usb_issue_boot_command(cardp
, BOOT_CMD_FW_BY_USB
);
853 /* wait for command response */
856 msleep_interruptible(100);
857 } while (cardp
->bootcmdresp
== 0 && j
< 10);
858 } while (cardp
->bootcmdresp
== 0 && i
< 5);
860 if (cardp
->bootcmdresp
<= 0) {
861 if (--reset_count
>= 0) {
862 if_usb_reset_device(cardp
);
870 cardp
->totalbytes
= 0;
871 cardp
->fwlastblksent
= 0;
873 cardp
->fwdnldover
= 0;
874 cardp
->fwseqnum
= -1;
875 cardp
->totalbytes
= 0;
876 cardp
->fwfinalblk
= 0;
878 /* Send the first firmware packet... */
879 if_usb_send_fw_pkt(cardp
);
881 /* ... and wait for the process to complete */
882 wait_event_interruptible(cardp
->fw_wq
, cardp
->priv
->surpriseremoved
||
885 del_timer_sync(&cardp
->fw_timeout
);
886 usb_kill_urb(cardp
->rx_urb
);
888 if (!cardp
->fwdnldover
) {
889 pr_info("failed to load fw, resetting device!\n");
890 if (--reset_count
>= 0) {
891 if_usb_reset_device(cardp
);
895 pr_info("FW download failure, time = %d ms\n", i
* 100);
900 cardp
->priv
->fw_ready
= 1;
903 release_firmware(cardp
->fw
);
906 if_usb_setup_firmware(cardp
->priv
);
909 lbtf_deb_leave_args(LBTF_DEB_USB
, "ret %d", ret
);
912 EXPORT_SYMBOL_GPL(if_usb_prog_firmware
);
915 #define if_usb_suspend NULL
916 #define if_usb_resume NULL
918 static struct usb_driver if_usb_driver
= {
920 .probe
= if_usb_probe
,
921 .disconnect
= if_usb_disconnect
,
922 .id_table
= if_usb_table
,
923 .suspend
= if_usb_suspend
,
924 .resume
= if_usb_resume
,
927 module_usb_driver(if_usb_driver
);
929 MODULE_DESCRIPTION("8388 USB WLAN Thinfirm Driver");
930 MODULE_AUTHOR("Cozybit Inc.");
931 MODULE_LICENSE("GPL");