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>
8 #include <linux/list.h>
11 #define DRV_NAME "usb8xxx"
19 #define MESSAGE_HEADER_LEN 4
21 static const char usbdriver_name
[] = "usb8xxx";
23 static char *lbs_fw_name
= "usb8388.bin";
24 module_param_named(fw_name
, lbs_fw_name
, charp
, 0644);
27 * We need to send a RESET command to all USB devices before
28 * we tear down the USB connection. Otherwise we would not
29 * be able to re-init device the device if the module gets
30 * loaded again. This is a list of all initialized USB devices,
31 * for the reset code see if_usb_reset_device()
33 static LIST_HEAD(usb_devices
);
35 static struct usb_device_id if_usb_table
[] = {
36 /* Enter the device signature inside */
37 { USB_DEVICE(0x1286, 0x2001) },
38 { USB_DEVICE(0x05a3, 0x8388) },
39 {} /* Terminating entry */
42 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
44 static void if_usb_receive(struct urb
*urb
);
45 static void if_usb_receive_fwload(struct urb
*urb
);
46 static int if_usb_prog_firmware(struct usb_card_rec
*cardp
);
47 static int if_usb_host_to_card(lbs_private
*priv
, u8 type
, u8
*payload
, u16 nb
);
48 static int if_usb_get_int_status(lbs_private
*priv
, u8
*);
49 static int if_usb_read_event_cause(lbs_private
*);
50 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
*payload
, u16 nb
);
51 static void if_usb_free(struct usb_card_rec
*cardp
);
52 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
);
53 static int if_usb_reset_device(struct usb_card_rec
*cardp
);
56 * @brief call back function to handle the status of the URB
57 * @param urb pointer to urb structure
60 static void if_usb_write_bulk_callback(struct urb
*urb
)
62 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) urb
->context
;
64 /* handle the transmission complete validations */
66 if (urb
->status
== 0) {
67 lbs_private
*priv
= cardp
->priv
;
70 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
71 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
75 /* Used for both firmware TX and regular TX. priv isn't
76 * valid at firmware load time.
79 lbs_adapter
*adapter
= priv
->adapter
;
80 struct net_device
*dev
= priv
->dev
;
82 priv
->dnld_sent
= DNLD_RES_RECEIVED
;
84 /* Wake main thread if commands are pending */
85 if (!adapter
->cur_cmd
)
86 wake_up_interruptible(&priv
->waitq
);
88 if ((adapter
->connect_status
== LBS_CONNECTED
)) {
89 netif_wake_queue(dev
);
90 netif_wake_queue(priv
->mesh_dev
);
94 /* print the failure status number for debug */
95 lbs_pr_info("URB in failure status: %d\n", urb
->status
);
102 * @brief free tx/rx urb, skb and rx buffer
103 * @param cardp pointer usb_card_rec
106 static void if_usb_free(struct usb_card_rec
*cardp
)
108 lbs_deb_enter(LBS_DEB_USB
);
110 /* Unlink tx & rx urb */
111 usb_kill_urb(cardp
->tx_urb
);
112 usb_kill_urb(cardp
->rx_urb
);
114 usb_free_urb(cardp
->tx_urb
);
115 cardp
->tx_urb
= NULL
;
117 usb_free_urb(cardp
->rx_urb
);
118 cardp
->rx_urb
= NULL
;
120 kfree(cardp
->bulk_out_buffer
);
121 cardp
->bulk_out_buffer
= NULL
;
123 lbs_deb_leave(LBS_DEB_USB
);
127 * @brief sets the configuration values
128 * @param ifnum interface number
129 * @param id pointer to usb_device_id
130 * @return 0 on success, error code on failure
132 static int if_usb_probe(struct usb_interface
*intf
,
133 const struct usb_device_id
*id
)
135 struct usb_device
*udev
;
136 struct usb_host_interface
*iface_desc
;
137 struct usb_endpoint_descriptor
*endpoint
;
139 struct usb_card_rec
*cardp
;
142 udev
= interface_to_usbdev(intf
);
144 cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
146 lbs_pr_err("Out of memory allocating private data.\n");
151 iface_desc
= intf
->cur_altsetting
;
153 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
154 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
155 le16_to_cpu(udev
->descriptor
.bcdUSB
),
156 udev
->descriptor
.bDeviceClass
,
157 udev
->descriptor
.bDeviceSubClass
,
158 udev
->descriptor
.bDeviceProtocol
);
160 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
161 endpoint
= &iface_desc
->endpoint
[i
].desc
;
162 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
163 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
164 USB_ENDPOINT_XFER_BULK
)) {
165 /* we found a bulk in endpoint */
166 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
167 le16_to_cpu(endpoint
->wMaxPacketSize
));
168 if (!(cardp
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
169 lbs_deb_usbd(&udev
->dev
,
170 "Rx URB allocation failed\n");
173 cardp
->rx_urb_recall
= 0;
175 cardp
->bulk_in_size
=
176 le16_to_cpu(endpoint
->wMaxPacketSize
);
177 cardp
->bulk_in_endpointAddr
=
179 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
180 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
181 endpoint
->bEndpointAddress
);
185 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
187 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
188 USB_ENDPOINT_XFER_BULK
)) {
189 /* We found bulk out endpoint */
190 if (!(cardp
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
191 lbs_deb_usbd(&udev
->dev
,
192 "Tx URB allocation failed\n");
196 cardp
->bulk_out_size
=
197 le16_to_cpu(endpoint
->wMaxPacketSize
);
198 lbs_deb_usbd(&udev
->dev
,
199 "Bulk out size is %d\n",
200 le16_to_cpu(endpoint
->wMaxPacketSize
));
201 cardp
->bulk_out_endpointAddr
=
202 endpoint
->bEndpointAddress
;
203 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
204 endpoint
->bEndpointAddress
);
205 cardp
->bulk_out_buffer
=
206 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
209 if (!cardp
->bulk_out_buffer
) {
210 lbs_deb_usbd(&udev
->dev
,
211 "Could not allocate buffer\n");
217 /* Upload firmware */
218 cardp
->rinfo
.cardp
= cardp
;
219 if (if_usb_prog_firmware(cardp
)) {
220 lbs_deb_usbd(&udev
->dev
, "FW upload failed");
221 goto err_prog_firmware
;
224 if (!(priv
= lbs_add_card(cardp
, &udev
->dev
)))
225 goto err_prog_firmware
;
229 if (lbs_add_mesh(priv
, &udev
->dev
))
232 cardp
->eth_dev
= priv
->dev
;
234 priv
->hw_host_to_card
= if_usb_host_to_card
;
235 priv
->hw_get_int_status
= if_usb_get_int_status
;
236 priv
->hw_read_event_cause
= if_usb_read_event_cause
;
237 priv
->boot2_version
= udev
->descriptor
.bcdDevice
;
239 /* Delay 200 ms to waiting for the FW ready */
240 if_usb_submit_rx_urb(cardp
);
241 msleep_interruptible(200);
242 priv
->adapter
->fw_ready
= 1;
244 if (lbs_start_card(priv
))
247 list_add_tail(&cardp
->list
, &usb_devices
);
250 usb_set_intfdata(intf
, cardp
);
255 lbs_remove_mesh(priv
);
257 lbs_remove_card(priv
);
259 if_usb_reset_device(cardp
);
268 * @brief free resource and cleanup
269 * @param intf USB interface structure
272 static void if_usb_disconnect(struct usb_interface
*intf
)
274 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
275 lbs_private
*priv
= (lbs_private
*) cardp
->priv
;
277 lbs_deb_enter(LBS_DEB_MAIN
);
279 /* Update Surprise removed to TRUE */
280 cardp
->surprise_removed
= 1;
282 list_del(&cardp
->list
);
285 lbs_adapter
*adapter
= priv
->adapter
;
287 adapter
->surpriseremoved
= 1;
289 lbs_remove_mesh(priv
);
290 lbs_remove_card(priv
);
293 /* Unlink and free urb */
296 usb_set_intfdata(intf
, NULL
);
297 usb_put_dev(interface_to_usbdev(intf
));
299 lbs_deb_leave(LBS_DEB_MAIN
);
303 * @brief This function download FW
304 * @param priv pointer to lbs_private
307 static int if_prog_firmware(struct usb_card_rec
*cardp
)
309 struct FWData
*fwdata
;
310 struct fwheader
*fwheader
;
311 u8
*firmware
= cardp
->fw
->data
;
313 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
318 fwheader
= &fwdata
->fwheader
;
320 if (!cardp
->CRC_OK
) {
321 cardp
->totalbytes
= cardp
->fwlastblksent
;
322 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
326 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
330 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
331 sizeof(struct fwheader
));
333 cardp
->fwlastblksent
= cardp
->totalbytes
;
334 cardp
->totalbytes
+= sizeof(struct fwheader
);
336 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
337 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
338 le32_to_cpu(fwdata
->fwheader
.datalength
));
341 lbs_deb_usbd(&cardp->udev->dev,
342 "Data length = %d\n", le32_to_cpu(fwdata->fwheader.datalength));
345 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
347 fwdata
->seqnum
= cpu_to_le32(cardp
->fwseqnum
);
348 cardp
->lastseqnum
= cardp
->fwseqnum
;
349 cardp
->totalbytes
+= le32_to_cpu(fwdata
->fwheader
.datalength
);
351 if (fwheader
->dnldcmd
== cpu_to_le32(FW_HAS_DATA_TO_RECV
)) {
353 lbs_deb_usbd(&cardp->udev->dev, "There are data to follow\n");
354 lbs_deb_usbd(&cardp->udev->dev,
355 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
358 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
359 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
361 } else if (fwdata
->fwheader
.dnldcmd
== cpu_to_le32(FW_HAS_LAST_BLOCK
)) {
363 lbs_deb_usbd(&cardp->udev->dev,
364 "Host has finished FW downloading\n");
365 lbs_deb_usbd(&cardp->udev->dev,
366 "Donwloading FW JUMP BLOCK\n");
368 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
369 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
370 cardp
->fwfinalblk
= 1;
374 lbs_deb_usbd(&cardp->udev->dev,
375 "The firmware download is done size is %d\n",
384 static int if_usb_reset_device(struct usb_card_rec
*cardp
)
387 lbs_private
* priv
= cardp
->priv
;
389 lbs_deb_enter(LBS_DEB_USB
);
391 /* Try a USB port reset first, if that fails send the reset
392 * command to the firmware.
394 ret
= usb_reset_device(cardp
->udev
);
397 ret
= lbs_reset_device(priv
);
401 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
407 * @brief This function transfer the data to the device.
408 * @param priv pointer to lbs_private
409 * @param payload pointer to payload data
410 * @param nb data length
413 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
* payload
, u16 nb
)
417 /* check if device is removed */
418 if (cardp
->surprise_removed
) {
419 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
423 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
424 usb_sndbulkpipe(cardp
->udev
,
425 cardp
->bulk_out_endpointAddr
),
426 payload
, nb
, if_usb_write_bulk_callback
, cardp
);
428 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
430 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
431 /* transfer failed */
432 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
435 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
443 static int __if_usb_submit_rx_urb(struct usb_card_rec
*cardp
,
444 void (*callbackfn
)(struct urb
*urb
))
447 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
450 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
451 lbs_pr_err("No free skb\n");
457 /* Fill the receive configuration URB and initialise the Rx call back */
458 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
459 usb_rcvbulkpipe(cardp
->udev
,
460 cardp
->bulk_in_endpointAddr
),
461 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
462 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
465 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
467 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
468 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
469 /* handle failure conditions */
470 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
473 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
481 static int if_usb_submit_rx_urb_fwload(struct usb_card_rec
*cardp
)
483 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive_fwload
);
486 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
)
488 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive
);
491 static void if_usb_receive_fwload(struct urb
*urb
)
493 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
494 struct sk_buff
*skb
= rinfo
->skb
;
495 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)rinfo
->cardp
;
496 struct fwsyncheader
*syncfwheader
;
497 struct bootcmdrespStr bootcmdresp
;
500 lbs_deb_usbd(&cardp
->udev
->dev
,
501 "URB status is failed during fw load\n");
506 if (cardp
->bootcmdresp
== 0) {
507 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
508 sizeof(bootcmdresp
));
509 if (le16_to_cpu(cardp
->udev
->descriptor
.bcdDevice
) < 0x3106) {
511 if_usb_submit_rx_urb_fwload(cardp
);
512 cardp
->bootcmdresp
= 1;
513 lbs_deb_usbd(&cardp
->udev
->dev
,
514 "Received valid boot command response\n");
517 if (bootcmdresp
.u32magicnumber
!= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
)) {
519 "boot cmd response wrong magic number (0x%x)\n",
520 le32_to_cpu(bootcmdresp
.u32magicnumber
));
521 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
523 "boot cmd response cmd_tag error (%d)\n",
524 bootcmdresp
.u8cmd_tag
);
525 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
527 "boot cmd response result error (%d)\n",
528 bootcmdresp
.u8result
);
530 cardp
->bootcmdresp
= 1;
531 lbs_deb_usbd(&cardp
->udev
->dev
,
532 "Received valid boot command response\n");
535 if_usb_submit_rx_urb_fwload(cardp
);
539 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
541 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
546 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
547 sizeof(struct fwsyncheader
));
549 if (!syncfwheader
->cmd
) {
551 lbs_deb_usbd(&cardp->udev->dev,
552 "FW received Blk with correct CRC\n");
553 lbs_deb_usbd(&cardp->udev->dev,
554 "FW received Blk seqnum = %d\n",
555 syncfwheader->seqnum);
559 lbs_deb_usbd(&cardp
->udev
->dev
,
560 "FW received Blk with CRC error\n");
566 if (cardp
->fwfinalblk
) {
567 cardp
->fwdnldover
= 1;
571 if_prog_firmware(cardp
);
573 if_usb_submit_rx_urb_fwload(cardp
);
581 #define MRVDRV_MIN_PKT_LEN 30
583 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
584 struct usb_card_rec
*cardp
,
587 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
588 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
589 lbs_deb_usbd(&cardp
->udev
->dev
,
590 "Packet length is Invalid\n");
595 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
596 skb_put(skb
, recvlength
);
597 skb_pull(skb
, MESSAGE_HEADER_LEN
);
598 lbs_process_rxed_packet(priv
, skb
);
599 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
602 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
604 struct usb_card_rec
*cardp
,
608 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
609 lbs_deb_usbd(&cardp
->udev
->dev
,
610 "The receive buffer is too large\n");
618 spin_lock(&priv
->adapter
->driver_lock
);
619 /* take care of cur_cmd = NULL case by reading the
620 * data to clear the interrupt */
621 if (!priv
->adapter
->cur_cmd
) {
622 cmdbuf
= priv
->upld_buf
;
623 priv
->adapter
->hisregcpy
&= ~MRVDRV_CMD_UPLD_RDY
;
625 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
627 cardp
->usb_int_cause
|= MRVDRV_CMD_UPLD_RDY
;
628 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
629 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
633 lbs_interrupt(priv
->dev
);
634 spin_unlock(&priv
->adapter
->driver_lock
);
636 lbs_deb_usbd(&cardp
->udev
->dev
,
637 "Wake up main thread to handle cmd response\n");
643 * @brief This function reads of the packet into the upload buff,
644 * wake up the main thread and initialise the Rx callack.
646 * @param urb pointer to struct urb
649 static void if_usb_receive(struct urb
*urb
)
651 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
652 struct sk_buff
*skb
= rinfo
->skb
;
653 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) rinfo
->cardp
;
654 lbs_private
* priv
= cardp
->priv
;
656 int recvlength
= urb
->actual_length
;
660 lbs_deb_enter(LBS_DEB_USB
);
666 lbs_deb_usbd(&cardp
->udev
->dev
,
667 "URB status is failed\n");
672 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
673 memcpy(&tmp
, recvbuff
, sizeof(u32
));
674 recvtype
= le32_to_cpu(tmp
);
675 lbs_deb_usbd(&cardp
->udev
->dev
,
676 "Recv length = 0x%x, Recv type = 0x%X\n",
677 recvlength
, recvtype
);
678 } else if (urb
->status
)
683 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
686 case CMD_TYPE_REQUEST
:
687 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
690 case CMD_TYPE_INDICATION
:
691 /* Event cause handling */
692 spin_lock(&priv
->adapter
->driver_lock
);
693 cardp
->usb_event_cause
= le32_to_cpu(*(__le32
*) (recvbuff
+ MESSAGE_HEADER_LEN
));
694 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
695 cardp
->usb_event_cause
);
696 if (cardp
->usb_event_cause
& 0xffff0000) {
697 lbs_send_tx_feedback(priv
);
698 spin_unlock(&priv
->adapter
->driver_lock
);
701 cardp
->usb_event_cause
<<= 3;
702 cardp
->usb_int_cause
|= MRVDRV_CARDEVENT
;
704 lbs_interrupt(priv
->dev
);
705 spin_unlock(&priv
->adapter
->driver_lock
);
708 lbs_deb_usbd(&cardp
->udev
->dev
, "Unknown command type 0x%X\n",
715 if_usb_submit_rx_urb(cardp
);
717 lbs_deb_leave(LBS_DEB_USB
);
721 * @brief This function downloads data to FW
722 * @param priv pointer to lbs_private structure
723 * @param type type of data
724 * @param buf pointer to data buffer
725 * @param len number of bytes
728 static int if_usb_host_to_card(lbs_private
*priv
, u8 type
, u8
*payload
, u16 nb
)
730 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
732 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
733 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
735 if (type
== MVMS_CMD
) {
736 __le32 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
737 priv
->dnld_sent
= DNLD_CMD_SENT
;
738 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
742 __le32 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
743 priv
->dnld_sent
= DNLD_DATA_SENT
;
744 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
748 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
750 return usb_tx_block(cardp
, cardp
->bulk_out_buffer
,
751 nb
+ MESSAGE_HEADER_LEN
);
754 /* called with adapter->driver_lock held */
755 static int if_usb_get_int_status(lbs_private
*priv
, u8
*ireg
)
757 struct usb_card_rec
*cardp
= priv
->card
;
759 *ireg
= cardp
->usb_int_cause
;
760 cardp
->usb_int_cause
= 0;
762 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
767 static int if_usb_read_event_cause(lbs_private
* priv
)
769 struct usb_card_rec
*cardp
= priv
->card
;
771 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
772 /* Re-submit rx urb here to avoid event lost issue */
773 if_usb_submit_rx_urb(cardp
);
778 * @brief This function issues Boot command to the Boot2 code
779 * @param ivalue 1:Boot from FW by USB-Download
780 * 2:Boot from FW in EEPROM
783 static int if_usb_issue_boot_command(struct usb_card_rec
*cardp
, int ivalue
)
785 struct bootcmdstr sbootcmd
;
788 /* Prepare command */
789 sbootcmd
.u32magicnumber
= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
);
790 sbootcmd
.u8cmd_tag
= ivalue
;
792 sbootcmd
.au8dumy
[i
]=0x00;
793 memcpy(cardp
->bulk_out_buffer
, &sbootcmd
, sizeof(struct bootcmdstr
));
796 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, sizeof(struct bootcmdstr
));
803 * @brief This function checks the validity of Boot2/FW image.
805 * @param data pointer to image
809 static int check_fwfile_format(u8
*data
, u32 totlen
)
812 u32 blksize
, offset
, len
;
819 struct fwheader
*fwh
= (void *)data
;
821 bincmd
= le32_to_cpu(fwh
->dnldcmd
);
822 blksize
= le32_to_cpu(fwh
->datalength
);
824 case FW_HAS_DATA_TO_RECV
:
825 offset
= sizeof(struct fwheader
) + blksize
;
831 case FW_HAS_LAST_BLOCK
:
842 lbs_pr_err("firmware file format check FAIL\n");
844 lbs_deb_fw("firmware file format check PASS\n");
850 static int if_usb_prog_firmware(struct usb_card_rec
*cardp
)
853 static int reset_count
= 10;
856 lbs_deb_enter(LBS_DEB_USB
);
858 if ((ret
= request_firmware(&cardp
->fw
, lbs_fw_name
,
859 &cardp
->udev
->dev
)) < 0) {
860 lbs_pr_err("request_firmware() failed with %#x\n", ret
);
861 lbs_pr_err("firmware %s not found\n", lbs_fw_name
);
865 if (check_fwfile_format(cardp
->fw
->data
, cardp
->fw
->size
))
869 if (if_usb_submit_rx_urb_fwload(cardp
) < 0) {
870 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
875 cardp
->bootcmdresp
= 0;
879 /* Issue Boot command = 1, Boot from Download-FW */
880 if_usb_issue_boot_command(cardp
, BOOT_CMD_FW_BY_USB
);
881 /* wait for command response */
884 msleep_interruptible(100);
885 } while (cardp
->bootcmdresp
== 0 && j
< 10);
886 } while (cardp
->bootcmdresp
== 0 && i
< 5);
888 if (cardp
->bootcmdresp
== 0) {
889 if (--reset_count
>= 0) {
890 if_usb_reset_device(cardp
);
898 cardp
->totalbytes
= 0;
899 cardp
->fwlastblksent
= 0;
901 cardp
->fwdnldover
= 0;
902 cardp
->fwseqnum
= -1;
903 cardp
->totalbytes
= 0;
904 cardp
->fwfinalblk
= 0;
906 if_prog_firmware(cardp
);
909 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
911 msleep_interruptible(100);
912 if (cardp
->surprise_removed
|| i
>= 20)
914 } while (!cardp
->fwdnldover
);
916 if (!cardp
->fwdnldover
) {
917 lbs_pr_info("failed to load fw, resetting device!\n");
918 if (--reset_count
>= 0) {
919 if_usb_reset_device(cardp
);
923 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
929 release_firmware(cardp
->fw
);
933 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
939 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
941 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
942 lbs_private
*priv
= cardp
->priv
;
944 lbs_deb_enter(LBS_DEB_USB
);
946 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
949 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
950 /* Mesh autostart must be activated while sleeping
951 * On resume it will go back to the current state
953 struct cmd_ds_mesh_access mesh_access
;
954 memset(&mesh_access
, 0, sizeof(mesh_access
));
955 mesh_access
.data
[0] = cpu_to_le32(1);
956 lbs_prepare_and_send_command(priv
,
958 CMD_ACT_MESH_SET_AUTOSTART_ENABLED
,
959 CMD_OPTION_WAITFORRSP
, 0, (void *)&mesh_access
);
962 netif_device_detach(cardp
->eth_dev
);
963 netif_device_detach(priv
->mesh_dev
);
965 /* Unlink tx & rx urb */
966 usb_kill_urb(cardp
->tx_urb
);
967 usb_kill_urb(cardp
->rx_urb
);
969 cardp
->rx_urb_recall
= 1;
971 lbs_deb_leave(LBS_DEB_USB
);
975 static int if_usb_resume(struct usb_interface
*intf
)
977 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
978 lbs_private
*priv
= cardp
->priv
;
980 lbs_deb_enter(LBS_DEB_USB
);
982 cardp
->rx_urb_recall
= 0;
984 if_usb_submit_rx_urb(cardp
->priv
);
986 netif_device_attach(cardp
->eth_dev
);
987 netif_device_attach(priv
->mesh_dev
);
989 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
990 /* Mesh autostart was activated while sleeping
991 * Disable it if appropriate
993 struct cmd_ds_mesh_access mesh_access
;
994 memset(&mesh_access
, 0, sizeof(mesh_access
));
995 mesh_access
.data
[0] = cpu_to_le32(0);
996 lbs_prepare_and_send_command(priv
,
998 CMD_ACT_MESH_SET_AUTOSTART_ENABLED
,
999 CMD_OPTION_WAITFORRSP
, 0, (void *)&mesh_access
);
1002 lbs_deb_leave(LBS_DEB_USB
);
1006 #define if_usb_suspend NULL
1007 #define if_usb_resume NULL
1010 static struct usb_driver if_usb_driver
= {
1012 .name
= usbdriver_name
,
1013 /* probe function name */
1014 .probe
= if_usb_probe
,
1015 /* disconnect function name */
1016 .disconnect
= if_usb_disconnect
,
1017 /* device signature table */
1018 .id_table
= if_usb_table
,
1019 .suspend
= if_usb_suspend
,
1020 .resume
= if_usb_resume
,
1023 static int if_usb_init_module(void)
1027 lbs_deb_enter(LBS_DEB_MAIN
);
1029 ret
= usb_register(&if_usb_driver
);
1031 lbs_deb_leave_args(LBS_DEB_MAIN
, "ret %d", ret
);
1035 static void if_usb_exit_module(void)
1037 struct usb_card_rec
*cardp
, *cardp_temp
;
1039 lbs_deb_enter(LBS_DEB_MAIN
);
1041 list_for_each_entry_safe(cardp
, cardp_temp
, &usb_devices
, list
) {
1042 lbs_prepare_and_send_command(cardp
->priv
, CMD_802_11_RESET
,
1043 CMD_ACT_HALT
, 0, 0, NULL
);
1046 /* API unregisters the driver from USB subsystem */
1047 usb_deregister(&if_usb_driver
);
1049 lbs_deb_leave(LBS_DEB_MAIN
);
1052 module_init(if_usb_init_module
);
1053 module_exit(if_usb_exit_module
);
1055 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1056 MODULE_AUTHOR("Marvell International Ltd.");
1057 MODULE_LICENSE("GPL");