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"
20 #define MESSAGE_HEADER_LEN 4
22 static const char usbdriver_name
[] = "usb8xxx";
23 static u8
*default_fw_name
= "usb8388.bin";
25 char *libertas_fw_name
= NULL
;
26 module_param_named(fw_name
, libertas_fw_name
, charp
, 0644);
29 * We need to send a RESET command to all USB devices before
30 * we tear down the USB connection. Otherwise we would not
31 * be able to re-init device the device if the module gets
32 * loaded again. This is a list of all initialized USB devices,
33 * for the reset code see if_usb_reset_device()
35 static LIST_HEAD(usb_devices
);
37 static struct usb_device_id if_usb_table
[] = {
38 /* Enter the device signature inside */
39 { USB_DEVICE(0x1286, 0x2001) },
40 { USB_DEVICE(0x05a3, 0x8388) },
41 {} /* Terminating entry */
44 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
46 static void if_usb_receive(struct urb
*urb
);
47 static void if_usb_receive_fwload(struct urb
*urb
);
48 static int if_usb_register_dev(wlan_private
* priv
);
49 static int if_usb_unregister_dev(wlan_private
*);
50 static int if_usb_prog_firmware(wlan_private
*);
51 static int if_usb_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
);
52 static int if_usb_get_int_status(wlan_private
* priv
, u8
*);
53 static int if_usb_read_event_cause(wlan_private
*);
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 wlan_private
*priv
= (wlan_private
*) (urb
->context
);
63 wlan_adapter
*adapter
= priv
->adapter
;
64 struct net_device
*dev
= priv
->dev
;
66 /* handle the transmission complete validations */
68 if (urb
->status
!= 0) {
69 /* print the failure status number for debug */
70 lbs_pr_info("URB in failure status: %d\n", urb
->status
);
73 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
74 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
77 priv
->dnld_sent
= DNLD_RES_RECEIVED
;
78 /* Wake main thread if commands are pending */
79 if (!adapter
->cur_cmd
)
80 wake_up_interruptible(&priv
->waitq
);
81 if ((adapter
->connect_status
== LIBERTAS_CONNECTED
)) {
82 netif_wake_queue(dev
);
83 netif_wake_queue(priv
->mesh_dev
);
91 * @brief free tx/rx urb, skb and rx buffer
92 * @param cardp pointer usb_card_rec
95 void if_usb_free(struct usb_card_rec
*cardp
)
97 lbs_deb_enter(LBS_DEB_USB
);
99 /* Unlink tx & rx urb */
100 usb_kill_urb(cardp
->tx_urb
);
101 usb_kill_urb(cardp
->rx_urb
);
103 usb_free_urb(cardp
->tx_urb
);
104 cardp
->tx_urb
= NULL
;
106 usb_free_urb(cardp
->rx_urb
);
107 cardp
->rx_urb
= NULL
;
109 kfree(cardp
->bulk_out_buffer
);
110 cardp
->bulk_out_buffer
= NULL
;
112 lbs_deb_leave(LBS_DEB_USB
);
116 * @brief sets the configuration values
117 * @param ifnum interface number
118 * @param id pointer to usb_device_id
119 * @return 0 on success, error code on failure
121 static int if_usb_probe(struct usb_interface
*intf
,
122 const struct usb_device_id
*id
)
124 struct usb_device
*udev
;
125 struct usb_host_interface
*iface_desc
;
126 struct usb_endpoint_descriptor
*endpoint
;
128 struct usb_card_rec
*cardp
;
131 udev
= interface_to_usbdev(intf
);
133 cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
135 lbs_pr_err("Out of memory allocating private data.\n");
140 iface_desc
= intf
->cur_altsetting
;
142 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
143 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
144 le16_to_cpu(udev
->descriptor
.bcdUSB
),
145 udev
->descriptor
.bDeviceClass
,
146 udev
->descriptor
.bDeviceSubClass
,
147 udev
->descriptor
.bDeviceProtocol
);
149 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
150 endpoint
= &iface_desc
->endpoint
[i
].desc
;
151 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
152 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
153 USB_ENDPOINT_XFER_BULK
)) {
154 /* we found a bulk in endpoint */
155 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
156 le16_to_cpu(endpoint
->wMaxPacketSize
));
157 if (!(cardp
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
158 lbs_deb_usbd(&udev
->dev
,
159 "Rx URB allocation failed\n");
162 cardp
->rx_urb_recall
= 0;
164 cardp
->bulk_in_size
=
165 le16_to_cpu(endpoint
->wMaxPacketSize
);
166 cardp
->bulk_in_endpointAddr
=
168 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
169 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
170 endpoint
->bEndpointAddress
);
174 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
176 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
177 USB_ENDPOINT_XFER_BULK
)) {
178 /* We found bulk out endpoint */
179 if (!(cardp
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
180 lbs_deb_usbd(&udev
->dev
,
181 "Tx URB allocation failed\n");
185 cardp
->bulk_out_size
=
186 le16_to_cpu(endpoint
->wMaxPacketSize
);
187 lbs_deb_usbd(&udev
->dev
,
188 "Bulk out size is %d\n",
189 le16_to_cpu(endpoint
->wMaxPacketSize
));
190 cardp
->bulk_out_endpointAddr
=
191 endpoint
->bEndpointAddress
;
192 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
193 endpoint
->bEndpointAddress
);
194 cardp
->bulk_out_buffer
=
195 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
198 if (!cardp
->bulk_out_buffer
) {
199 lbs_deb_usbd(&udev
->dev
,
200 "Could not allocate buffer\n");
206 if (!(priv
= libertas_add_card(cardp
, &udev
->dev
)))
209 if (libertas_add_mesh(priv
, &udev
->dev
))
212 priv
->hw_register_dev
= if_usb_register_dev
;
213 priv
->hw_unregister_dev
= if_usb_unregister_dev
;
214 priv
->hw_prog_firmware
= if_usb_prog_firmware
;
215 priv
->hw_host_to_card
= if_usb_host_to_card
;
216 priv
->hw_get_int_status
= if_usb_get_int_status
;
217 priv
->hw_read_event_cause
= if_usb_read_event_cause
;
219 if (libertas_activate_card(priv
, libertas_fw_name
))
220 goto err_activate_card
;
222 list_add_tail(&cardp
->list
, &usb_devices
);
225 usb_set_intfdata(intf
, cardp
);
230 libertas_remove_mesh(priv
);
232 free_netdev(priv
->dev
);
233 kfree(priv
->adapter
);
242 * @brief free resource and cleanup
243 * @param intf USB interface structure
246 static void if_usb_disconnect(struct usb_interface
*intf
)
248 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
249 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
250 wlan_adapter
*adapter
= NULL
;
252 adapter
= priv
->adapter
;
255 * Update Surprise removed to TRUE
257 adapter
->surpriseremoved
= 1;
259 list_del(&cardp
->list
);
261 /* card is removed and we can call wlan_remove_card */
262 lbs_deb_usbd(&cardp
->udev
->dev
, "call remove card\n");
263 libertas_remove_mesh(priv
);
264 libertas_remove_card(priv
);
266 /* Unlink and free urb */
269 usb_set_intfdata(intf
, NULL
);
270 usb_put_dev(interface_to_usbdev(intf
));
276 * @brief This function download FW
277 * @param priv pointer to wlan_private
280 static int if_prog_firmware(wlan_private
* priv
)
282 struct usb_card_rec
*cardp
= priv
->card
;
283 struct FWData
*fwdata
;
284 struct fwheader
*fwheader
;
285 u8
*firmware
= priv
->firmware
->data
;
287 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
292 fwheader
= &fwdata
->fwheader
;
294 if (!cardp
->CRC_OK
) {
295 cardp
->totalbytes
= cardp
->fwlastblksent
;
296 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
300 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
304 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
305 sizeof(struct fwheader
));
307 cardp
->fwlastblksent
= cardp
->totalbytes
;
308 cardp
->totalbytes
+= sizeof(struct fwheader
);
310 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
311 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
312 le32_to_cpu(fwdata
->fwheader
.datalength
));
315 lbs_deb_usbd(&cardp->udev->dev,
316 "Data length = %d\n", le32_to_cpu(fwdata->fwheader.datalength));
319 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
321 fwdata
->seqnum
= cpu_to_le32(cardp
->fwseqnum
);
322 cardp
->lastseqnum
= cardp
->fwseqnum
;
323 cardp
->totalbytes
+= le32_to_cpu(fwdata
->fwheader
.datalength
);
325 if (fwheader
->dnldcmd
== cpu_to_le32(FW_HAS_DATA_TO_RECV
)) {
327 lbs_deb_usbd(&cardp->udev->dev, "There are data to follow\n");
328 lbs_deb_usbd(&cardp->udev->dev,
329 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
332 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
333 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
335 } else if (fwdata
->fwheader
.dnldcmd
== cpu_to_le32(FW_HAS_LAST_BLOCK
)) {
337 lbs_deb_usbd(&cardp->udev->dev,
338 "Host has finished FW downloading\n");
339 lbs_deb_usbd(&cardp->udev->dev,
340 "Donwloading FW JUMP BLOCK\n");
342 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
343 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
344 cardp
->fwfinalblk
= 1;
348 lbs_deb_usbd(&cardp->udev->dev,
349 "The firmware download is done size is %d\n",
358 static int if_usb_reset_device(wlan_private
*priv
)
361 struct usb_card_rec
*cardp
= priv
->card
;
363 lbs_deb_enter(LBS_DEB_USB
);
365 /* Try a USB port reset first, if that fails send the reset
366 * command to the firmware.
368 ret
= usb_reset_device(cardp
->udev
);
371 ret
= libertas_reset_device(priv
);
375 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
381 * @brief This function transfer the data to the device.
382 * @param priv pointer to wlan_private
383 * @param payload pointer to payload data
384 * @param nb data length
387 int usb_tx_block(wlan_private
* priv
, u8
* payload
, u16 nb
)
389 /* pointer to card structure */
390 struct usb_card_rec
*cardp
= priv
->card
;
393 /* check if device is removed */
394 if (priv
->adapter
->surpriseremoved
) {
395 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
399 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
400 usb_sndbulkpipe(cardp
->udev
,
401 cardp
->bulk_out_endpointAddr
),
402 payload
, nb
, if_usb_write_bulk_callback
, priv
);
404 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
406 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
407 /* transfer failed */
408 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
411 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
419 static int __if_usb_submit_rx_urb(wlan_private
* priv
,
423 struct usb_card_rec
*cardp
= priv
->card
;
425 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
428 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
429 lbs_pr_err("No free skb\n");
435 /* Fill the receive configuration URB and initialise the Rx call back */
436 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
437 usb_rcvbulkpipe(cardp
->udev
,
438 cardp
->bulk_in_endpointAddr
),
439 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
440 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
443 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
445 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
446 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
447 /* handle failure conditions */
448 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
451 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
459 static inline int if_usb_submit_rx_urb_fwload(wlan_private
* priv
)
461 return __if_usb_submit_rx_urb(priv
, &if_usb_receive_fwload
);
464 static inline int if_usb_submit_rx_urb(wlan_private
* priv
)
466 return __if_usb_submit_rx_urb(priv
, &if_usb_receive
);
469 static void if_usb_receive_fwload(struct urb
*urb
)
471 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
472 wlan_private
*priv
= rinfo
->priv
;
473 struct sk_buff
*skb
= rinfo
->skb
;
474 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
475 struct fwsyncheader
*syncfwheader
;
476 struct bootcmdrespStr bootcmdresp
;
479 lbs_deb_usbd(&cardp
->udev
->dev
,
480 "URB status is failed during fw load\n");
485 if (cardp
->bootcmdresp
== 0) {
486 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
487 sizeof(bootcmdresp
));
488 if (le16_to_cpu(cardp
->udev
->descriptor
.bcdDevice
) < 0x3106) {
490 if_usb_submit_rx_urb_fwload(priv
);
491 cardp
->bootcmdresp
= 1;
492 lbs_deb_usbd(&cardp
->udev
->dev
,
493 "Received valid boot command response\n");
496 if (bootcmdresp
.u32magicnumber
!= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
)) {
498 "boot cmd response wrong magic number (0x%x)\n",
499 le32_to_cpu(bootcmdresp
.u32magicnumber
));
500 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
502 "boot cmd response cmd_tag error (%d)\n",
503 bootcmdresp
.u8cmd_tag
);
504 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
506 "boot cmd response result error (%d)\n",
507 bootcmdresp
.u8result
);
509 cardp
->bootcmdresp
= 1;
510 lbs_deb_usbd(&cardp
->udev
->dev
,
511 "Received valid boot command response\n");
514 if_usb_submit_rx_urb_fwload(priv
);
518 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
520 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
525 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
526 sizeof(struct fwsyncheader
));
528 if (!syncfwheader
->cmd
) {
530 lbs_deb_usbd(&cardp->udev->dev,
531 "FW received Blk with correct CRC\n");
532 lbs_deb_usbd(&cardp->udev->dev,
533 "FW received Blk seqnum = %d\n",
534 syncfwheader->seqnum);
538 lbs_deb_usbd(&cardp
->udev
->dev
,
539 "FW received Blk with CRC error\n");
545 if (cardp
->fwfinalblk
) {
546 cardp
->fwdnldover
= 1;
550 if_prog_firmware(priv
);
552 if_usb_submit_rx_urb_fwload(priv
);
560 #define MRVDRV_MIN_PKT_LEN 30
562 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
563 struct usb_card_rec
*cardp
,
566 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
567 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
568 lbs_deb_usbd(&cardp
->udev
->dev
,
569 "Packet length is Invalid\n");
574 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
575 skb_put(skb
, recvlength
);
576 skb_pull(skb
, MESSAGE_HEADER_LEN
);
577 libertas_process_rxed_packet(priv
, skb
);
578 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
581 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
583 struct usb_card_rec
*cardp
,
587 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
588 lbs_deb_usbd(&cardp
->udev
->dev
,
589 "The receive buffer is too large\n");
597 spin_lock(&priv
->adapter
->driver_lock
);
598 /* take care of cur_cmd = NULL case by reading the
599 * data to clear the interrupt */
600 if (!priv
->adapter
->cur_cmd
) {
601 cmdbuf
= priv
->upld_buf
;
602 priv
->adapter
->hisregcpy
&= ~his_cmdupldrdy
;
604 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
606 cardp
->usb_int_cause
|= his_cmdupldrdy
;
607 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
608 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
612 libertas_interrupt(priv
->dev
);
613 spin_unlock(&priv
->adapter
->driver_lock
);
615 lbs_deb_usbd(&cardp
->udev
->dev
,
616 "Wake up main thread to handle cmd response\n");
622 * @brief This function reads of the packet into the upload buff,
623 * wake up the main thread and initialise the Rx callack.
625 * @param urb pointer to struct urb
628 static void if_usb_receive(struct urb
*urb
)
630 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
631 wlan_private
*priv
= rinfo
->priv
;
632 struct sk_buff
*skb
= rinfo
->skb
;
633 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
635 int recvlength
= urb
->actual_length
;
639 lbs_deb_enter(LBS_DEB_USB
);
643 lbs_deb_usbd(&cardp
->udev
->dev
,
644 "URB status is failed\n");
649 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
650 memcpy(&recvtype
, recvbuff
, sizeof(u32
));
651 lbs_deb_usbd(&cardp
->udev
->dev
,
652 "Recv length = 0x%x\n", recvlength
);
653 lbs_deb_usbd(&cardp
->udev
->dev
,
654 "Receive type = 0x%X\n", recvtype
);
655 recvtype
= le32_to_cpu(recvtype
);
656 lbs_deb_usbd(&cardp
->udev
->dev
,
657 "Receive type after = 0x%X\n", recvtype
);
658 } else if (urb
->status
)
664 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
667 case CMD_TYPE_REQUEST
:
668 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
671 case CMD_TYPE_INDICATION
:
672 /* Event cause handling */
673 spin_lock(&priv
->adapter
->driver_lock
);
674 cardp
->usb_event_cause
= le32_to_cpu(*(__le32
*) (recvbuff
+ MESSAGE_HEADER_LEN
));
675 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
676 cardp
->usb_event_cause
);
677 if (cardp
->usb_event_cause
& 0xffff0000) {
678 libertas_send_tx_feedback(priv
);
679 spin_unlock(&priv
->adapter
->driver_lock
);
682 cardp
->usb_event_cause
<<= 3;
683 cardp
->usb_int_cause
|= his_cardevent
;
685 libertas_interrupt(priv
->dev
);
686 spin_unlock(&priv
->adapter
->driver_lock
);
694 if_usb_submit_rx_urb(priv
);
696 lbs_deb_leave(LBS_DEB_USB
);
700 * @brief This function downloads data to FW
701 * @param priv pointer to wlan_private structure
702 * @param type type of data
703 * @param buf pointer to data buffer
704 * @param len number of bytes
707 static int if_usb_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
711 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
713 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
714 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
716 if (type
== MVMS_CMD
) {
717 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
718 priv
->dnld_sent
= DNLD_CMD_SENT
;
719 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
723 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
724 priv
->dnld_sent
= DNLD_DATA_SENT
;
725 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
729 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
732 usb_tx_block(priv
, cardp
->bulk_out_buffer
, nb
+ MESSAGE_HEADER_LEN
);
737 /* called with adapter->driver_lock held */
738 static int if_usb_get_int_status(wlan_private
* priv
, u8
* ireg
)
740 struct usb_card_rec
*cardp
= priv
->card
;
742 *ireg
= cardp
->usb_int_cause
;
743 cardp
->usb_int_cause
= 0;
745 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
750 static int if_usb_read_event_cause(wlan_private
* priv
)
752 struct usb_card_rec
*cardp
= priv
->card
;
753 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
754 /* Re-submit rx urb here to avoid event lost issue */
755 if_usb_submit_rx_urb(priv
);
759 static int if_usb_unregister_dev(wlan_private
* priv
)
763 /* Need to send a Reset command to device before USB resources freed
764 * and wlan_remove_card() called, then device can handle FW download
768 libertas_reset_device(priv
);
775 * @brief This function register usb device and initialize parameter
776 * @param priv pointer to wlan_private
779 static int if_usb_register_dev(wlan_private
* priv
)
781 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
783 lbs_deb_enter(LBS_DEB_USB
);
786 cardp
->eth_dev
= priv
->dev
;
787 priv
->hotplug_device
= &(cardp
->udev
->dev
);
789 lbs_deb_usbd(&cardp
->udev
->dev
, "udev pointer is at %p\n",
792 lbs_deb_leave(LBS_DEB_USB
);
797 * @brief This function issues Boot command to the Boot2 code
798 * @param ivalue 1:Boot from FW by USB-Download
799 * 2:Boot from FW in EEPROM
802 static int if_usb_issue_boot_command(wlan_private
*priv
, int ivalue
)
804 struct usb_card_rec
*cardp
= priv
->card
;
805 struct bootcmdstr sbootcmd
;
808 /* Prepare command */
809 sbootcmd
.u32magicnumber
= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
);
810 sbootcmd
.u8cmd_tag
= ivalue
;
812 sbootcmd
.au8dumy
[i
]=0x00;
813 memcpy(cardp
->bulk_out_buffer
, &sbootcmd
, sizeof(struct bootcmdstr
));
816 usb_tx_block(priv
, cardp
->bulk_out_buffer
, sizeof(struct bootcmdstr
));
822 static int if_usb_prog_firmware(wlan_private
* priv
)
824 struct usb_card_rec
*cardp
= priv
->card
;
826 static int reset_count
= 10;
829 lbs_deb_enter(LBS_DEB_USB
);
831 cardp
->rinfo
.priv
= priv
;
834 if (if_usb_submit_rx_urb_fwload(priv
) < 0) {
835 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
840 cardp
->bootcmdresp
= 0;
844 /* Issue Boot command = 1, Boot from Download-FW */
845 if_usb_issue_boot_command(priv
, BOOT_CMD_FW_BY_USB
);
846 /* wait for command response */
849 msleep_interruptible(100);
850 } while (cardp
->bootcmdresp
== 0 && j
< 10);
851 } while (cardp
->bootcmdresp
== 0 && i
< 5);
853 if (cardp
->bootcmdresp
== 0) {
854 if (--reset_count
>= 0) {
855 if_usb_reset_device(priv
);
862 priv
->adapter
->fw_ready
= 0;
864 cardp
->totalbytes
= 0;
865 cardp
->fwlastblksent
= 0;
867 cardp
->fwdnldover
= 0;
868 cardp
->fwseqnum
= -1;
869 cardp
->totalbytes
= 0;
870 cardp
->fwfinalblk
= 0;
872 if_prog_firmware(priv
);
875 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
877 msleep_interruptible(100);
878 if (priv
->adapter
->surpriseremoved
|| i
>= 20)
880 } while (!cardp
->fwdnldover
);
882 if (!cardp
->fwdnldover
) {
883 lbs_pr_info("failed to load fw, resetting device!\n");
884 if (--reset_count
>= 0) {
885 if_usb_reset_device(priv
);
889 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
894 if_usb_submit_rx_urb(priv
);
896 /* Delay 200 ms to waiting for the FW ready */
897 msleep_interruptible(200);
899 priv
->adapter
->fw_ready
= 1;
902 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
907 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
909 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
910 wlan_private
*priv
= cardp
->priv
;
912 lbs_deb_enter(LBS_DEB_USB
);
914 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
917 netif_device_detach(cardp
->eth_dev
);
918 netif_device_detach(priv
->mesh_dev
);
920 /* Unlink tx & rx urb */
921 usb_kill_urb(cardp
->tx_urb
);
922 usb_kill_urb(cardp
->rx_urb
);
924 cardp
->rx_urb_recall
= 1;
926 lbs_deb_leave(LBS_DEB_USB
);
930 static int if_usb_resume(struct usb_interface
*intf
)
932 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
933 wlan_private
*priv
= cardp
->priv
;
935 lbs_deb_enter(LBS_DEB_USB
);
937 cardp
->rx_urb_recall
= 0;
939 if_usb_submit_rx_urb(cardp
->priv
);
941 netif_device_attach(cardp
->eth_dev
);
942 netif_device_attach(priv
->mesh_dev
);
944 lbs_deb_leave(LBS_DEB_USB
);
948 #define if_usb_suspend NULL
949 #define if_usb_resume NULL
952 static struct usb_driver if_usb_driver
= {
954 .name
= usbdriver_name
,
955 /* probe function name */
956 .probe
= if_usb_probe
,
957 /* disconnect function name */
958 .disconnect
= if_usb_disconnect
,
959 /* device signature table */
960 .id_table
= if_usb_table
,
961 .suspend
= if_usb_suspend
,
962 .resume
= if_usb_resume
,
965 static int if_usb_init_module(void)
969 lbs_deb_enter(LBS_DEB_MAIN
);
971 if (libertas_fw_name
== NULL
) {
972 libertas_fw_name
= default_fw_name
;
975 ret
= usb_register(&if_usb_driver
);
977 lbs_deb_leave_args(LBS_DEB_MAIN
, "ret %d", ret
);
981 static void if_usb_exit_module(void)
983 struct usb_card_rec
*cardp
, *cardp_temp
;
985 lbs_deb_enter(LBS_DEB_MAIN
);
987 list_for_each_entry_safe(cardp
, cardp_temp
, &usb_devices
, list
)
988 libertas_reset_device((wlan_private
*) cardp
->priv
);
990 /* API unregisters the driver from USB subsystem */
991 usb_deregister(&if_usb_driver
);
993 lbs_deb_leave(LBS_DEB_MAIN
);
996 module_init(if_usb_init_module
);
997 module_exit(if_usb_exit_module
);
999 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1000 MODULE_AUTHOR("Marvell International Ltd.");
1001 MODULE_LICENSE("GPL");