2 * This file contains functions used in USB interface module.
4 #include <linux/delay.h>
5 #include <linux/moduleparam.h>
6 #include <linux/firmware.h>
7 #include <linux/netdevice.h>
10 #define DRV_NAME "usb8xxx"
18 #define MESSAGE_HEADER_LEN 4
20 static char *lbs_fw_name
= "usb8388.bin";
21 module_param_named(fw_name
, lbs_fw_name
, charp
, 0644);
23 static struct usb_device_id if_usb_table
[] = {
24 /* Enter the device signature inside */
25 { USB_DEVICE(0x1286, 0x2001) },
26 { USB_DEVICE(0x05a3, 0x8388) },
27 {} /* Terminating entry */
30 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
32 static void if_usb_receive(struct urb
*urb
);
33 static void if_usb_receive_fwload(struct urb
*urb
);
34 static int if_usb_prog_firmware(struct usb_card_rec
*cardp
);
35 static int if_usb_host_to_card(struct lbs_private
*priv
,
39 static int if_usb_get_int_status(struct lbs_private
*priv
, u8
*);
40 static int if_usb_read_event_cause(struct lbs_private
*);
41 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
*payload
, u16 nb
);
42 static void if_usb_free(struct usb_card_rec
*cardp
);
43 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
);
44 static int if_usb_reset_device(struct usb_card_rec
*cardp
);
47 * @brief call back function to handle the status of the URB
48 * @param urb pointer to urb structure
51 static void if_usb_write_bulk_callback(struct urb
*urb
)
53 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) urb
->context
;
55 /* handle the transmission complete validations */
57 if (urb
->status
== 0) {
58 struct lbs_private
*priv
= cardp
->priv
;
61 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
62 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
66 /* Used for both firmware TX and regular TX. priv isn't
67 * valid at firmware load time.
70 lbs_host_to_card_done(priv
);
72 /* print the failure status number for debug */
73 lbs_pr_info("URB in failure status: %d\n", urb
->status
);
80 * @brief free tx/rx urb, skb and rx buffer
81 * @param cardp pointer usb_card_rec
84 static void if_usb_free(struct usb_card_rec
*cardp
)
86 lbs_deb_enter(LBS_DEB_USB
);
88 /* Unlink tx & rx urb */
89 usb_kill_urb(cardp
->tx_urb
);
90 usb_kill_urb(cardp
->rx_urb
);
92 usb_free_urb(cardp
->tx_urb
);
95 usb_free_urb(cardp
->rx_urb
);
98 kfree(cardp
->bulk_out_buffer
);
99 cardp
->bulk_out_buffer
= NULL
;
101 lbs_deb_leave(LBS_DEB_USB
);
104 static void if_usb_set_boot2_ver(struct lbs_private
*priv
)
106 struct cmd_ds_set_boot2_ver b2_cmd
;
107 int rsp_len
= sizeof(b2_cmd
);
110 b2_cmd
.version
= priv
->boot2_version
;
112 if (lbs_cmd(priv
, CMD_SET_BOOT2_VER
, &b2_cmd
, sizeof(b2_cmd
),
113 &b2_cmd
, &rsp_len
)) {
114 lbs_deb_usb("Setting boot2 version failed\n");
120 * @brief sets the configuration values
121 * @param ifnum interface number
122 * @param id pointer to usb_device_id
123 * @return 0 on success, error code on failure
125 static int if_usb_probe(struct usb_interface
*intf
,
126 const struct usb_device_id
*id
)
128 struct usb_device
*udev
;
129 struct usb_host_interface
*iface_desc
;
130 struct usb_endpoint_descriptor
*endpoint
;
131 struct lbs_private
*priv
;
132 struct usb_card_rec
*cardp
;
135 udev
= interface_to_usbdev(intf
);
137 cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
139 lbs_pr_err("Out of memory allocating private data.\n");
144 iface_desc
= intf
->cur_altsetting
;
146 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
147 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
148 le16_to_cpu(udev
->descriptor
.bcdUSB
),
149 udev
->descriptor
.bDeviceClass
,
150 udev
->descriptor
.bDeviceSubClass
,
151 udev
->descriptor
.bDeviceProtocol
);
153 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
154 endpoint
= &iface_desc
->endpoint
[i
].desc
;
155 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
156 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
157 USB_ENDPOINT_XFER_BULK
)) {
158 /* we found a bulk in endpoint */
159 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
160 le16_to_cpu(endpoint
->wMaxPacketSize
));
161 if (!(cardp
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
162 lbs_deb_usbd(&udev
->dev
,
163 "Rx URB allocation failed\n");
166 cardp
->rx_urb_recall
= 0;
168 cardp
->bulk_in_size
=
169 le16_to_cpu(endpoint
->wMaxPacketSize
);
170 cardp
->bulk_in_endpointAddr
=
172 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
173 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
174 endpoint
->bEndpointAddress
);
178 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
180 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
181 USB_ENDPOINT_XFER_BULK
)) {
182 /* We found bulk out endpoint */
183 if (!(cardp
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
184 lbs_deb_usbd(&udev
->dev
,
185 "Tx URB allocation failed\n");
189 cardp
->bulk_out_size
=
190 le16_to_cpu(endpoint
->wMaxPacketSize
);
191 lbs_deb_usbd(&udev
->dev
,
192 "Bulk out size is %d\n",
193 le16_to_cpu(endpoint
->wMaxPacketSize
));
194 cardp
->bulk_out_endpointAddr
=
195 endpoint
->bEndpointAddress
;
196 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
197 endpoint
->bEndpointAddress
);
198 cardp
->bulk_out_buffer
=
199 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
202 if (!cardp
->bulk_out_buffer
) {
203 lbs_deb_usbd(&udev
->dev
,
204 "Could not allocate buffer\n");
210 /* Upload firmware */
211 cardp
->rinfo
.cardp
= cardp
;
212 if (if_usb_prog_firmware(cardp
)) {
213 lbs_deb_usbd(&udev
->dev
, "FW upload failed");
214 goto err_prog_firmware
;
217 if (!(priv
= lbs_add_card(cardp
, &udev
->dev
)))
218 goto err_prog_firmware
;
222 if (lbs_add_mesh(priv
, &udev
->dev
))
225 cardp
->eth_dev
= priv
->dev
;
227 priv
->hw_host_to_card
= if_usb_host_to_card
;
228 priv
->hw_get_int_status
= if_usb_get_int_status
;
229 priv
->hw_read_event_cause
= if_usb_read_event_cause
;
230 priv
->boot2_version
= udev
->descriptor
.bcdDevice
;
232 /* Delay 200 ms to waiting for the FW ready */
233 if_usb_submit_rx_urb(cardp
);
234 msleep_interruptible(200);
235 priv
->adapter
->fw_ready
= 1;
237 if (lbs_start_card(priv
))
240 if_usb_set_boot2_ver(priv
);
243 usb_set_intfdata(intf
, cardp
);
248 lbs_remove_mesh(priv
);
250 lbs_remove_card(priv
);
252 if_usb_reset_device(cardp
);
261 * @brief free resource and cleanup
262 * @param intf USB interface structure
265 static void if_usb_disconnect(struct usb_interface
*intf
)
267 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
268 struct lbs_private
*priv
= (struct lbs_private
*) cardp
->priv
;
270 lbs_deb_enter(LBS_DEB_MAIN
);
272 /* Update Surprise removed to TRUE */
273 cardp
->surprise_removed
= 1;
276 struct lbs_adapter
*adapter
= priv
->adapter
;
278 adapter
->surpriseremoved
= 1;
280 lbs_remove_mesh(priv
);
281 lbs_remove_card(priv
);
284 /* this is (apparently?) necessary for future usage of the device */
285 lbs_prepare_and_send_command(priv
, CMD_802_11_RESET
, CMD_ACT_HALT
,
288 /* Unlink and free urb */
291 usb_set_intfdata(intf
, NULL
);
292 usb_put_dev(interface_to_usbdev(intf
));
294 lbs_deb_leave(LBS_DEB_MAIN
);
298 * @brief This function download FW
299 * @param priv pointer to struct lbs_private
302 static int if_prog_firmware(struct usb_card_rec
*cardp
)
304 struct FWData
*fwdata
;
305 struct fwheader
*fwheader
;
306 u8
*firmware
= cardp
->fw
->data
;
308 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
313 fwheader
= &fwdata
->fwheader
;
315 if (!cardp
->CRC_OK
) {
316 cardp
->totalbytes
= cardp
->fwlastblksent
;
317 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
321 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
325 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
326 sizeof(struct fwheader
));
328 cardp
->fwlastblksent
= cardp
->totalbytes
;
329 cardp
->totalbytes
+= sizeof(struct fwheader
);
331 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
332 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
333 le32_to_cpu(fwdata
->fwheader
.datalength
));
336 lbs_deb_usbd(&cardp->udev->dev,
337 "Data length = %d\n", le32_to_cpu(fwdata->fwheader.datalength));
340 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
342 fwdata
->seqnum
= cpu_to_le32(cardp
->fwseqnum
);
343 cardp
->lastseqnum
= cardp
->fwseqnum
;
344 cardp
->totalbytes
+= le32_to_cpu(fwdata
->fwheader
.datalength
);
346 if (fwheader
->dnldcmd
== cpu_to_le32(FW_HAS_DATA_TO_RECV
)) {
348 lbs_deb_usbd(&cardp->udev->dev, "There are data to follow\n");
349 lbs_deb_usbd(&cardp->udev->dev,
350 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
353 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
354 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
356 } else if (fwdata
->fwheader
.dnldcmd
== cpu_to_le32(FW_HAS_LAST_BLOCK
)) {
358 lbs_deb_usbd(&cardp->udev->dev,
359 "Host has finished FW downloading\n");
360 lbs_deb_usbd(&cardp->udev->dev,
361 "Donwloading FW JUMP BLOCK\n");
363 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
364 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
365 cardp
->fwfinalblk
= 1;
369 lbs_deb_usbd(&cardp->udev->dev,
370 "The firmware download is done size is %d\n",
379 static int if_usb_reset_device(struct usb_card_rec
*cardp
)
382 struct lbs_private
*priv
= cardp
->priv
;
384 lbs_deb_enter(LBS_DEB_USB
);
386 /* Try a USB port reset first, if that fails send the reset
387 * command to the firmware.
389 ret
= usb_reset_device(cardp
->udev
);
392 ret
= lbs_reset_device(priv
);
396 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
402 * @brief This function transfer the data to the device.
403 * @param priv pointer to struct lbs_private
404 * @param payload pointer to payload data
405 * @param nb data length
408 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
* payload
, u16 nb
)
412 /* check if device is removed */
413 if (cardp
->surprise_removed
) {
414 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
418 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
419 usb_sndbulkpipe(cardp
->udev
,
420 cardp
->bulk_out_endpointAddr
),
421 payload
, nb
, if_usb_write_bulk_callback
, cardp
);
423 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
425 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
426 /* transfer failed */
427 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed: %d\n", ret
);
430 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
438 static int __if_usb_submit_rx_urb(struct usb_card_rec
*cardp
,
439 void (*callbackfn
)(struct urb
*urb
))
442 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
445 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
446 lbs_pr_err("No free skb\n");
452 /* Fill the receive configuration URB and initialise the Rx call back */
453 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
454 usb_rcvbulkpipe(cardp
->udev
,
455 cardp
->bulk_in_endpointAddr
),
456 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
457 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
460 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
462 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
463 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
464 /* handle failure conditions */
465 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed: %d\n", ret
);
470 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
478 static int if_usb_submit_rx_urb_fwload(struct usb_card_rec
*cardp
)
480 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive_fwload
);
483 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
)
485 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive
);
488 static void if_usb_receive_fwload(struct urb
*urb
)
490 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
491 struct sk_buff
*skb
= rinfo
->skb
;
492 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)rinfo
->cardp
;
493 struct fwsyncheader
*syncfwheader
;
494 struct bootcmdrespStr bootcmdresp
;
497 lbs_deb_usbd(&cardp
->udev
->dev
,
498 "URB status is failed during fw load\n");
503 if (cardp
->bootcmdresp
== 0) {
504 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
505 sizeof(bootcmdresp
));
506 if (le16_to_cpu(cardp
->udev
->descriptor
.bcdDevice
) < 0x3106) {
508 if_usb_submit_rx_urb_fwload(cardp
);
509 cardp
->bootcmdresp
= 1;
510 lbs_deb_usbd(&cardp
->udev
->dev
,
511 "Received valid boot command response\n");
514 if (bootcmdresp
.u32magicnumber
!= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
)) {
516 "boot cmd response wrong magic number (0x%x)\n",
517 le32_to_cpu(bootcmdresp
.u32magicnumber
));
518 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
520 "boot cmd response cmd_tag error (%d)\n",
521 bootcmdresp
.u8cmd_tag
);
522 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
524 "boot cmd response result error (%d)\n",
525 bootcmdresp
.u8result
);
527 cardp
->bootcmdresp
= 1;
528 lbs_deb_usbd(&cardp
->udev
->dev
,
529 "Received valid boot command response\n");
532 if_usb_submit_rx_urb_fwload(cardp
);
536 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
538 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
543 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
544 sizeof(struct fwsyncheader
));
546 if (!syncfwheader
->cmd
) {
548 lbs_deb_usbd(&cardp->udev->dev,
549 "FW received Blk with correct CRC\n");
550 lbs_deb_usbd(&cardp->udev->dev,
551 "FW received Blk seqnum = %d\n",
552 syncfwheader->seqnum);
556 lbs_deb_usbd(&cardp
->udev
->dev
,
557 "FW received Blk with CRC error\n");
563 if (cardp
->fwfinalblk
) {
564 cardp
->fwdnldover
= 1;
568 if_prog_firmware(cardp
);
570 if_usb_submit_rx_urb_fwload(cardp
);
578 #define MRVDRV_MIN_PKT_LEN 30
580 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
581 struct usb_card_rec
*cardp
,
582 struct lbs_private
*priv
)
584 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
585 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
586 lbs_deb_usbd(&cardp
->udev
->dev
,
587 "Packet length is Invalid\n");
592 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
593 skb_put(skb
, recvlength
);
594 skb_pull(skb
, MESSAGE_HEADER_LEN
);
595 lbs_process_rxed_packet(priv
, skb
);
596 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
599 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
601 struct usb_card_rec
*cardp
,
602 struct lbs_private
*priv
)
605 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
606 lbs_deb_usbd(&cardp
->udev
->dev
,
607 "The receive buffer is too large\n");
615 spin_lock(&priv
->adapter
->driver_lock
);
616 /* take care of cur_cmd = NULL case by reading the
617 * data to clear the interrupt */
618 if (!priv
->adapter
->cur_cmd
) {
619 cmdbuf
= priv
->upld_buf
;
620 priv
->adapter
->hisregcpy
&= ~MRVDRV_CMD_UPLD_RDY
;
622 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
624 cardp
->usb_int_cause
|= MRVDRV_CMD_UPLD_RDY
;
625 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
626 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
630 lbs_interrupt(priv
->dev
);
631 spin_unlock(&priv
->adapter
->driver_lock
);
633 lbs_deb_usbd(&cardp
->udev
->dev
,
634 "Wake up main thread to handle cmd response\n");
640 * @brief This function reads of the packet into the upload buff,
641 * wake up the main thread and initialise the Rx callack.
643 * @param urb pointer to struct urb
646 static void if_usb_receive(struct urb
*urb
)
648 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
649 struct sk_buff
*skb
= rinfo
->skb
;
650 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) rinfo
->cardp
;
651 struct lbs_private
*priv
= cardp
->priv
;
653 int recvlength
= urb
->actual_length
;
657 lbs_deb_enter(LBS_DEB_USB
);
663 lbs_deb_usbd(&cardp
->udev
->dev
,
664 "URB status is failed\n");
669 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
670 memcpy(&tmp
, recvbuff
, sizeof(u32
));
671 recvtype
= le32_to_cpu(tmp
);
672 lbs_deb_usbd(&cardp
->udev
->dev
,
673 "Recv length = 0x%x, Recv type = 0x%X\n",
674 recvlength
, recvtype
);
675 } else if (urb
->status
) {
682 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
685 case CMD_TYPE_REQUEST
:
686 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
689 case CMD_TYPE_INDICATION
:
690 /* Event cause handling */
691 spin_lock(&priv
->adapter
->driver_lock
);
692 cardp
->usb_event_cause
= le32_to_cpu(*(__le32
*) (recvbuff
+ MESSAGE_HEADER_LEN
));
693 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
694 cardp
->usb_event_cause
);
695 if (cardp
->usb_event_cause
& 0xffff0000) {
696 lbs_send_tx_feedback(priv
);
697 spin_unlock(&priv
->adapter
->driver_lock
);
700 cardp
->usb_event_cause
<<= 3;
701 cardp
->usb_int_cause
|= MRVDRV_CARDEVENT
;
703 lbs_interrupt(priv
->dev
);
704 spin_unlock(&priv
->adapter
->driver_lock
);
707 lbs_deb_usbd(&cardp
->udev
->dev
, "Unknown command type 0x%X\n",
714 if_usb_submit_rx_urb(cardp
);
716 lbs_deb_leave(LBS_DEB_USB
);
720 * @brief This function downloads data to FW
721 * @param priv pointer to struct lbs_private structure
722 * @param type type of data
723 * @param buf pointer to data buffer
724 * @param len number of bytes
727 static int if_usb_host_to_card(struct lbs_private
*priv
,
732 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
734 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
735 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
737 if (type
== MVMS_CMD
) {
738 __le32 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
739 priv
->dnld_sent
= DNLD_CMD_SENT
;
740 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
744 __le32 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
745 priv
->dnld_sent
= DNLD_DATA_SENT
;
746 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
750 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
752 return usb_tx_block(cardp
, cardp
->bulk_out_buffer
,
753 nb
+ MESSAGE_HEADER_LEN
);
756 /* called with adapter->driver_lock held */
757 static int if_usb_get_int_status(struct lbs_private
*priv
, u8
*ireg
)
759 struct usb_card_rec
*cardp
= priv
->card
;
761 *ireg
= cardp
->usb_int_cause
;
762 cardp
->usb_int_cause
= 0;
764 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
769 static int if_usb_read_event_cause(struct lbs_private
*priv
)
771 struct usb_card_rec
*cardp
= priv
->card
;
773 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
774 /* Re-submit rx urb here to avoid event lost issue */
775 if_usb_submit_rx_urb(cardp
);
780 * @brief This function issues Boot command to the Boot2 code
781 * @param ivalue 1:Boot from FW by USB-Download
782 * 2:Boot from FW in EEPROM
785 static int if_usb_issue_boot_command(struct usb_card_rec
*cardp
, int ivalue
)
787 struct bootcmdstr sbootcmd
;
790 /* Prepare command */
791 sbootcmd
.u32magicnumber
= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
);
792 sbootcmd
.u8cmd_tag
= ivalue
;
794 sbootcmd
.au8dumy
[i
]=0x00;
795 memcpy(cardp
->bulk_out_buffer
, &sbootcmd
, sizeof(struct bootcmdstr
));
798 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, sizeof(struct bootcmdstr
));
805 * @brief This function checks the validity of Boot2/FW image.
807 * @param data pointer to image
811 static int check_fwfile_format(u8
*data
, u32 totlen
)
814 u32 blksize
, offset
, len
;
821 struct fwheader
*fwh
= (void *)data
;
823 bincmd
= le32_to_cpu(fwh
->dnldcmd
);
824 blksize
= le32_to_cpu(fwh
->datalength
);
826 case FW_HAS_DATA_TO_RECV
:
827 offset
= sizeof(struct fwheader
) + blksize
;
833 case FW_HAS_LAST_BLOCK
:
844 lbs_pr_err("firmware file format check FAIL\n");
846 lbs_deb_fw("firmware file format check PASS\n");
852 static int if_usb_prog_firmware(struct usb_card_rec
*cardp
)
855 static int reset_count
= 10;
858 lbs_deb_enter(LBS_DEB_USB
);
860 if ((ret
= request_firmware(&cardp
->fw
, lbs_fw_name
,
861 &cardp
->udev
->dev
)) < 0) {
862 lbs_pr_err("request_firmware() failed with %#x\n", ret
);
863 lbs_pr_err("firmware %s not found\n", lbs_fw_name
);
867 if (check_fwfile_format(cardp
->fw
->data
, cardp
->fw
->size
))
871 if (if_usb_submit_rx_urb_fwload(cardp
) < 0) {
872 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
877 cardp
->bootcmdresp
= 0;
881 /* Issue Boot command = 1, Boot from Download-FW */
882 if_usb_issue_boot_command(cardp
, BOOT_CMD_FW_BY_USB
);
883 /* wait for command response */
886 msleep_interruptible(100);
887 } while (cardp
->bootcmdresp
== 0 && j
< 10);
888 } while (cardp
->bootcmdresp
== 0 && i
< 5);
890 if (cardp
->bootcmdresp
== 0) {
891 if (--reset_count
>= 0) {
892 if_usb_reset_device(cardp
);
900 cardp
->totalbytes
= 0;
901 cardp
->fwlastblksent
= 0;
903 cardp
->fwdnldover
= 0;
904 cardp
->fwseqnum
= -1;
905 cardp
->totalbytes
= 0;
906 cardp
->fwfinalblk
= 0;
908 if_prog_firmware(cardp
);
911 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
913 msleep_interruptible(100);
914 if (cardp
->surprise_removed
|| i
>= 20)
916 } while (!cardp
->fwdnldover
);
918 if (!cardp
->fwdnldover
) {
919 lbs_pr_info("failed to load fw, resetting device!\n");
920 if (--reset_count
>= 0) {
921 if_usb_reset_device(cardp
);
925 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
931 release_firmware(cardp
->fw
);
935 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
941 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
943 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
944 struct lbs_private
*priv
= cardp
->priv
;
946 lbs_deb_enter(LBS_DEB_USB
);
948 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
951 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
952 /* Mesh autostart must be activated while sleeping
953 * On resume it will go back to the current state
955 struct cmd_ds_mesh_access mesh_access
;
956 memset(&mesh_access
, 0, sizeof(mesh_access
));
957 mesh_access
.data
[0] = cpu_to_le32(1);
958 lbs_prepare_and_send_command(priv
,
960 CMD_ACT_MESH_SET_AUTOSTART_ENABLED
,
961 CMD_OPTION_WAITFORRSP
, 0, (void *)&mesh_access
);
964 netif_device_detach(cardp
->eth_dev
);
965 netif_device_detach(priv
->mesh_dev
);
967 /* Unlink tx & rx urb */
968 usb_kill_urb(cardp
->tx_urb
);
969 usb_kill_urb(cardp
->rx_urb
);
971 cardp
->rx_urb_recall
= 1;
973 lbs_deb_leave(LBS_DEB_USB
);
977 static int if_usb_resume(struct usb_interface
*intf
)
979 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
980 struct lbs_private
*priv
= cardp
->priv
;
982 lbs_deb_enter(LBS_DEB_USB
);
984 cardp
->rx_urb_recall
= 0;
986 if_usb_submit_rx_urb(cardp
->priv
);
988 netif_device_attach(cardp
->eth_dev
);
989 netif_device_attach(priv
->mesh_dev
);
991 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
992 /* Mesh autostart was activated while sleeping
993 * Disable it if appropriate
995 struct cmd_ds_mesh_access mesh_access
;
996 memset(&mesh_access
, 0, sizeof(mesh_access
));
997 mesh_access
.data
[0] = cpu_to_le32(0);
998 lbs_prepare_and_send_command(priv
,
1000 CMD_ACT_MESH_SET_AUTOSTART_ENABLED
,
1001 CMD_OPTION_WAITFORRSP
, 0, (void *)&mesh_access
);
1004 lbs_deb_leave(LBS_DEB_USB
);
1008 #define if_usb_suspend NULL
1009 #define if_usb_resume NULL
1012 static struct usb_driver if_usb_driver
= {
1014 .probe
= if_usb_probe
,
1015 .disconnect
= if_usb_disconnect
,
1016 .id_table
= if_usb_table
,
1017 .suspend
= if_usb_suspend
,
1018 .resume
= if_usb_resume
,
1021 static int __init
if_usb_init_module(void)
1025 lbs_deb_enter(LBS_DEB_MAIN
);
1027 ret
= usb_register(&if_usb_driver
);
1029 lbs_deb_leave_args(LBS_DEB_MAIN
, "ret %d", ret
);
1033 static void __exit
if_usb_exit_module(void)
1035 lbs_deb_enter(LBS_DEB_MAIN
);
1037 usb_deregister(&if_usb_driver
);
1039 lbs_deb_leave(LBS_DEB_MAIN
);
1042 module_init(if_usb_init_module
);
1043 module_exit(if_usb_exit_module
);
1045 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1046 MODULE_AUTHOR("Marvell International Ltd.");
1047 MODULE_LICENSE("GPL");