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");
49 lbs_dev_dbg(2, &urb
->dev
->dev
, "URB status is successfull\n");
50 lbs_dev_dbg(2, &urb
->dev
->dev
, "Actual length transmitted %d\n",
52 priv
->wlan_dev
.dnld_sent
= DNLD_RES_RECEIVED
;
53 /* Wake main thread if commands are pending */
54 if (!adapter
->cur_cmd
)
55 wake_up_interruptible(&priv
->mainthread
.waitq
);
56 if ((adapter
->connect_status
== libertas_connected
))
57 netif_wake_queue(dev
);
64 * @brief free tx/rx urb, skb and rx buffer
65 * @param cardp pointer usb_card_rec
68 void if_usb_free(struct usb_card_rec
*cardp
)
72 /* Unlink tx & rx urb */
73 usb_kill_urb(cardp
->tx_urb
);
74 usb_kill_urb(cardp
->rx_urb
);
76 usb_free_urb(cardp
->tx_urb
);
79 usb_free_urb(cardp
->rx_urb
);
82 kfree(cardp
->bulk_out_buffer
);
83 cardp
->bulk_out_buffer
= NULL
;
90 * @brief sets the configuration values
91 * @param ifnum interface number
92 * @param id pointer to usb_device_id
93 * @return 0 on success, error code on failure
95 static int if_usb_probe(struct usb_interface
*intf
,
96 const struct usb_device_id
*id
)
98 struct usb_device
*udev
;
99 struct usb_host_interface
*iface_desc
;
100 struct usb_endpoint_descriptor
*endpoint
;
101 wlan_private
*pwlanpriv
;
102 struct usb_card_rec
*usb_cardp
;
105 udev
= interface_to_usbdev(intf
);
107 usb_cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
109 lbs_pr_err("Out of memory allocating private data.\n");
113 usb_cardp
->udev
= udev
;
114 iface_desc
= intf
->cur_altsetting
;
116 lbs_dev_dbg(1, &udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
117 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
118 udev
->descriptor
.bcdUSB
,
119 udev
->descriptor
.bDeviceClass
,
120 udev
->descriptor
.bDeviceSubClass
,
121 udev
->descriptor
.bDeviceProtocol
);
123 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
124 endpoint
= &iface_desc
->endpoint
[i
].desc
;
125 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
126 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
127 USB_ENDPOINT_XFER_BULK
)) {
128 /* we found a bulk in endpoint */
129 lbs_dev_dbg(1, &udev
->dev
, "Bulk in size is %d\n",
130 endpoint
->wMaxPacketSize
);
133 usb_alloc_urb(0, GFP_KERNEL
))) {
134 lbs_dev_dbg(1, &udev
->dev
,
135 "Rx URB allocation failed\n");
138 usb_cardp
->rx_urb_recall
= 0;
140 usb_cardp
->bulk_in_size
=
141 endpoint
->wMaxPacketSize
;
142 usb_cardp
->bulk_in_endpointAddr
=
144 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
145 lbs_dev_dbg(1, &udev
->dev
, "in_endpoint = %d\n",
146 endpoint
->bEndpointAddress
);
150 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
152 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
153 USB_ENDPOINT_XFER_BULK
)) {
154 /* We found bulk out endpoint */
157 usb_alloc_urb(0, GFP_KERNEL
))) {
158 lbs_dev_dbg(1,&udev
->dev
,
159 "Tx URB allocation failed\n");
163 usb_cardp
->bulk_out_size
=
164 endpoint
->wMaxPacketSize
;
165 lbs_dev_dbg(1, &udev
->dev
,
166 "Bulk out size is %d\n",
167 endpoint
->wMaxPacketSize
);
168 usb_cardp
->bulk_out_endpointAddr
=
169 endpoint
->bEndpointAddress
;
170 lbs_dev_dbg(1, &udev
->dev
, "out_endpoint = %d\n",
171 endpoint
->bEndpointAddress
);
172 usb_cardp
->bulk_out_buffer
=
173 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
176 if (!usb_cardp
->bulk_out_buffer
) {
177 lbs_dev_dbg(1, &udev
->dev
,
178 "Could not allocate buffer\n");
185 /* At this point wlan_add_card() will be called. Don't worry
186 * about keeping pwlanpriv around since it will be set on our
187 * usb device data in -> add() -> libertas_sbi_register_dev().
189 if (!(pwlanpriv
= wlan_add_card(usb_cardp
)))
193 usb_set_intfdata(intf
, usb_cardp
);
196 * return card structure, which can be got back in the
197 * diconnect function as the ptr
203 if_usb_free(usb_cardp
);
210 * @brief free resource and cleanup
211 * @param udev pointer to usb_device
212 * @param ptr pointer to usb_cardp
215 static void if_usb_disconnect(struct usb_interface
*intf
)
217 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
218 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
219 wlan_adapter
*adapter
= NULL
;
221 adapter
= priv
->adapter
;
224 * Update Surprise removed to TRUE
226 adapter
->surpriseremoved
= 1;
228 /* card is removed and we can call wlan_remove_card */
229 lbs_dev_dbg(1, &cardp
->udev
->dev
, "call remove card\n");
230 wlan_remove_card(cardp
);
232 /* Unlink and free urb */
235 usb_set_intfdata(intf
, NULL
);
236 usb_put_dev(interface_to_usbdev(intf
));
242 * @brief This function download FW
243 * @param priv pointer to wlan_private
246 static int if_prog_firmware(wlan_private
* priv
)
248 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
249 struct FWData
*fwdata
;
250 struct fwheader
*fwheader
;
251 u8
*firmware
= priv
->firmware
->data
;
253 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
258 fwheader
= &fwdata
->fwheader
;
260 if (!cardp
->CRC_OK
) {
261 cardp
->totalbytes
= cardp
->fwlastblksent
;
262 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
265 lbs_dev_dbg(2, &cardp
->udev
->dev
, "totalbytes = %d\n",
268 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
269 sizeof(struct fwheader
));
271 cardp
->fwlastblksent
= cardp
->totalbytes
;
272 cardp
->totalbytes
+= sizeof(struct fwheader
);
274 lbs_dev_dbg(2, &cardp
->udev
->dev
,"Copy Data\n");
275 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
276 fwdata
->fwheader
.datalength
);
278 lbs_dev_dbg(2, &cardp
->udev
->dev
,
279 "Data length = %d\n", fwdata
->fwheader
.datalength
);
281 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
283 fwdata
->seqnum
= cardp
->fwseqnum
;
284 cardp
->lastseqnum
= fwdata
->seqnum
;
285 cardp
->totalbytes
+= fwdata
->fwheader
.datalength
;
287 if (fwheader
->dnldcmd
== FW_HAS_DATA_TO_RECV
) {
288 lbs_dev_dbg(2, &cardp
->udev
->dev
, "There is data to follow\n");
289 lbs_dev_dbg(2, &cardp
->udev
->dev
,
290 "seqnum = %d totalbytes = %d\n", cardp
->fwseqnum
,
292 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
293 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
295 } else if (fwdata
->fwheader
.dnldcmd
== FW_HAS_LAST_BLOCK
) {
296 lbs_dev_dbg(2, &cardp
->udev
->dev
,
297 "Host has finished FW downloading\n");
298 lbs_dev_dbg(2, &cardp
->udev
->dev
,
299 "Donwloading FW JUMP BLOCK\n");
300 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
301 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
302 cardp
->fwfinalblk
= 1;
305 lbs_dev_dbg(2, &cardp
->udev
->dev
,
306 "The firmware download is done size is %d\n",
314 static int libertas_do_reset(wlan_private
*priv
)
317 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
319 ret
= usb_reset_device(cardp
->udev
);
329 * @brief This function transfer the data to the device.
330 * @param priv pointer to wlan_private
331 * @param payload pointer to payload data
332 * @param nb data length
335 int usb_tx_block(wlan_private
* priv
, u8
* payload
, u16 nb
)
337 /* pointer to card structure */
338 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
341 /* check if device is removed */
342 if (priv
->adapter
->surpriseremoved
) {
343 lbs_dev_dbg(1, &cardp
->udev
->dev
, "Device removed\n");
347 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
348 usb_sndbulkpipe(cardp
->udev
,
349 cardp
->bulk_out_endpointAddr
),
350 payload
, nb
, if_usb_write_bulk_callback
, priv
);
352 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
354 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
355 /* transfer failed */
356 lbs_dev_dbg(1, &cardp
->udev
->dev
, "usb_submit_urb failed\n");
359 lbs_dev_dbg(2, &cardp
->udev
->dev
, "usb_submit_urb success\n");
367 static int __if_usb_submit_rx_urb(wlan_private
* priv
,
371 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
373 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
376 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
377 lbs_pr_err("No free skb\n");
383 /* Fill the receive configuration URB and initialise the Rx call back */
384 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
385 usb_rcvbulkpipe(cardp
->udev
,
386 cardp
->bulk_in_endpointAddr
),
387 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
388 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
391 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
393 lbs_dev_dbg(2, &cardp
->udev
->dev
, "Pointer for rx_urb %p\n", cardp
->rx_urb
);
394 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
395 /* handle failure conditions */
396 lbs_dev_dbg(1, &cardp
->udev
->dev
, "Submit Rx URB failed\n");
399 lbs_dev_dbg(2, &cardp
->udev
->dev
, "Submit Rx URB success\n");
407 static inline int if_usb_submit_rx_urb_fwload(wlan_private
* priv
)
409 return __if_usb_submit_rx_urb(priv
, &if_usb_receive_fwload
);
412 static inline int if_usb_submit_rx_urb(wlan_private
* priv
)
414 return __if_usb_submit_rx_urb(priv
, &if_usb_receive
);
417 static void if_usb_receive_fwload(struct urb
*urb
)
419 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
420 wlan_private
*priv
= rinfo
->priv
;
421 struct sk_buff
*skb
= rinfo
->skb
;
422 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
423 struct fwsyncheader
*syncfwheader
;
424 struct bootcmdrespStr bootcmdresp
;
427 lbs_dev_dbg(1, &cardp
->udev
->dev
,
428 "URB status is failed during fw load\n");
433 if (cardp
->bootcmdresp
== 0) {
434 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
435 sizeof(bootcmdresp
));
436 if (cardp
->udev
->descriptor
.bcdDevice
< 0x3106) {
438 if_usb_submit_rx_urb_fwload(priv
);
439 cardp
->bootcmdresp
= 1;
440 lbs_dev_dbg(1, &cardp
->udev
->dev
,
441 "Received valid boot command response\n");
444 if (bootcmdresp
.u32magicnumber
!= BOOT_CMD_MAGIC_NUMBER
) {
446 "boot cmd response wrong magic number (0x%x)\n",
447 bootcmdresp
.u32magicnumber
);
448 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
450 "boot cmd response cmd_tag error (%d)\n",
451 bootcmdresp
.u8cmd_tag
);
452 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
454 "boot cmd response result error (%d)\n",
455 bootcmdresp
.u8result
);
457 cardp
->bootcmdresp
= 1;
458 lbs_dev_dbg(1, &cardp
->udev
->dev
,
459 "Received valid boot command response\n");
462 if_usb_submit_rx_urb_fwload(priv
);
466 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
468 lbs_dev_dbg(1, &cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
473 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
474 sizeof(struct fwsyncheader
));
476 if (!syncfwheader
->cmd
) {
477 lbs_dev_dbg(2, &cardp
->udev
->dev
,
478 "FW received Blk with correct CRC\n");
479 lbs_dev_dbg(2, &cardp
->udev
->dev
,
480 "FW received Blk seqnum = %d\n",
481 syncfwheader
->seqnum
);
484 lbs_dev_dbg(1, &cardp
->udev
->dev
,
485 "FW received Blk with CRC error\n");
491 if (cardp
->fwfinalblk
) {
492 cardp
->fwdnldover
= 1;
496 if_prog_firmware(priv
);
498 if_usb_submit_rx_urb_fwload(priv
);
506 #define MRVDRV_MIN_PKT_LEN 30
508 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
509 struct usb_card_rec
*cardp
,
512 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
513 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
514 lbs_dev_dbg(1, &cardp
->udev
->dev
,
515 "Packet length is Invalid\n");
520 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
521 skb_put(skb
, recvlength
);
522 skb_pull(skb
, MESSAGE_HEADER_LEN
);
523 libertas_process_rxed_packet(priv
, skb
);
524 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
527 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
529 struct usb_card_rec
*cardp
,
533 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
534 lbs_dev_dbg(1, &cardp
->udev
->dev
,
535 "The receive buffer is too large\n");
543 spin_lock(&priv
->adapter
->driver_lock
);
544 /* take care of cur_cmd = NULL case by reading the
545 * data to clear the interrupt */
546 if (!priv
->adapter
->cur_cmd
) {
547 cmdbuf
= priv
->wlan_dev
.upld_buf
;
548 priv
->adapter
->hisregcpy
&= ~his_cmdupldrdy
;
550 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
552 cardp
->usb_int_cause
|= his_cmdupldrdy
;
553 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
554 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
555 priv
->wlan_dev
.upld_len
);
558 libertas_interrupt(priv
->wlan_dev
.netdev
);
559 spin_unlock(&priv
->adapter
->driver_lock
);
561 lbs_dev_dbg(1, &cardp
->udev
->dev
,
562 "Wake up main thread to handle cmd response\n");
568 * @brief This function reads of the packet into the upload buff,
569 * wake up the main thread and initialise the Rx callack.
571 * @param urb pointer to struct urb
574 static void if_usb_receive(struct urb
*urb
)
576 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
577 wlan_private
*priv
= rinfo
->priv
;
578 struct sk_buff
*skb
= rinfo
->skb
;
579 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
581 int recvlength
= urb
->actual_length
;
589 lbs_dev_dbg(1, &cardp
->udev
->dev
,
590 "URB status is failed\n");
595 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
596 memcpy(&recvtype
, recvbuff
, sizeof(u32
));
597 lbs_dev_dbg(1, &cardp
->udev
->dev
,
598 "Recv length = 0x%x\n", recvlength
);
599 lbs_dev_dbg(1, &cardp
->udev
->dev
,
600 "Receive type = 0x%X\n", recvtype
);
601 recvtype
= le32_to_cpu(recvtype
);
602 lbs_dev_dbg(1, &cardp
->udev
->dev
,
603 "Receive type after = 0x%X\n", recvtype
);
604 } else if (urb
->status
)
610 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
613 case CMD_TYPE_REQUEST
:
614 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
617 case CMD_TYPE_INDICATION
:
618 /* Event cause handling */
619 spin_lock(&priv
->adapter
->driver_lock
);
620 cardp
->usb_event_cause
= *(u32
*) (recvbuff
+ MESSAGE_HEADER_LEN
);
621 lbs_dev_dbg(1, &cardp
->udev
->dev
,"**EVENT** 0x%X\n",
622 cardp
->usb_event_cause
);
623 if (cardp
->usb_event_cause
& 0xffff0000) {
624 libertas_send_tx_feedback(priv
);
625 spin_unlock(&priv
->adapter
->driver_lock
);
628 cardp
->usb_event_cause
= le32_to_cpu(cardp
->usb_event_cause
) << 3;
629 cardp
->usb_int_cause
|= his_cardevent
;
631 libertas_interrupt(priv
->wlan_dev
.netdev
);
632 spin_unlock(&priv
->adapter
->driver_lock
);
640 if_usb_submit_rx_urb(priv
);
647 * @brief This function downloads data to FW
648 * @param priv pointer to wlan_private structure
649 * @param type type of data
650 * @param buf pointer to data buffer
651 * @param len number of bytes
654 int libertas_sbi_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
658 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
660 lbs_dev_dbg(1, &cardp
->udev
->dev
,"*** type = %u\n", type
);
661 lbs_dev_dbg(1, &cardp
->udev
->dev
,"size after = %d\n", nb
);
663 if (type
== MVMS_CMD
) {
664 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
665 priv
->wlan_dev
.dnld_sent
= DNLD_CMD_SENT
;
666 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
670 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
671 priv
->wlan_dev
.dnld_sent
= DNLD_DATA_SENT
;
672 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
676 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
679 usb_tx_block(priv
, cardp
->bulk_out_buffer
, nb
+ MESSAGE_HEADER_LEN
);
684 /* called with adapter->driver_lock held */
685 int libertas_sbi_get_int_status(wlan_private
* priv
, u8
* ireg
)
687 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
689 *ireg
= cardp
->usb_int_cause
;
690 cardp
->usb_int_cause
= 0;
692 lbs_dev_dbg(1, &cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
697 int libertas_sbi_read_event_cause(wlan_private
* priv
)
699 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
700 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
701 /* Re-submit rx urb here to avoid event lost issue */
702 if_usb_submit_rx_urb(priv
);
706 int reset_device(wlan_private
*priv
)
710 ret
= libertas_prepare_and_send_command(priv
, cmd_802_11_reset
,
711 cmd_act_halt
, 0, 0, NULL
);
712 msleep_interruptible(10);
717 int libertas_sbi_unregister_dev(wlan_private
* priv
)
721 /* Need to send a Reset command to device before USB resources freed
722 * and wlan_remove_card() called, then device can handle FW download
733 * @brief This function register usb device and initialize parameter
734 * @param priv pointer to wlan_private
737 int libertas_sbi_register_dev(wlan_private
* priv
)
740 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
744 cardp
->eth_dev
= priv
->wlan_dev
.netdev
;
745 priv
->hotplug_device
= &(cardp
->udev
->dev
);
747 SET_NETDEV_DEV(cardp
->eth_dev
, &(cardp
->udev
->dev
));
749 lbs_dev_dbg(1, &cardp
->udev
->dev
, "udev pointer is at %p\n",
758 int libertas_sbi_prog_firmware(wlan_private
* priv
)
760 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
762 static int reset_count
= 10;
766 cardp
->rinfo
.priv
= priv
;
769 if (if_usb_submit_rx_urb_fwload(priv
) < 0) {
770 lbs_dev_dbg(1, &cardp
->udev
->dev
, "URB submission is failed\n");
775 cardp
->bootcmdresp
= 0;
779 /* Issue Boot command = 1, Boot from Download-FW */
780 if_usb_issue_boot_command(priv
, BOOT_CMD_FW_BY_USB
);
781 /* wait for command response */
784 msleep_interruptible(100);
785 } while (cardp
->bootcmdresp
== 0 && j
< 10);
786 } while (cardp
->bootcmdresp
== 0 && i
< 5);
788 if (cardp
->bootcmdresp
== 0) {
789 if (--reset_count
>= 0) {
790 libertas_do_reset(priv
);
797 priv
->adapter
->fw_ready
= 0;
799 cardp
->totalbytes
= 0;
800 cardp
->fwlastblksent
= 0;
802 cardp
->fwdnldover
= 0;
803 cardp
->fwseqnum
= -1;
804 cardp
->totalbytes
= 0;
805 cardp
->fwfinalblk
= 0;
807 if_prog_firmware(priv
);
810 lbs_dev_dbg(1, &cardp
->udev
->dev
,"Wlan sched timeout\n");
812 msleep_interruptible(100);
813 if (priv
->adapter
->surpriseremoved
|| i
>= 20)
815 } while (!cardp
->fwdnldover
);
817 if (!cardp
->fwdnldover
) {
818 lbs_pr_info("failed to load fw, resetting device!\n");
819 if (--reset_count
>= 0) {
820 libertas_do_reset(priv
);
824 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
829 if_usb_submit_rx_urb(priv
);
831 /* Delay 200 ms to waiting for the FW ready */
832 msleep_interruptible(200);
834 priv
->adapter
->fw_ready
= 1;
841 * @brief Given a usb_card_rec return its wlan_private
842 * @param card pointer to a usb_card_rec
843 * @return pointer to wlan_private
845 wlan_private
*libertas_sbi_get_priv(void *card
)
847 struct usb_card_rec
*cardp
= card
;
852 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
854 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
855 wlan_private
*priv
= cardp
->priv
;
859 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
862 netif_device_detach(cardp
->eth_dev
);
864 /* Unlink tx & rx urb */
865 usb_kill_urb(cardp
->tx_urb
);
866 usb_kill_urb(cardp
->rx_urb
);
868 cardp
->rx_urb_recall
= 1;
874 static int if_usb_resume(struct usb_interface
*intf
)
876 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
880 cardp
->rx_urb_recall
= 0;
882 if_usb_submit_rx_urb(cardp
->priv
);
884 netif_device_attach(cardp
->eth_dev
);
890 #define if_usb_suspend NULL
891 #define if_usb_resume NULL
894 static struct usb_driver if_usb_driver
= {
896 .name
= usbdriver_name
,
897 /* probe function name */
898 .probe
= if_usb_probe
,
899 /* disconnect function name */
900 .disconnect
= if_usb_disconnect
,
901 /* device signature table */
902 .id_table
= if_usb_table
,
903 .suspend
= if_usb_suspend
,
904 .resume
= if_usb_resume
,
908 * @brief This function registers driver.
909 * @param add pointer to add_card callback function
910 * @param remove pointer to remove card callback function
911 * @param arg pointer to call back function parameter
912 * @return dummy success variable
914 int libertas_sbi_register(void)
917 * API registers the Marvell USB driver
920 usb_register(&if_usb_driver
);
922 /* Return success to wlan layer */
927 * @brief This function removes usb driver.
930 void libertas_sbi_unregister(void)
932 /* API unregisters the driver from USB subsystem */
933 usb_deregister(&if_usb_driver
);