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
);
65 netif_wake_queue(priv
->mesh_dev
);
73 * @brief free tx/rx urb, skb and rx buffer
74 * @param cardp pointer usb_card_rec
77 void if_usb_free(struct usb_card_rec
*cardp
)
79 lbs_deb_enter(LBS_DEB_USB
);
81 /* Unlink tx & rx urb */
82 usb_kill_urb(cardp
->tx_urb
);
83 usb_kill_urb(cardp
->rx_urb
);
85 usb_free_urb(cardp
->tx_urb
);
88 usb_free_urb(cardp
->rx_urb
);
91 kfree(cardp
->bulk_out_buffer
);
92 cardp
->bulk_out_buffer
= NULL
;
94 lbs_deb_leave(LBS_DEB_USB
);
98 * @brief sets the configuration values
99 * @param ifnum interface number
100 * @param id pointer to usb_device_id
101 * @return 0 on success, error code on failure
103 static int if_usb_probe(struct usb_interface
*intf
,
104 const struct usb_device_id
*id
)
106 struct usb_device
*udev
;
107 struct usb_host_interface
*iface_desc
;
108 struct usb_endpoint_descriptor
*endpoint
;
110 struct usb_card_rec
*usb_cardp
;
113 udev
= interface_to_usbdev(intf
);
115 usb_cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
117 lbs_pr_err("Out of memory allocating private data.\n");
121 usb_cardp
->udev
= udev
;
122 iface_desc
= intf
->cur_altsetting
;
124 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
125 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
126 udev
->descriptor
.bcdUSB
,
127 udev
->descriptor
.bDeviceClass
,
128 udev
->descriptor
.bDeviceSubClass
,
129 udev
->descriptor
.bDeviceProtocol
);
131 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
132 endpoint
= &iface_desc
->endpoint
[i
].desc
;
133 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
134 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
135 USB_ENDPOINT_XFER_BULK
)) {
136 /* we found a bulk in endpoint */
137 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
138 endpoint
->wMaxPacketSize
);
141 usb_alloc_urb(0, GFP_KERNEL
))) {
142 lbs_deb_usbd(&udev
->dev
,
143 "Rx URB allocation failed\n");
146 usb_cardp
->rx_urb_recall
= 0;
148 usb_cardp
->bulk_in_size
=
149 endpoint
->wMaxPacketSize
;
150 usb_cardp
->bulk_in_endpointAddr
=
152 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
153 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
154 endpoint
->bEndpointAddress
);
158 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
160 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
161 USB_ENDPOINT_XFER_BULK
)) {
162 /* We found bulk out endpoint */
165 usb_alloc_urb(0, GFP_KERNEL
))) {
166 lbs_deb_usbd(&udev
->dev
,
167 "Tx URB allocation failed\n");
171 usb_cardp
->bulk_out_size
=
172 endpoint
->wMaxPacketSize
;
173 lbs_deb_usbd(&udev
->dev
,
174 "Bulk out size is %d\n",
175 endpoint
->wMaxPacketSize
);
176 usb_cardp
->bulk_out_endpointAddr
=
177 endpoint
->bEndpointAddress
;
178 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
179 endpoint
->bEndpointAddress
);
180 usb_cardp
->bulk_out_buffer
=
181 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
184 if (!usb_cardp
->bulk_out_buffer
) {
185 lbs_deb_usbd(&udev
->dev
,
186 "Could not allocate buffer\n");
193 /* At this point wlan_add_card() will be called. Don't worry
194 * about keeping pwlanpriv around since it will be set on our
195 * usb device data in -> add() -> libertas_sbi_register_dev().
197 if (!(priv
= wlan_add_card(usb_cardp
)))
200 if (wlan_add_mesh(priv
))
203 if (libertas_activate_card(priv
))
206 if (libertas_found
< MAX_DEVS
) {
207 libertas_devs
[libertas_found
] = priv
->wlan_dev
.netdev
;
212 usb_set_intfdata(intf
, usb_cardp
);
215 * return card structure, which can be got back in the
216 * diconnect function as the ptr
222 if_usb_free(usb_cardp
);
229 * @brief free resource and cleanup
230 * @param udev pointer to usb_device
231 * @param ptr pointer to usb_cardp
234 static void if_usb_disconnect(struct usb_interface
*intf
)
236 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
237 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
238 wlan_adapter
*adapter
= NULL
;
241 adapter
= priv
->adapter
;
244 * Update Surprise removed to TRUE
246 adapter
->surpriseremoved
= 1;
248 for (i
= 0; i
<libertas_found
; i
++) {
249 if (libertas_devs
[i
]==priv
->wlan_dev
.netdev
) {
250 libertas_devs
[i
] = libertas_devs
[--libertas_found
];
251 libertas_devs
[libertas_found
] = NULL
;
256 /* card is removed and we can call wlan_remove_card */
257 lbs_deb_usbd(&cardp
->udev
->dev
, "call remove card\n");
258 wlan_remove_mesh(priv
);
259 wlan_remove_card(priv
);
261 /* Unlink and free urb */
264 usb_set_intfdata(intf
, NULL
);
265 usb_put_dev(interface_to_usbdev(intf
));
271 * @brief This function download FW
272 * @param priv pointer to wlan_private
275 static int if_prog_firmware(wlan_private
* priv
)
277 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
278 struct FWData
*fwdata
;
279 struct fwheader
*fwheader
;
280 u8
*firmware
= priv
->firmware
->data
;
282 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
287 fwheader
= &fwdata
->fwheader
;
289 if (!cardp
->CRC_OK
) {
290 cardp
->totalbytes
= cardp
->fwlastblksent
;
291 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
295 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
299 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
300 sizeof(struct fwheader
));
302 cardp
->fwlastblksent
= cardp
->totalbytes
;
303 cardp
->totalbytes
+= sizeof(struct fwheader
);
305 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
306 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
307 fwdata
->fwheader
.datalength
);
310 lbs_deb_usbd(&cardp->udev->dev,
311 "Data length = %d\n", fwdata->fwheader.datalength);
314 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
316 fwdata
->seqnum
= cardp
->fwseqnum
;
317 cardp
->lastseqnum
= fwdata
->seqnum
;
318 cardp
->totalbytes
+= fwdata
->fwheader
.datalength
;
320 if (fwheader
->dnldcmd
== FW_HAS_DATA_TO_RECV
) {
322 lbs_deb_usbd(&cardp->udev->dev, "There is data to follow\n");
323 lbs_deb_usbd(&cardp->udev->dev,
324 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
327 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
328 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
330 } else if (fwdata
->fwheader
.dnldcmd
== FW_HAS_LAST_BLOCK
) {
332 lbs_deb_usbd(&cardp->udev->dev,
333 "Host has finished FW downloading\n");
334 lbs_deb_usbd(&cardp->udev->dev,
335 "Donwloading FW JUMP BLOCK\n");
337 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
338 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
339 cardp
->fwfinalblk
= 1;
343 lbs_deb_usbd(&cardp->udev->dev,
344 "The firmware download is done size is %d\n",
353 static int libertas_do_reset(wlan_private
*priv
)
356 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
358 lbs_deb_enter(LBS_DEB_USB
);
360 ret
= usb_reset_device(cardp
->udev
);
367 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
373 * @brief This function transfer the data to the device.
374 * @param priv pointer to wlan_private
375 * @param payload pointer to payload data
376 * @param nb data length
379 int usb_tx_block(wlan_private
* priv
, u8
* payload
, u16 nb
)
381 /* pointer to card structure */
382 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
385 /* check if device is removed */
386 if (priv
->adapter
->surpriseremoved
) {
387 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
391 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
392 usb_sndbulkpipe(cardp
->udev
,
393 cardp
->bulk_out_endpointAddr
),
394 payload
, nb
, if_usb_write_bulk_callback
, priv
);
396 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
398 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
399 /* transfer failed */
400 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
403 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
411 static int __if_usb_submit_rx_urb(wlan_private
* priv
,
415 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
417 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
420 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
421 lbs_pr_err("No free skb\n");
427 /* Fill the receive configuration URB and initialise the Rx call back */
428 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
429 usb_rcvbulkpipe(cardp
->udev
,
430 cardp
->bulk_in_endpointAddr
),
431 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
432 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
435 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
437 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
438 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
439 /* handle failure conditions */
440 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
443 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
451 static inline int if_usb_submit_rx_urb_fwload(wlan_private
* priv
)
453 return __if_usb_submit_rx_urb(priv
, &if_usb_receive_fwload
);
456 static inline int if_usb_submit_rx_urb(wlan_private
* priv
)
458 return __if_usb_submit_rx_urb(priv
, &if_usb_receive
);
461 static void if_usb_receive_fwload(struct urb
*urb
)
463 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
464 wlan_private
*priv
= rinfo
->priv
;
465 struct sk_buff
*skb
= rinfo
->skb
;
466 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
467 struct fwsyncheader
*syncfwheader
;
468 struct bootcmdrespStr bootcmdresp
;
471 lbs_deb_usbd(&cardp
->udev
->dev
,
472 "URB status is failed during fw load\n");
477 if (cardp
->bootcmdresp
== 0) {
478 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
479 sizeof(bootcmdresp
));
480 if (cardp
->udev
->descriptor
.bcdDevice
< 0x3106) {
482 if_usb_submit_rx_urb_fwload(priv
);
483 cardp
->bootcmdresp
= 1;
484 lbs_deb_usbd(&cardp
->udev
->dev
,
485 "Received valid boot command response\n");
488 if (bootcmdresp
.u32magicnumber
!= BOOT_CMD_MAGIC_NUMBER
) {
490 "boot cmd response wrong magic number (0x%x)\n",
491 bootcmdresp
.u32magicnumber
);
492 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
494 "boot cmd response cmd_tag error (%d)\n",
495 bootcmdresp
.u8cmd_tag
);
496 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
498 "boot cmd response result error (%d)\n",
499 bootcmdresp
.u8result
);
501 cardp
->bootcmdresp
= 1;
502 lbs_deb_usbd(&cardp
->udev
->dev
,
503 "Received valid boot command response\n");
506 if_usb_submit_rx_urb_fwload(priv
);
510 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
512 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
517 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
518 sizeof(struct fwsyncheader
));
520 if (!syncfwheader
->cmd
) {
522 lbs_deb_usbd(&cardp->udev->dev,
523 "FW received Blk with correct CRC\n");
524 lbs_deb_usbd(&cardp->udev->dev,
525 "FW received Blk seqnum = %d\n",
526 syncfwheader->seqnum);
530 lbs_deb_usbd(&cardp
->udev
->dev
,
531 "FW received Blk with CRC error\n");
537 if (cardp
->fwfinalblk
) {
538 cardp
->fwdnldover
= 1;
542 if_prog_firmware(priv
);
544 if_usb_submit_rx_urb_fwload(priv
);
552 #define MRVDRV_MIN_PKT_LEN 30
554 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
555 struct usb_card_rec
*cardp
,
558 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
559 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
560 lbs_deb_usbd(&cardp
->udev
->dev
,
561 "Packet length is Invalid\n");
566 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
567 skb_put(skb
, recvlength
);
568 skb_pull(skb
, MESSAGE_HEADER_LEN
);
569 libertas_process_rxed_packet(priv
, skb
);
570 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
573 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
575 struct usb_card_rec
*cardp
,
579 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
580 lbs_deb_usbd(&cardp
->udev
->dev
,
581 "The receive buffer is too large\n");
589 spin_lock(&priv
->adapter
->driver_lock
);
590 /* take care of cur_cmd = NULL case by reading the
591 * data to clear the interrupt */
592 if (!priv
->adapter
->cur_cmd
) {
593 cmdbuf
= priv
->wlan_dev
.upld_buf
;
594 priv
->adapter
->hisregcpy
&= ~his_cmdupldrdy
;
596 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
598 cardp
->usb_int_cause
|= his_cmdupldrdy
;
599 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
600 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
601 priv
->wlan_dev
.upld_len
);
604 libertas_interrupt(priv
->wlan_dev
.netdev
);
605 spin_unlock(&priv
->adapter
->driver_lock
);
607 lbs_deb_usbd(&cardp
->udev
->dev
,
608 "Wake up main thread to handle cmd response\n");
614 * @brief This function reads of the packet into the upload buff,
615 * wake up the main thread and initialise the Rx callack.
617 * @param urb pointer to struct urb
620 static void if_usb_receive(struct urb
*urb
)
622 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
623 wlan_private
*priv
= rinfo
->priv
;
624 struct sk_buff
*skb
= rinfo
->skb
;
625 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
627 int recvlength
= urb
->actual_length
;
631 lbs_deb_enter(LBS_DEB_USB
);
635 lbs_deb_usbd(&cardp
->udev
->dev
,
636 "URB status is failed\n");
641 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
642 memcpy(&recvtype
, recvbuff
, sizeof(u32
));
643 lbs_deb_usbd(&cardp
->udev
->dev
,
644 "Recv length = 0x%x\n", recvlength
);
645 lbs_deb_usbd(&cardp
->udev
->dev
,
646 "Receive type = 0x%X\n", recvtype
);
647 recvtype
= le32_to_cpu(recvtype
);
648 lbs_deb_usbd(&cardp
->udev
->dev
,
649 "Receive type after = 0x%X\n", recvtype
);
650 } else if (urb
->status
)
656 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
659 case CMD_TYPE_REQUEST
:
660 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
663 case CMD_TYPE_INDICATION
:
664 /* Event cause handling */
665 spin_lock(&priv
->adapter
->driver_lock
);
666 cardp
->usb_event_cause
= *(u32
*) (recvbuff
+ MESSAGE_HEADER_LEN
);
667 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
668 cardp
->usb_event_cause
);
669 if (cardp
->usb_event_cause
& 0xffff0000) {
670 libertas_send_tx_feedback(priv
);
671 spin_unlock(&priv
->adapter
->driver_lock
);
674 cardp
->usb_event_cause
= le32_to_cpu(cardp
->usb_event_cause
) << 3;
675 cardp
->usb_int_cause
|= his_cardevent
;
677 libertas_interrupt(priv
->wlan_dev
.netdev
);
678 spin_unlock(&priv
->adapter
->driver_lock
);
686 if_usb_submit_rx_urb(priv
);
688 lbs_deb_leave(LBS_DEB_USB
);
692 * @brief This function downloads data to FW
693 * @param priv pointer to wlan_private structure
694 * @param type type of data
695 * @param buf pointer to data buffer
696 * @param len number of bytes
699 int libertas_sbi_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
703 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
705 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
706 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
708 if (type
== MVMS_CMD
) {
709 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
710 priv
->wlan_dev
.dnld_sent
= DNLD_CMD_SENT
;
711 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
715 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
716 priv
->wlan_dev
.dnld_sent
= DNLD_DATA_SENT
;
717 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
721 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
724 usb_tx_block(priv
, cardp
->bulk_out_buffer
, nb
+ MESSAGE_HEADER_LEN
);
729 /* called with adapter->driver_lock held */
730 int libertas_sbi_get_int_status(wlan_private
* priv
, u8
* ireg
)
732 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
734 *ireg
= cardp
->usb_int_cause
;
735 cardp
->usb_int_cause
= 0;
737 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
742 int libertas_sbi_read_event_cause(wlan_private
* priv
)
744 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
745 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
746 /* Re-submit rx urb here to avoid event lost issue */
747 if_usb_submit_rx_urb(priv
);
751 static int reset_device(wlan_private
*priv
)
755 lbs_deb_enter(LBS_DEB_USB
);
756 ret
= libertas_prepare_and_send_command(priv
, cmd_802_11_reset
,
757 cmd_act_halt
, 0, 0, NULL
);
758 msleep_interruptible(10);
760 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
764 int libertas_sbi_unregister_dev(wlan_private
* priv
)
768 /* Need to send a Reset command to device before USB resources freed
769 * and wlan_remove_card() called, then device can handle FW download
780 * @brief This function register usb device and initialize parameter
781 * @param priv pointer to wlan_private
784 int libertas_sbi_register_dev(wlan_private
* priv
)
786 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
788 lbs_deb_enter(LBS_DEB_USB
);
791 cardp
->eth_dev
= priv
->wlan_dev
.netdev
;
792 priv
->hotplug_device
= &(cardp
->udev
->dev
);
794 SET_NETDEV_DEV(cardp
->eth_dev
, &(cardp
->udev
->dev
));
795 SET_NETDEV_DEV(priv
->mesh_dev
, &(cardp
->udev
->dev
));
797 lbs_deb_usbd(&cardp
->udev
->dev
, "udev pointer is at %p\n",
800 lbs_deb_leave(LBS_DEB_USB
);
806 int libertas_sbi_prog_firmware(wlan_private
* priv
)
808 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
810 static int reset_count
= 10;
813 lbs_deb_enter(LBS_DEB_USB
);
815 cardp
->rinfo
.priv
= priv
;
818 if (if_usb_submit_rx_urb_fwload(priv
) < 0) {
819 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
824 cardp
->bootcmdresp
= 0;
828 /* Issue Boot command = 1, Boot from Download-FW */
829 if_usb_issue_boot_command(priv
, BOOT_CMD_FW_BY_USB
);
830 /* wait for command response */
833 msleep_interruptible(100);
834 } while (cardp
->bootcmdresp
== 0 && j
< 10);
835 } while (cardp
->bootcmdresp
== 0 && i
< 5);
837 if (cardp
->bootcmdresp
== 0) {
838 if (--reset_count
>= 0) {
839 libertas_do_reset(priv
);
846 priv
->adapter
->fw_ready
= 0;
848 cardp
->totalbytes
= 0;
849 cardp
->fwlastblksent
= 0;
851 cardp
->fwdnldover
= 0;
852 cardp
->fwseqnum
= -1;
853 cardp
->totalbytes
= 0;
854 cardp
->fwfinalblk
= 0;
856 if_prog_firmware(priv
);
859 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
861 msleep_interruptible(100);
862 if (priv
->adapter
->surpriseremoved
|| i
>= 20)
864 } while (!cardp
->fwdnldover
);
866 if (!cardp
->fwdnldover
) {
867 lbs_pr_info("failed to load fw, resetting device!\n");
868 if (--reset_count
>= 0) {
869 libertas_do_reset(priv
);
873 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
878 if_usb_submit_rx_urb(priv
);
880 /* Delay 200 ms to waiting for the FW ready */
881 msleep_interruptible(200);
883 priv
->adapter
->fw_ready
= 1;
886 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
891 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
893 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
894 wlan_private
*priv
= cardp
->priv
;
896 lbs_deb_enter(LBS_DEB_USB
);
898 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
901 netif_device_detach(cardp
->eth_dev
);
902 netif_device_detach(priv
->mesh_dev
);
904 /* Unlink tx & rx urb */
905 usb_kill_urb(cardp
->tx_urb
);
906 usb_kill_urb(cardp
->rx_urb
);
908 cardp
->rx_urb_recall
= 1;
910 lbs_deb_leave(LBS_DEB_USB
);
914 static int if_usb_resume(struct usb_interface
*intf
)
916 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
917 wlan_private
*priv
= cardp
->priv
;
919 lbs_deb_enter(LBS_DEB_USB
);
921 cardp
->rx_urb_recall
= 0;
923 if_usb_submit_rx_urb(cardp
->priv
);
925 netif_device_attach(cardp
->eth_dev
);
926 netif_device_attach(priv
->mesh_dev
);
928 lbs_deb_leave(LBS_DEB_USB
);
932 #define if_usb_suspend NULL
933 #define if_usb_resume NULL
936 static struct usb_driver if_usb_driver
= {
938 .name
= usbdriver_name
,
939 /* probe function name */
940 .probe
= if_usb_probe
,
941 /* disconnect function name */
942 .disconnect
= if_usb_disconnect
,
943 /* device signature table */
944 .id_table
= if_usb_table
,
945 .suspend
= if_usb_suspend
,
946 .resume
= if_usb_resume
,
950 * @brief This function registers driver.
951 * @param add pointer to add_card callback function
952 * @param remove pointer to remove card callback function
953 * @param arg pointer to call back function parameter
954 * @return dummy success variable
956 int libertas_sbi_register(void)
959 * API registers the Marvell USB driver
962 usb_register(&if_usb_driver
);
964 /* Return success to wlan layer */
969 * @brief This function removes usb driver.
972 void libertas_sbi_unregister(void)
976 for (i
= 0; i
<libertas_found
; i
++) {
977 wlan_private
*priv
= libertas_devs
[i
]->priv
;
981 /* API unregisters the driver from USB subsystem */
982 usb_deregister(&if_usb_driver
);