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";
21 static struct net_device
*libertas_devs
[MAX_DEVS
];
22 static int libertas_found
= 0;
24 static struct usb_device_id if_usb_table
[] = {
25 /* Enter the device signature inside */
26 { USB_DEVICE(0x1286, 0x2001) },
27 { USB_DEVICE(0x05a3, 0x8388) },
28 {} /* Terminating entry */
31 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
33 static void if_usb_receive(struct urb
*urb
);
34 static void if_usb_receive_fwload(struct urb
*urb
);
35 static int reset_device(wlan_private
*priv
);
38 * @brief call back function to handle the status of the URB
39 * @param urb pointer to urb structure
42 static void if_usb_write_bulk_callback(struct urb
*urb
)
44 wlan_private
*priv
= (wlan_private
*) (urb
->context
);
45 wlan_adapter
*adapter
= priv
->adapter
;
46 struct net_device
*dev
= priv
->wlan_dev
.netdev
;
48 /* handle the transmission complete validations */
50 if (urb
->status
!= 0) {
51 /* print the failure status number for debug */
52 lbs_pr_info("URB in failure status\n");
55 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
56 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
59 priv
->wlan_dev
.dnld_sent
= DNLD_RES_RECEIVED
;
60 /* Wake main thread if commands are pending */
61 if (!adapter
->cur_cmd
)
62 wake_up_interruptible(&priv
->mainthread
.waitq
);
63 if ((adapter
->connect_status
== libertas_connected
))
64 netif_wake_queue(dev
);
71 * @brief free tx/rx urb, skb and rx buffer
72 * @param cardp pointer usb_card_rec
75 void if_usb_free(struct usb_card_rec
*cardp
)
77 lbs_deb_enter(LBS_DEB_USB
);
79 /* Unlink tx & rx urb */
80 usb_kill_urb(cardp
->tx_urb
);
81 usb_kill_urb(cardp
->rx_urb
);
83 usb_free_urb(cardp
->tx_urb
);
86 usb_free_urb(cardp
->rx_urb
);
89 kfree(cardp
->bulk_out_buffer
);
90 cardp
->bulk_out_buffer
= NULL
;
92 lbs_deb_leave(LBS_DEB_USB
);
96 * @brief sets the configuration values
97 * @param ifnum interface number
98 * @param id pointer to usb_device_id
99 * @return 0 on success, error code on failure
101 static int if_usb_probe(struct usb_interface
*intf
,
102 const struct usb_device_id
*id
)
104 struct usb_device
*udev
;
105 struct usb_host_interface
*iface_desc
;
106 struct usb_endpoint_descriptor
*endpoint
;
108 struct usb_card_rec
*usb_cardp
;
111 udev
= interface_to_usbdev(intf
);
113 usb_cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
115 lbs_pr_err("Out of memory allocating private data.\n");
119 usb_cardp
->udev
= udev
;
120 iface_desc
= intf
->cur_altsetting
;
122 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
123 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
124 udev
->descriptor
.bcdUSB
,
125 udev
->descriptor
.bDeviceClass
,
126 udev
->descriptor
.bDeviceSubClass
,
127 udev
->descriptor
.bDeviceProtocol
);
129 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
130 endpoint
= &iface_desc
->endpoint
[i
].desc
;
131 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
132 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
133 USB_ENDPOINT_XFER_BULK
)) {
134 /* we found a bulk in endpoint */
135 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
136 endpoint
->wMaxPacketSize
);
139 usb_alloc_urb(0, GFP_KERNEL
))) {
140 lbs_deb_usbd(&udev
->dev
,
141 "Rx URB allocation failed\n");
144 usb_cardp
->rx_urb_recall
= 0;
146 usb_cardp
->bulk_in_size
=
147 endpoint
->wMaxPacketSize
;
148 usb_cardp
->bulk_in_endpointAddr
=
150 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
151 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
152 endpoint
->bEndpointAddress
);
156 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
158 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
159 USB_ENDPOINT_XFER_BULK
)) {
160 /* We found bulk out endpoint */
163 usb_alloc_urb(0, GFP_KERNEL
))) {
164 lbs_deb_usbd(&udev
->dev
,
165 "Tx URB allocation failed\n");
169 usb_cardp
->bulk_out_size
=
170 endpoint
->wMaxPacketSize
;
171 lbs_deb_usbd(&udev
->dev
,
172 "Bulk out size is %d\n",
173 endpoint
->wMaxPacketSize
);
174 usb_cardp
->bulk_out_endpointAddr
=
175 endpoint
->bEndpointAddress
;
176 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
177 endpoint
->bEndpointAddress
);
178 usb_cardp
->bulk_out_buffer
=
179 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
182 if (!usb_cardp
->bulk_out_buffer
) {
183 lbs_deb_usbd(&udev
->dev
,
184 "Could not allocate buffer\n");
191 /* At this point wlan_add_card() will be called. Don't worry
192 * about keeping pwlanpriv around since it will be set on our
193 * usb device data in -> add() -> libertas_sbi_register_dev().
195 if (!(priv
= wlan_add_card(usb_cardp
)))
198 if (libertas_activate_card(priv
))
201 if (libertas_found
< MAX_DEVS
) {
202 libertas_devs
[libertas_found
] = priv
->wlan_dev
.netdev
;
206 if (wlan_add_mesh(priv
))
210 usb_set_intfdata(intf
, usb_cardp
);
213 * return card structure, which can be got back in the
214 * diconnect function as the ptr
220 if_usb_free(usb_cardp
);
227 * @brief free resource and cleanup
228 * @param udev pointer to usb_device
229 * @param ptr pointer to usb_cardp
232 static void if_usb_disconnect(struct usb_interface
*intf
)
234 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
235 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
236 wlan_adapter
*adapter
= NULL
;
239 adapter
= priv
->adapter
;
242 * Update Surprise removed to TRUE
244 adapter
->surpriseremoved
= 1;
246 for (i
= 0; i
<libertas_found
; i
++) {
247 if (libertas_devs
[i
]==priv
->wlan_dev
.netdev
) {
248 libertas_devs
[i
] = libertas_devs
[--libertas_found
];
249 libertas_devs
[libertas_found
] = NULL
;
254 /* card is removed and we can call wlan_remove_card */
255 lbs_deb_usbd(&cardp
->udev
->dev
, "call remove card\n");
256 wlan_remove_mesh(priv
);
257 wlan_remove_card(priv
);
259 /* Unlink and free urb */
262 usb_set_intfdata(intf
, NULL
);
263 usb_put_dev(interface_to_usbdev(intf
));
269 * @brief This function download FW
270 * @param priv pointer to wlan_private
273 static int if_prog_firmware(wlan_private
* priv
)
275 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
276 struct FWData
*fwdata
;
277 struct fwheader
*fwheader
;
278 u8
*firmware
= priv
->firmware
->data
;
280 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
285 fwheader
= &fwdata
->fwheader
;
287 if (!cardp
->CRC_OK
) {
288 cardp
->totalbytes
= cardp
->fwlastblksent
;
289 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
293 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
297 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
298 sizeof(struct fwheader
));
300 cardp
->fwlastblksent
= cardp
->totalbytes
;
301 cardp
->totalbytes
+= sizeof(struct fwheader
);
303 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
304 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
305 fwdata
->fwheader
.datalength
);
308 lbs_deb_usbd(&cardp->udev->dev,
309 "Data length = %d\n", fwdata->fwheader.datalength);
312 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
314 fwdata
->seqnum
= cardp
->fwseqnum
;
315 cardp
->lastseqnum
= fwdata
->seqnum
;
316 cardp
->totalbytes
+= fwdata
->fwheader
.datalength
;
318 if (fwheader
->dnldcmd
== FW_HAS_DATA_TO_RECV
) {
320 lbs_deb_usbd(&cardp->udev->dev, "There is data to follow\n");
321 lbs_deb_usbd(&cardp->udev->dev,
322 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
325 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
326 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
328 } else if (fwdata
->fwheader
.dnldcmd
== FW_HAS_LAST_BLOCK
) {
330 lbs_deb_usbd(&cardp->udev->dev,
331 "Host has finished FW downloading\n");
332 lbs_deb_usbd(&cardp->udev->dev,
333 "Donwloading FW JUMP BLOCK\n");
335 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
336 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
337 cardp
->fwfinalblk
= 1;
341 lbs_deb_usbd(&cardp->udev->dev,
342 "The firmware download is done size is %d\n",
351 static int libertas_do_reset(wlan_private
*priv
)
354 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
356 lbs_deb_enter(LBS_DEB_USB
);
358 ret
= usb_reset_device(cardp
->udev
);
365 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
371 * @brief This function transfer the data to the device.
372 * @param priv pointer to wlan_private
373 * @param payload pointer to payload data
374 * @param nb data length
377 int usb_tx_block(wlan_private
* priv
, u8
* payload
, u16 nb
)
379 /* pointer to card structure */
380 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
383 /* check if device is removed */
384 if (priv
->adapter
->surpriseremoved
) {
385 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
389 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
390 usb_sndbulkpipe(cardp
->udev
,
391 cardp
->bulk_out_endpointAddr
),
392 payload
, nb
, if_usb_write_bulk_callback
, priv
);
394 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
396 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
397 /* transfer failed */
398 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
401 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
409 static int __if_usb_submit_rx_urb(wlan_private
* priv
,
413 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
415 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
418 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
419 lbs_pr_err("No free skb\n");
425 /* Fill the receive configuration URB and initialise the Rx call back */
426 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
427 usb_rcvbulkpipe(cardp
->udev
,
428 cardp
->bulk_in_endpointAddr
),
429 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
430 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
433 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
435 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
436 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
437 /* handle failure conditions */
438 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
441 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
449 static inline int if_usb_submit_rx_urb_fwload(wlan_private
* priv
)
451 return __if_usb_submit_rx_urb(priv
, &if_usb_receive_fwload
);
454 static inline int if_usb_submit_rx_urb(wlan_private
* priv
)
456 return __if_usb_submit_rx_urb(priv
, &if_usb_receive
);
459 static void if_usb_receive_fwload(struct urb
*urb
)
461 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
462 wlan_private
*priv
= rinfo
->priv
;
463 struct sk_buff
*skb
= rinfo
->skb
;
464 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
465 struct fwsyncheader
*syncfwheader
;
466 struct bootcmdrespStr bootcmdresp
;
469 lbs_deb_usbd(&cardp
->udev
->dev
,
470 "URB status is failed during fw load\n");
475 if (cardp
->bootcmdresp
== 0) {
476 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
477 sizeof(bootcmdresp
));
478 if (cardp
->udev
->descriptor
.bcdDevice
< 0x3106) {
480 if_usb_submit_rx_urb_fwload(priv
);
481 cardp
->bootcmdresp
= 1;
482 lbs_deb_usbd(&cardp
->udev
->dev
,
483 "Received valid boot command response\n");
486 if (bootcmdresp
.u32magicnumber
!= BOOT_CMD_MAGIC_NUMBER
) {
488 "boot cmd response wrong magic number (0x%x)\n",
489 bootcmdresp
.u32magicnumber
);
490 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
492 "boot cmd response cmd_tag error (%d)\n",
493 bootcmdresp
.u8cmd_tag
);
494 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
496 "boot cmd response result error (%d)\n",
497 bootcmdresp
.u8result
);
499 cardp
->bootcmdresp
= 1;
500 lbs_deb_usbd(&cardp
->udev
->dev
,
501 "Received valid boot command response\n");
504 if_usb_submit_rx_urb_fwload(priv
);
508 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
510 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
515 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
516 sizeof(struct fwsyncheader
));
518 if (!syncfwheader
->cmd
) {
520 lbs_deb_usbd(&cardp->udev->dev,
521 "FW received Blk with correct CRC\n");
522 lbs_deb_usbd(&cardp->udev->dev,
523 "FW received Blk seqnum = %d\n",
524 syncfwheader->seqnum);
528 lbs_deb_usbd(&cardp
->udev
->dev
,
529 "FW received Blk with CRC error\n");
535 if (cardp
->fwfinalblk
) {
536 cardp
->fwdnldover
= 1;
540 if_prog_firmware(priv
);
542 if_usb_submit_rx_urb_fwload(priv
);
550 #define MRVDRV_MIN_PKT_LEN 30
552 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
553 struct usb_card_rec
*cardp
,
556 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
557 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
558 lbs_deb_usbd(&cardp
->udev
->dev
,
559 "Packet length is Invalid\n");
564 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
565 skb_put(skb
, recvlength
);
566 skb_pull(skb
, MESSAGE_HEADER_LEN
);
567 libertas_process_rxed_packet(priv
, skb
);
568 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
571 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
573 struct usb_card_rec
*cardp
,
577 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
578 lbs_deb_usbd(&cardp
->udev
->dev
,
579 "The receive buffer is too large\n");
587 spin_lock(&priv
->adapter
->driver_lock
);
588 /* take care of cur_cmd = NULL case by reading the
589 * data to clear the interrupt */
590 if (!priv
->adapter
->cur_cmd
) {
591 cmdbuf
= priv
->wlan_dev
.upld_buf
;
592 priv
->adapter
->hisregcpy
&= ~his_cmdupldrdy
;
594 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
596 cardp
->usb_int_cause
|= his_cmdupldrdy
;
597 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
598 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
599 priv
->wlan_dev
.upld_len
);
602 libertas_interrupt(priv
->wlan_dev
.netdev
);
603 spin_unlock(&priv
->adapter
->driver_lock
);
605 lbs_deb_usbd(&cardp
->udev
->dev
,
606 "Wake up main thread to handle cmd response\n");
612 * @brief This function reads of the packet into the upload buff,
613 * wake up the main thread and initialise the Rx callack.
615 * @param urb pointer to struct urb
618 static void if_usb_receive(struct urb
*urb
)
620 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
621 wlan_private
*priv
= rinfo
->priv
;
622 struct sk_buff
*skb
= rinfo
->skb
;
623 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
625 int recvlength
= urb
->actual_length
;
629 lbs_deb_enter(LBS_DEB_USB
);
633 lbs_deb_usbd(&cardp
->udev
->dev
,
634 "URB status is failed\n");
639 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
640 memcpy(&recvtype
, recvbuff
, sizeof(u32
));
641 lbs_deb_usbd(&cardp
->udev
->dev
,
642 "Recv length = 0x%x\n", recvlength
);
643 lbs_deb_usbd(&cardp
->udev
->dev
,
644 "Receive type = 0x%X\n", recvtype
);
645 recvtype
= le32_to_cpu(recvtype
);
646 lbs_deb_usbd(&cardp
->udev
->dev
,
647 "Receive type after = 0x%X\n", recvtype
);
648 } else if (urb
->status
)
654 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
657 case CMD_TYPE_REQUEST
:
658 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
661 case CMD_TYPE_INDICATION
:
662 /* Event cause handling */
663 spin_lock(&priv
->adapter
->driver_lock
);
664 cardp
->usb_event_cause
= *(u32
*) (recvbuff
+ MESSAGE_HEADER_LEN
);
665 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
666 cardp
->usb_event_cause
);
667 if (cardp
->usb_event_cause
& 0xffff0000) {
668 libertas_send_tx_feedback(priv
);
669 spin_unlock(&priv
->adapter
->driver_lock
);
672 cardp
->usb_event_cause
= le32_to_cpu(cardp
->usb_event_cause
) << 3;
673 cardp
->usb_int_cause
|= his_cardevent
;
675 libertas_interrupt(priv
->wlan_dev
.netdev
);
676 spin_unlock(&priv
->adapter
->driver_lock
);
684 if_usb_submit_rx_urb(priv
);
686 lbs_deb_leave(LBS_DEB_USB
);
690 * @brief This function downloads data to FW
691 * @param priv pointer to wlan_private structure
692 * @param type type of data
693 * @param buf pointer to data buffer
694 * @param len number of bytes
697 int libertas_sbi_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
701 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
703 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
704 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
706 if (type
== MVMS_CMD
) {
707 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
708 priv
->wlan_dev
.dnld_sent
= DNLD_CMD_SENT
;
709 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
713 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
714 priv
->wlan_dev
.dnld_sent
= DNLD_DATA_SENT
;
715 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
719 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
722 usb_tx_block(priv
, cardp
->bulk_out_buffer
, nb
+ MESSAGE_HEADER_LEN
);
727 /* called with adapter->driver_lock held */
728 int libertas_sbi_get_int_status(wlan_private
* priv
, u8
* ireg
)
730 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
732 *ireg
= cardp
->usb_int_cause
;
733 cardp
->usb_int_cause
= 0;
735 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
740 int libertas_sbi_read_event_cause(wlan_private
* priv
)
742 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
743 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
744 /* Re-submit rx urb here to avoid event lost issue */
745 if_usb_submit_rx_urb(priv
);
749 static int reset_device(wlan_private
*priv
)
753 lbs_deb_enter(LBS_DEB_USB
);
754 ret
= libertas_prepare_and_send_command(priv
, cmd_802_11_reset
,
755 cmd_act_halt
, 0, 0, NULL
);
756 msleep_interruptible(10);
758 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
762 int libertas_sbi_unregister_dev(wlan_private
* priv
)
766 /* Need to send a Reset command to device before USB resources freed
767 * and wlan_remove_card() called, then device can handle FW download
778 * @brief This function register usb device and initialize parameter
779 * @param priv pointer to wlan_private
782 int libertas_sbi_register_dev(wlan_private
* priv
)
784 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
786 lbs_deb_enter(LBS_DEB_USB
);
789 cardp
->eth_dev
= priv
->wlan_dev
.netdev
;
790 priv
->hotplug_device
= &(cardp
->udev
->dev
);
792 SET_NETDEV_DEV(cardp
->eth_dev
, &(cardp
->udev
->dev
));
794 lbs_deb_usbd(&cardp
->udev
->dev
, "udev pointer is at %p\n",
797 lbs_deb_leave(LBS_DEB_USB
);
803 int libertas_sbi_prog_firmware(wlan_private
* priv
)
805 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
807 static int reset_count
= 10;
810 lbs_deb_enter(LBS_DEB_USB
);
812 cardp
->rinfo
.priv
= priv
;
815 if (if_usb_submit_rx_urb_fwload(priv
) < 0) {
816 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
821 cardp
->bootcmdresp
= 0;
825 /* Issue Boot command = 1, Boot from Download-FW */
826 if_usb_issue_boot_command(priv
, BOOT_CMD_FW_BY_USB
);
827 /* wait for command response */
830 msleep_interruptible(100);
831 } while (cardp
->bootcmdresp
== 0 && j
< 10);
832 } while (cardp
->bootcmdresp
== 0 && i
< 5);
834 if (cardp
->bootcmdresp
== 0) {
835 if (--reset_count
>= 0) {
836 libertas_do_reset(priv
);
843 priv
->adapter
->fw_ready
= 0;
845 cardp
->totalbytes
= 0;
846 cardp
->fwlastblksent
= 0;
848 cardp
->fwdnldover
= 0;
849 cardp
->fwseqnum
= -1;
850 cardp
->totalbytes
= 0;
851 cardp
->fwfinalblk
= 0;
853 if_prog_firmware(priv
);
856 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
858 msleep_interruptible(100);
859 if (priv
->adapter
->surpriseremoved
|| i
>= 20)
861 } while (!cardp
->fwdnldover
);
863 if (!cardp
->fwdnldover
) {
864 lbs_pr_info("failed to load fw, resetting device!\n");
865 if (--reset_count
>= 0) {
866 libertas_do_reset(priv
);
870 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
875 if_usb_submit_rx_urb(priv
);
877 /* Delay 200 ms to waiting for the FW ready */
878 msleep_interruptible(200);
880 priv
->adapter
->fw_ready
= 1;
883 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
888 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
890 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
891 wlan_private
*priv
= cardp
->priv
;
893 lbs_deb_enter(LBS_DEB_USB
);
895 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
898 netif_device_detach(cardp
->eth_dev
);
900 /* Unlink tx & rx urb */
901 usb_kill_urb(cardp
->tx_urb
);
902 usb_kill_urb(cardp
->rx_urb
);
904 cardp
->rx_urb_recall
= 1;
906 lbs_deb_leave(LBS_DEB_USB
);
910 static int if_usb_resume(struct usb_interface
*intf
)
912 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
914 lbs_deb_enter(LBS_DEB_USB
);
916 cardp
->rx_urb_recall
= 0;
918 if_usb_submit_rx_urb(cardp
->priv
);
920 netif_device_attach(cardp
->eth_dev
);
922 lbs_deb_leave(LBS_DEB_USB
);
926 #define if_usb_suspend NULL
927 #define if_usb_resume NULL
930 static struct usb_driver if_usb_driver
= {
932 .name
= usbdriver_name
,
933 /* probe function name */
934 .probe
= if_usb_probe
,
935 /* disconnect function name */
936 .disconnect
= if_usb_disconnect
,
937 /* device signature table */
938 .id_table
= if_usb_table
,
939 .suspend
= if_usb_suspend
,
940 .resume
= if_usb_resume
,
944 * @brief This function registers driver.
945 * @param add pointer to add_card callback function
946 * @param remove pointer to remove card callback function
947 * @param arg pointer to call back function parameter
948 * @return dummy success variable
950 int libertas_sbi_register(void)
953 * API registers the Marvell USB driver
956 usb_register(&if_usb_driver
);
958 /* Return success to wlan layer */
963 * @brief This function removes usb driver.
966 void libertas_sbi_unregister(void)
970 for (i
= 0; i
<libertas_found
; i
++) {
971 wlan_private
*priv
= libertas_devs
[i
]->priv
;
975 /* API unregisters the driver from USB subsystem */
976 usb_deregister(&if_usb_driver
);