2 * This file contains functions used in USB interface module.
4 #include <linux/delay.h>
5 #include <linux/firmware.h>
6 #include <linux/netdevice.h>
16 #define MESSAGE_HEADER_LEN 4
18 static const char usbdriver_name
[] = "usb8xxx";
20 static struct usb_device_id if_usb_table
[] = {
21 /* Enter the device signature inside */
22 { USB_DEVICE(0x1286, 0x2001) },
23 { USB_DEVICE(0x05a3, 0x8388) },
24 {} /* Terminating entry */
27 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
29 static void if_usb_receive(struct urb
*urb
);
30 static void if_usb_receive_fwload(struct urb
*urb
);
33 * @brief call back function to handle the status of the URB
34 * @param urb pointer to urb structure
37 static void if_usb_write_bulk_callback(struct urb
*urb
)
39 wlan_private
*priv
= (wlan_private
*) (urb
->context
);
40 wlan_adapter
*adapter
= priv
->adapter
;
41 struct net_device
*dev
= priv
->wlan_dev
.netdev
;
43 /* handle the transmission complete validations */
45 if (urb
->status
!= 0) {
46 /* print the failure status number for debug */
47 lbs_pr_info("URB in failure status\n");
50 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
51 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
54 priv
->wlan_dev
.dnld_sent
= DNLD_RES_RECEIVED
;
55 /* Wake main thread if commands are pending */
56 if (!adapter
->cur_cmd
)
57 wake_up_interruptible(&priv
->mainthread
.waitq
);
58 if ((adapter
->connect_status
== libertas_connected
))
59 netif_wake_queue(dev
);
66 * @brief free tx/rx urb, skb and rx buffer
67 * @param cardp pointer usb_card_rec
70 void if_usb_free(struct usb_card_rec
*cardp
)
72 lbs_deb_enter(LBS_DEB_USB
);
74 /* Unlink tx & rx urb */
75 usb_kill_urb(cardp
->tx_urb
);
76 usb_kill_urb(cardp
->rx_urb
);
78 usb_free_urb(cardp
->tx_urb
);
81 usb_free_urb(cardp
->rx_urb
);
84 kfree(cardp
->bulk_out_buffer
);
85 cardp
->bulk_out_buffer
= NULL
;
87 lbs_deb_leave(LBS_DEB_USB
);
91 * @brief sets the configuration values
92 * @param ifnum interface number
93 * @param id pointer to usb_device_id
94 * @return 0 on success, error code on failure
96 static int if_usb_probe(struct usb_interface
*intf
,
97 const struct usb_device_id
*id
)
99 struct usb_device
*udev
;
100 struct usb_host_interface
*iface_desc
;
101 struct usb_endpoint_descriptor
*endpoint
;
103 struct usb_card_rec
*usb_cardp
;
106 udev
= interface_to_usbdev(intf
);
108 usb_cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
110 lbs_pr_err("Out of memory allocating private data.\n");
114 usb_cardp
->udev
= udev
;
115 iface_desc
= intf
->cur_altsetting
;
117 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
118 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
119 udev
->descriptor
.bcdUSB
,
120 udev
->descriptor
.bDeviceClass
,
121 udev
->descriptor
.bDeviceSubClass
,
122 udev
->descriptor
.bDeviceProtocol
);
124 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
125 endpoint
= &iface_desc
->endpoint
[i
].desc
;
126 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
127 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
128 USB_ENDPOINT_XFER_BULK
)) {
129 /* we found a bulk in endpoint */
130 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
131 endpoint
->wMaxPacketSize
);
134 usb_alloc_urb(0, GFP_KERNEL
))) {
135 lbs_deb_usbd(&udev
->dev
,
136 "Rx URB allocation failed\n");
139 usb_cardp
->rx_urb_recall
= 0;
141 usb_cardp
->bulk_in_size
=
142 endpoint
->wMaxPacketSize
;
143 usb_cardp
->bulk_in_endpointAddr
=
145 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
146 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
147 endpoint
->bEndpointAddress
);
151 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
153 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
154 USB_ENDPOINT_XFER_BULK
)) {
155 /* We found bulk out endpoint */
158 usb_alloc_urb(0, GFP_KERNEL
))) {
159 lbs_deb_usbd(&udev
->dev
,
160 "Tx URB allocation failed\n");
164 usb_cardp
->bulk_out_size
=
165 endpoint
->wMaxPacketSize
;
166 lbs_deb_usbd(&udev
->dev
,
167 "Bulk out size is %d\n",
168 endpoint
->wMaxPacketSize
);
169 usb_cardp
->bulk_out_endpointAddr
=
170 endpoint
->bEndpointAddress
;
171 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
172 endpoint
->bEndpointAddress
);
173 usb_cardp
->bulk_out_buffer
=
174 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
177 if (!usb_cardp
->bulk_out_buffer
) {
178 lbs_deb_usbd(&udev
->dev
,
179 "Could not allocate buffer\n");
186 /* At this point wlan_add_card() will be called. Don't worry
187 * about keeping pwlanpriv around since it will be set on our
188 * usb device data in -> add() -> libertas_sbi_register_dev().
190 if (!(priv
= wlan_add_card(usb_cardp
)))
192 if (wlan_add_mesh(priv
))
196 usb_set_intfdata(intf
, usb_cardp
);
199 * return card structure, which can be got back in the
200 * diconnect function as the ptr
206 if_usb_free(usb_cardp
);
213 * @brief free resource and cleanup
214 * @param udev pointer to usb_device
215 * @param ptr pointer to usb_cardp
218 static void if_usb_disconnect(struct usb_interface
*intf
)
220 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
221 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
222 wlan_adapter
*adapter
= NULL
;
224 adapter
= priv
->adapter
;
227 * Update Surprise removed to TRUE
229 adapter
->surpriseremoved
= 1;
231 /* card is removed and we can call wlan_remove_card */
232 lbs_deb_usbd(&cardp
->udev
->dev
, "call remove card\n");
233 wlan_remove_mesh(priv
);
234 wlan_remove_card(priv
);
236 /* Unlink and free urb */
239 usb_set_intfdata(intf
, NULL
);
240 usb_put_dev(interface_to_usbdev(intf
));
246 * @brief This function download FW
247 * @param priv pointer to wlan_private
250 static int if_prog_firmware(wlan_private
* priv
)
252 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
253 struct FWData
*fwdata
;
254 struct fwheader
*fwheader
;
255 u8
*firmware
= priv
->firmware
->data
;
257 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
262 fwheader
= &fwdata
->fwheader
;
264 if (!cardp
->CRC_OK
) {
265 cardp
->totalbytes
= cardp
->fwlastblksent
;
266 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
270 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
274 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
275 sizeof(struct fwheader
));
277 cardp
->fwlastblksent
= cardp
->totalbytes
;
278 cardp
->totalbytes
+= sizeof(struct fwheader
);
280 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
281 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
282 fwdata
->fwheader
.datalength
);
285 lbs_deb_usbd(&cardp->udev->dev,
286 "Data length = %d\n", fwdata->fwheader.datalength);
289 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
291 fwdata
->seqnum
= cardp
->fwseqnum
;
292 cardp
->lastseqnum
= fwdata
->seqnum
;
293 cardp
->totalbytes
+= fwdata
->fwheader
.datalength
;
295 if (fwheader
->dnldcmd
== FW_HAS_DATA_TO_RECV
) {
297 lbs_deb_usbd(&cardp->udev->dev, "There is data to follow\n");
298 lbs_deb_usbd(&cardp->udev->dev,
299 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
302 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
303 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
305 } else if (fwdata
->fwheader
.dnldcmd
== FW_HAS_LAST_BLOCK
) {
307 lbs_deb_usbd(&cardp->udev->dev,
308 "Host has finished FW downloading\n");
309 lbs_deb_usbd(&cardp->udev->dev,
310 "Donwloading FW JUMP BLOCK\n");
312 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
313 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
314 cardp
->fwfinalblk
= 1;
318 lbs_deb_usbd(&cardp->udev->dev,
319 "The firmware download is done size is %d\n",
328 static int libertas_do_reset(wlan_private
*priv
)
331 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
333 ret
= usb_reset_device(cardp
->udev
);
343 * @brief This function transfer the data to the device.
344 * @param priv pointer to wlan_private
345 * @param payload pointer to payload data
346 * @param nb data length
349 int usb_tx_block(wlan_private
* priv
, u8
* payload
, u16 nb
)
351 /* pointer to card structure */
352 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
355 /* check if device is removed */
356 if (priv
->adapter
->surpriseremoved
) {
357 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
361 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
362 usb_sndbulkpipe(cardp
->udev
,
363 cardp
->bulk_out_endpointAddr
),
364 payload
, nb
, if_usb_write_bulk_callback
, priv
);
366 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
368 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
369 /* transfer failed */
370 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
373 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
381 static int __if_usb_submit_rx_urb(wlan_private
* priv
,
385 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
387 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
390 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
391 lbs_pr_err("No free skb\n");
397 /* Fill the receive configuration URB and initialise the Rx call back */
398 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
399 usb_rcvbulkpipe(cardp
->udev
,
400 cardp
->bulk_in_endpointAddr
),
401 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
402 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
405 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
407 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
408 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
409 /* handle failure conditions */
410 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
413 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
421 static inline int if_usb_submit_rx_urb_fwload(wlan_private
* priv
)
423 return __if_usb_submit_rx_urb(priv
, &if_usb_receive_fwload
);
426 static inline int if_usb_submit_rx_urb(wlan_private
* priv
)
428 return __if_usb_submit_rx_urb(priv
, &if_usb_receive
);
431 static void if_usb_receive_fwload(struct urb
*urb
)
433 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
434 wlan_private
*priv
= rinfo
->priv
;
435 struct sk_buff
*skb
= rinfo
->skb
;
436 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
437 struct fwsyncheader
*syncfwheader
;
438 struct bootcmdrespStr bootcmdresp
;
441 lbs_deb_usbd(&cardp
->udev
->dev
,
442 "URB status is failed during fw load\n");
447 if (cardp
->bootcmdresp
== 0) {
448 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
449 sizeof(bootcmdresp
));
450 if (cardp
->udev
->descriptor
.bcdDevice
< 0x3106) {
452 if_usb_submit_rx_urb_fwload(priv
);
453 cardp
->bootcmdresp
= 1;
454 lbs_deb_usbd(&cardp
->udev
->dev
,
455 "Received valid boot command response\n");
458 if (bootcmdresp
.u32magicnumber
!= BOOT_CMD_MAGIC_NUMBER
) {
460 "boot cmd response wrong magic number (0x%x)\n",
461 bootcmdresp
.u32magicnumber
);
462 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
464 "boot cmd response cmd_tag error (%d)\n",
465 bootcmdresp
.u8cmd_tag
);
466 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
468 "boot cmd response result error (%d)\n",
469 bootcmdresp
.u8result
);
471 cardp
->bootcmdresp
= 1;
472 lbs_deb_usbd(&cardp
->udev
->dev
,
473 "Received valid boot command response\n");
476 if_usb_submit_rx_urb_fwload(priv
);
480 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
482 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
487 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
488 sizeof(struct fwsyncheader
));
490 if (!syncfwheader
->cmd
) {
492 lbs_deb_usbd(&cardp->udev->dev,
493 "FW received Blk with correct CRC\n");
494 lbs_deb_usbd(&cardp->udev->dev,
495 "FW received Blk seqnum = %d\n",
496 syncfwheader->seqnum);
500 lbs_deb_usbd(&cardp
->udev
->dev
,
501 "FW received Blk with CRC error\n");
507 if (cardp
->fwfinalblk
) {
508 cardp
->fwdnldover
= 1;
512 if_prog_firmware(priv
);
514 if_usb_submit_rx_urb_fwload(priv
);
522 #define MRVDRV_MIN_PKT_LEN 30
524 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
525 struct usb_card_rec
*cardp
,
528 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
529 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
530 lbs_deb_usbd(&cardp
->udev
->dev
,
531 "Packet length is Invalid\n");
536 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
537 skb_put(skb
, recvlength
);
538 skb_pull(skb
, MESSAGE_HEADER_LEN
);
539 libertas_process_rxed_packet(priv
, skb
);
540 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
543 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
545 struct usb_card_rec
*cardp
,
549 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
550 lbs_deb_usbd(&cardp
->udev
->dev
,
551 "The receive buffer is too large\n");
559 spin_lock(&priv
->adapter
->driver_lock
);
560 /* take care of cur_cmd = NULL case by reading the
561 * data to clear the interrupt */
562 if (!priv
->adapter
->cur_cmd
) {
563 cmdbuf
= priv
->wlan_dev
.upld_buf
;
564 priv
->adapter
->hisregcpy
&= ~his_cmdupldrdy
;
566 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
568 cardp
->usb_int_cause
|= his_cmdupldrdy
;
569 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
570 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
571 priv
->wlan_dev
.upld_len
);
574 libertas_interrupt(priv
->wlan_dev
.netdev
);
575 spin_unlock(&priv
->adapter
->driver_lock
);
577 lbs_deb_usbd(&cardp
->udev
->dev
,
578 "Wake up main thread to handle cmd response\n");
584 * @brief This function reads of the packet into the upload buff,
585 * wake up the main thread and initialise the Rx callack.
587 * @param urb pointer to struct urb
590 static void if_usb_receive(struct urb
*urb
)
592 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
593 wlan_private
*priv
= rinfo
->priv
;
594 struct sk_buff
*skb
= rinfo
->skb
;
595 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
597 int recvlength
= urb
->actual_length
;
601 lbs_deb_enter(LBS_DEB_USB
);
605 lbs_deb_usbd(&cardp
->udev
->dev
,
606 "URB status is failed\n");
611 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
612 memcpy(&recvtype
, recvbuff
, sizeof(u32
));
613 lbs_deb_usbd(&cardp
->udev
->dev
,
614 "Recv length = 0x%x\n", recvlength
);
615 lbs_deb_usbd(&cardp
->udev
->dev
,
616 "Receive type = 0x%X\n", recvtype
);
617 recvtype
= le32_to_cpu(recvtype
);
618 lbs_deb_usbd(&cardp
->udev
->dev
,
619 "Receive type after = 0x%X\n", recvtype
);
620 } else if (urb
->status
)
626 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
629 case CMD_TYPE_REQUEST
:
630 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
633 case CMD_TYPE_INDICATION
:
634 /* Event cause handling */
635 spin_lock(&priv
->adapter
->driver_lock
);
636 cardp
->usb_event_cause
= *(u32
*) (recvbuff
+ MESSAGE_HEADER_LEN
);
637 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
638 cardp
->usb_event_cause
);
639 if (cardp
->usb_event_cause
& 0xffff0000) {
640 libertas_send_tx_feedback(priv
);
641 spin_unlock(&priv
->adapter
->driver_lock
);
644 cardp
->usb_event_cause
= le32_to_cpu(cardp
->usb_event_cause
) << 3;
645 cardp
->usb_int_cause
|= his_cardevent
;
647 libertas_interrupt(priv
->wlan_dev
.netdev
);
648 spin_unlock(&priv
->adapter
->driver_lock
);
656 if_usb_submit_rx_urb(priv
);
658 lbs_deb_leave(LBS_DEB_USB
);
662 * @brief This function downloads data to FW
663 * @param priv pointer to wlan_private structure
664 * @param type type of data
665 * @param buf pointer to data buffer
666 * @param len number of bytes
669 int libertas_sbi_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
673 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
675 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
676 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
678 if (type
== MVMS_CMD
) {
679 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
680 priv
->wlan_dev
.dnld_sent
= DNLD_CMD_SENT
;
681 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
685 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
686 priv
->wlan_dev
.dnld_sent
= DNLD_DATA_SENT
;
687 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
691 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
694 usb_tx_block(priv
, cardp
->bulk_out_buffer
, nb
+ MESSAGE_HEADER_LEN
);
699 /* called with adapter->driver_lock held */
700 int libertas_sbi_get_int_status(wlan_private
* priv
, u8
* ireg
)
702 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
704 *ireg
= cardp
->usb_int_cause
;
705 cardp
->usb_int_cause
= 0;
707 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
712 int libertas_sbi_read_event_cause(wlan_private
* priv
)
714 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
715 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
716 /* Re-submit rx urb here to avoid event lost issue */
717 if_usb_submit_rx_urb(priv
);
721 int reset_device(wlan_private
*priv
)
725 ret
= libertas_prepare_and_send_command(priv
, cmd_802_11_reset
,
726 cmd_act_halt
, 0, 0, NULL
);
727 msleep_interruptible(10);
732 int libertas_sbi_unregister_dev(wlan_private
* priv
)
736 /* Need to send a Reset command to device before USB resources freed
737 * and wlan_remove_card() called, then device can handle FW download
748 * @brief This function register usb device and initialize parameter
749 * @param priv pointer to wlan_private
752 int libertas_sbi_register_dev(wlan_private
* priv
)
754 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
756 lbs_deb_enter(LBS_DEB_USB
);
759 cardp
->eth_dev
= priv
->wlan_dev
.netdev
;
760 priv
->hotplug_device
= &(cardp
->udev
->dev
);
762 SET_NETDEV_DEV(cardp
->eth_dev
, &(cardp
->udev
->dev
));
764 lbs_deb_usbd(&cardp
->udev
->dev
, "udev pointer is at %p\n",
767 lbs_deb_leave(LBS_DEB_USB
);
773 int libertas_sbi_prog_firmware(wlan_private
* priv
)
775 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
777 static int reset_count
= 10;
780 lbs_deb_enter(LBS_DEB_USB
);
782 cardp
->rinfo
.priv
= priv
;
785 if (if_usb_submit_rx_urb_fwload(priv
) < 0) {
786 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
791 cardp
->bootcmdresp
= 0;
795 /* Issue Boot command = 1, Boot from Download-FW */
796 if_usb_issue_boot_command(priv
, BOOT_CMD_FW_BY_USB
);
797 /* wait for command response */
800 msleep_interruptible(100);
801 } while (cardp
->bootcmdresp
== 0 && j
< 10);
802 } while (cardp
->bootcmdresp
== 0 && i
< 5);
804 if (cardp
->bootcmdresp
== 0) {
805 if (--reset_count
>= 0) {
806 libertas_do_reset(priv
);
813 priv
->adapter
->fw_ready
= 0;
815 cardp
->totalbytes
= 0;
816 cardp
->fwlastblksent
= 0;
818 cardp
->fwdnldover
= 0;
819 cardp
->fwseqnum
= -1;
820 cardp
->totalbytes
= 0;
821 cardp
->fwfinalblk
= 0;
823 if_prog_firmware(priv
);
826 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
828 msleep_interruptible(100);
829 if (priv
->adapter
->surpriseremoved
|| i
>= 20)
831 } while (!cardp
->fwdnldover
);
833 if (!cardp
->fwdnldover
) {
834 lbs_pr_info("failed to load fw, resetting device!\n");
835 if (--reset_count
>= 0) {
836 libertas_do_reset(priv
);
840 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
845 if_usb_submit_rx_urb(priv
);
847 /* Delay 200 ms to waiting for the FW ready */
848 msleep_interruptible(200);
850 priv
->adapter
->fw_ready
= 1;
853 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
858 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
860 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
861 wlan_private
*priv
= cardp
->priv
;
863 lbs_deb_enter(LBS_DEB_USB
);
865 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
868 netif_device_detach(cardp
->eth_dev
);
870 /* Unlink tx & rx urb */
871 usb_kill_urb(cardp
->tx_urb
);
872 usb_kill_urb(cardp
->rx_urb
);
874 cardp
->rx_urb_recall
= 1;
876 lbs_deb_leave(LBS_DEB_USB
);
880 static int if_usb_resume(struct usb_interface
*intf
)
882 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
884 lbs_deb_enter(LBS_DEB_USB
);
886 cardp
->rx_urb_recall
= 0;
888 if_usb_submit_rx_urb(cardp
->priv
);
890 netif_device_attach(cardp
->eth_dev
);
892 lbs_deb_leave(LBS_DEB_USB
);
896 #define if_usb_suspend NULL
897 #define if_usb_resume NULL
900 static struct usb_driver if_usb_driver
= {
902 .name
= usbdriver_name
,
903 /* probe function name */
904 .probe
= if_usb_probe
,
905 /* disconnect function name */
906 .disconnect
= if_usb_disconnect
,
907 /* device signature table */
908 .id_table
= if_usb_table
,
909 .suspend
= if_usb_suspend
,
910 .resume
= if_usb_resume
,
914 * @brief This function registers driver.
915 * @param add pointer to add_card callback function
916 * @param remove pointer to remove card callback function
917 * @param arg pointer to call back function parameter
918 * @return dummy success variable
920 int libertas_sbi_register(void)
923 * API registers the Marvell USB driver
926 usb_register(&if_usb_driver
);
928 /* Return success to wlan layer */
933 * @brief This function removes usb driver.
936 void libertas_sbi_unregister(void)
938 /* API unregisters the driver from USB subsystem */
939 usb_deregister(&if_usb_driver
);