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>
17 #define MESSAGE_HEADER_LEN 4
19 static const char usbdriver_name
[] = "usb8xxx";
20 static u8
*default_fw_name
= "usb8388.bin";
22 char *libertas_fw_name
= NULL
;
23 module_param_named(fw_name
, libertas_fw_name
, charp
, 0644);
26 * We need to send a RESET command to all USB devices before
27 * we tear down the USB connection. Otherwise we would not
28 * be able to re-init device the device if the module gets
29 * loaded again. This is a list of all initialized USB devices,
30 * for the reset code see if_usb_reset_device()
32 static LIST_HEAD(usb_devices
);
34 static struct usb_device_id if_usb_table
[] = {
35 /* Enter the device signature inside */
36 { USB_DEVICE(0x1286, 0x2001) },
37 { USB_DEVICE(0x05a3, 0x8388) },
38 {} /* Terminating entry */
41 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
43 static void if_usb_receive(struct urb
*urb
);
44 static void if_usb_receive_fwload(struct urb
*urb
);
45 static int if_usb_reset_device(wlan_private
*priv
);
46 static int if_usb_register_dev(wlan_private
* priv
);
47 static int if_usb_unregister_dev(wlan_private
*);
48 static int if_usb_prog_firmware(wlan_private
*);
49 static int if_usb_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
);
50 static int if_usb_get_int_status(wlan_private
* priv
, u8
*);
51 static int if_usb_read_event_cause(wlan_private
*);
54 * @brief call back function to handle the status of the URB
55 * @param urb pointer to urb structure
58 static void if_usb_write_bulk_callback(struct urb
*urb
)
60 wlan_private
*priv
= (wlan_private
*) (urb
->context
);
61 wlan_adapter
*adapter
= priv
->adapter
;
62 struct net_device
*dev
= priv
->wlan_dev
.netdev
;
64 /* handle the transmission complete validations */
66 if (urb
->status
!= 0) {
67 /* print the failure status number for debug */
68 lbs_pr_info("URB in failure status\n");
71 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
72 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
75 priv
->wlan_dev
.dnld_sent
= DNLD_RES_RECEIVED
;
76 /* Wake main thread if commands are pending */
77 if (!adapter
->cur_cmd
)
78 wake_up_interruptible(&priv
->mainthread
.waitq
);
79 if ((adapter
->connect_status
== libertas_connected
)) {
80 netif_wake_queue(dev
);
81 netif_wake_queue(priv
->mesh_dev
);
89 * @brief free tx/rx urb, skb and rx buffer
90 * @param cardp pointer usb_card_rec
93 void if_usb_free(struct usb_card_rec
*cardp
)
95 lbs_deb_enter(LBS_DEB_USB
);
97 /* Unlink tx & rx urb */
98 usb_kill_urb(cardp
->tx_urb
);
99 usb_kill_urb(cardp
->rx_urb
);
101 usb_free_urb(cardp
->tx_urb
);
102 cardp
->tx_urb
= NULL
;
104 usb_free_urb(cardp
->rx_urb
);
105 cardp
->rx_urb
= NULL
;
107 kfree(cardp
->bulk_out_buffer
);
108 cardp
->bulk_out_buffer
= NULL
;
110 lbs_deb_leave(LBS_DEB_USB
);
114 * @brief sets the configuration values
115 * @param ifnum interface number
116 * @param id pointer to usb_device_id
117 * @return 0 on success, error code on failure
119 static int if_usb_probe(struct usb_interface
*intf
,
120 const struct usb_device_id
*id
)
122 struct usb_device
*udev
;
123 struct usb_host_interface
*iface_desc
;
124 struct usb_endpoint_descriptor
*endpoint
;
126 struct usb_card_rec
*cardp
;
129 udev
= interface_to_usbdev(intf
);
131 cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
133 lbs_pr_err("Out of memory allocating private data.\n");
138 iface_desc
= intf
->cur_altsetting
;
140 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
141 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
142 udev
->descriptor
.bcdUSB
,
143 udev
->descriptor
.bDeviceClass
,
144 udev
->descriptor
.bDeviceSubClass
,
145 udev
->descriptor
.bDeviceProtocol
);
147 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
148 endpoint
= &iface_desc
->endpoint
[i
].desc
;
149 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
150 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
151 USB_ENDPOINT_XFER_BULK
)) {
152 /* we found a bulk in endpoint */
153 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
154 endpoint
->wMaxPacketSize
);
157 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 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 */
181 usb_alloc_urb(0, GFP_KERNEL
))) {
182 lbs_deb_usbd(&udev
->dev
,
183 "Tx URB allocation failed\n");
187 cardp
->bulk_out_size
=
188 endpoint
->wMaxPacketSize
;
189 lbs_deb_usbd(&udev
->dev
,
190 "Bulk out size is %d\n",
191 endpoint
->wMaxPacketSize
);
192 cardp
->bulk_out_endpointAddr
=
193 endpoint
->bEndpointAddress
;
194 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
195 endpoint
->bEndpointAddress
);
196 cardp
->bulk_out_buffer
=
197 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
200 if (!cardp
->bulk_out_buffer
) {
201 lbs_deb_usbd(&udev
->dev
,
202 "Could not allocate buffer\n");
209 /* At this point libertas_add_card() will be called. Don't worry
210 * about keeping pwlanpriv around since it will be set on our
211 * usb device data in -> add() -> hw_register_dev() -> if_usb_register_dev.
213 if (!(priv
= libertas_add_card(cardp
)))
216 if (libertas_add_mesh(priv
))
219 priv
->hw_register_dev
= if_usb_register_dev
;
220 priv
->hw_unregister_dev
= if_usb_unregister_dev
;
221 priv
->hw_prog_firmware
= if_usb_prog_firmware
;
222 priv
->hw_host_to_card
= if_usb_host_to_card
;
223 priv
->hw_get_int_status
= if_usb_get_int_status
;
224 priv
->hw_read_event_cause
= if_usb_read_event_cause
;
226 if (libertas_activate_card(priv
, libertas_fw_name
))
227 goto err_activate_card
;
229 list_add_tail(&cardp
->list
, &usb_devices
);
232 usb_set_intfdata(intf
, cardp
);
237 unregister_netdev(priv
->mesh_dev
);
238 free_netdev(priv
->mesh_dev
);
240 free_netdev(priv
->wlan_dev
.netdev
);
241 kfree(priv
->adapter
);
250 * @brief free resource and cleanup
251 * @param intf USB interface structure
254 static void if_usb_disconnect(struct usb_interface
*intf
)
256 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
257 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
258 wlan_adapter
*adapter
= NULL
;
260 adapter
= priv
->adapter
;
263 * Update Surprise removed to TRUE
265 adapter
->surpriseremoved
= 1;
267 list_del(&cardp
->list
);
269 /* card is removed and we can call wlan_remove_card */
270 lbs_deb_usbd(&cardp
->udev
->dev
, "call remove card\n");
271 libertas_remove_mesh(priv
);
272 libertas_remove_card(priv
);
274 /* Unlink and free urb */
277 usb_set_intfdata(intf
, NULL
);
278 usb_put_dev(interface_to_usbdev(intf
));
284 * @brief This function download FW
285 * @param priv pointer to wlan_private
288 static int if_prog_firmware(wlan_private
* priv
)
290 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
291 struct FWData
*fwdata
;
292 struct fwheader
*fwheader
;
293 u8
*firmware
= priv
->firmware
->data
;
295 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
300 fwheader
= &fwdata
->fwheader
;
302 if (!cardp
->CRC_OK
) {
303 cardp
->totalbytes
= cardp
->fwlastblksent
;
304 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
308 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
312 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
313 sizeof(struct fwheader
));
315 cardp
->fwlastblksent
= cardp
->totalbytes
;
316 cardp
->totalbytes
+= sizeof(struct fwheader
);
318 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
319 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
320 fwdata
->fwheader
.datalength
);
323 lbs_deb_usbd(&cardp->udev->dev,
324 "Data length = %d\n", fwdata->fwheader.datalength);
327 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
329 fwdata
->seqnum
= cardp
->fwseqnum
;
330 cardp
->lastseqnum
= fwdata
->seqnum
;
331 cardp
->totalbytes
+= fwdata
->fwheader
.datalength
;
333 if (fwheader
->dnldcmd
== FW_HAS_DATA_TO_RECV
) {
335 lbs_deb_usbd(&cardp->udev->dev, "There is data to follow\n");
336 lbs_deb_usbd(&cardp->udev->dev,
337 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
340 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
341 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
343 } else if (fwdata
->fwheader
.dnldcmd
== FW_HAS_LAST_BLOCK
) {
345 lbs_deb_usbd(&cardp->udev->dev,
346 "Host has finished FW downloading\n");
347 lbs_deb_usbd(&cardp->udev->dev,
348 "Donwloading FW JUMP BLOCK\n");
350 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
351 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
352 cardp
->fwfinalblk
= 1;
356 lbs_deb_usbd(&cardp->udev->dev,
357 "The firmware download is done size is %d\n",
366 static int libertas_do_reset(wlan_private
*priv
)
369 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
371 lbs_deb_enter(LBS_DEB_USB
);
373 ret
= usb_reset_device(cardp
->udev
);
376 if_usb_reset_device(priv
);
380 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
386 * @brief This function transfer the data to the device.
387 * @param priv pointer to wlan_private
388 * @param payload pointer to payload data
389 * @param nb data length
392 int usb_tx_block(wlan_private
* priv
, u8
* payload
, u16 nb
)
394 /* pointer to card structure */
395 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
398 /* check if device is removed */
399 if (priv
->adapter
->surpriseremoved
) {
400 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
404 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
405 usb_sndbulkpipe(cardp
->udev
,
406 cardp
->bulk_out_endpointAddr
),
407 payload
, nb
, if_usb_write_bulk_callback
, priv
);
409 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
411 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
412 /* transfer failed */
413 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
416 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
424 static int __if_usb_submit_rx_urb(wlan_private
* priv
,
428 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
430 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
433 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
434 lbs_pr_err("No free skb\n");
440 /* Fill the receive configuration URB and initialise the Rx call back */
441 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
442 usb_rcvbulkpipe(cardp
->udev
,
443 cardp
->bulk_in_endpointAddr
),
444 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
445 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
448 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
450 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
451 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
452 /* handle failure conditions */
453 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
456 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
464 static inline int if_usb_submit_rx_urb_fwload(wlan_private
* priv
)
466 return __if_usb_submit_rx_urb(priv
, &if_usb_receive_fwload
);
469 static inline int if_usb_submit_rx_urb(wlan_private
* priv
)
471 return __if_usb_submit_rx_urb(priv
, &if_usb_receive
);
474 static void if_usb_receive_fwload(struct urb
*urb
)
476 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
477 wlan_private
*priv
= rinfo
->priv
;
478 struct sk_buff
*skb
= rinfo
->skb
;
479 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
480 struct fwsyncheader
*syncfwheader
;
481 struct bootcmdrespStr bootcmdresp
;
484 lbs_deb_usbd(&cardp
->udev
->dev
,
485 "URB status is failed during fw load\n");
490 if (cardp
->bootcmdresp
== 0) {
491 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
492 sizeof(bootcmdresp
));
493 if (cardp
->udev
->descriptor
.bcdDevice
< 0x3106) {
495 if_usb_submit_rx_urb_fwload(priv
);
496 cardp
->bootcmdresp
= 1;
497 lbs_deb_usbd(&cardp
->udev
->dev
,
498 "Received valid boot command response\n");
501 if (bootcmdresp
.u32magicnumber
!= BOOT_CMD_MAGIC_NUMBER
) {
503 "boot cmd response wrong magic number (0x%x)\n",
504 bootcmdresp
.u32magicnumber
);
505 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
507 "boot cmd response cmd_tag error (%d)\n",
508 bootcmdresp
.u8cmd_tag
);
509 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
511 "boot cmd response result error (%d)\n",
512 bootcmdresp
.u8result
);
514 cardp
->bootcmdresp
= 1;
515 lbs_deb_usbd(&cardp
->udev
->dev
,
516 "Received valid boot command response\n");
519 if_usb_submit_rx_urb_fwload(priv
);
523 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
525 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
530 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
531 sizeof(struct fwsyncheader
));
533 if (!syncfwheader
->cmd
) {
535 lbs_deb_usbd(&cardp->udev->dev,
536 "FW received Blk with correct CRC\n");
537 lbs_deb_usbd(&cardp->udev->dev,
538 "FW received Blk seqnum = %d\n",
539 syncfwheader->seqnum);
543 lbs_deb_usbd(&cardp
->udev
->dev
,
544 "FW received Blk with CRC error\n");
550 if (cardp
->fwfinalblk
) {
551 cardp
->fwdnldover
= 1;
555 if_prog_firmware(priv
);
557 if_usb_submit_rx_urb_fwload(priv
);
565 #define MRVDRV_MIN_PKT_LEN 30
567 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
568 struct usb_card_rec
*cardp
,
571 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
572 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
573 lbs_deb_usbd(&cardp
->udev
->dev
,
574 "Packet length is Invalid\n");
579 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
580 skb_put(skb
, recvlength
);
581 skb_pull(skb
, MESSAGE_HEADER_LEN
);
582 libertas_process_rxed_packet(priv
, skb
);
583 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
586 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
588 struct usb_card_rec
*cardp
,
592 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
593 lbs_deb_usbd(&cardp
->udev
->dev
,
594 "The receive buffer is too large\n");
602 spin_lock(&priv
->adapter
->driver_lock
);
603 /* take care of cur_cmd = NULL case by reading the
604 * data to clear the interrupt */
605 if (!priv
->adapter
->cur_cmd
) {
606 cmdbuf
= priv
->wlan_dev
.upld_buf
;
607 priv
->adapter
->hisregcpy
&= ~his_cmdupldrdy
;
609 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
611 cardp
->usb_int_cause
|= his_cmdupldrdy
;
612 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
613 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
614 priv
->wlan_dev
.upld_len
);
617 libertas_interrupt(priv
->wlan_dev
.netdev
);
618 spin_unlock(&priv
->adapter
->driver_lock
);
620 lbs_deb_usbd(&cardp
->udev
->dev
,
621 "Wake up main thread to handle cmd response\n");
627 * @brief This function reads of the packet into the upload buff,
628 * wake up the main thread and initialise the Rx callack.
630 * @param urb pointer to struct urb
633 static void if_usb_receive(struct urb
*urb
)
635 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
636 wlan_private
*priv
= rinfo
->priv
;
637 struct sk_buff
*skb
= rinfo
->skb
;
638 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
640 int recvlength
= urb
->actual_length
;
644 lbs_deb_enter(LBS_DEB_USB
);
648 lbs_deb_usbd(&cardp
->udev
->dev
,
649 "URB status is failed\n");
654 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
655 memcpy(&recvtype
, recvbuff
, sizeof(u32
));
656 lbs_deb_usbd(&cardp
->udev
->dev
,
657 "Recv length = 0x%x\n", recvlength
);
658 lbs_deb_usbd(&cardp
->udev
->dev
,
659 "Receive type = 0x%X\n", recvtype
);
660 recvtype
= le32_to_cpu(recvtype
);
661 lbs_deb_usbd(&cardp
->udev
->dev
,
662 "Receive type after = 0x%X\n", recvtype
);
663 } else if (urb
->status
)
669 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
672 case CMD_TYPE_REQUEST
:
673 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
676 case CMD_TYPE_INDICATION
:
677 /* Event cause handling */
678 spin_lock(&priv
->adapter
->driver_lock
);
679 cardp
->usb_event_cause
= *(u32
*) (recvbuff
+ MESSAGE_HEADER_LEN
);
680 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
681 cardp
->usb_event_cause
);
682 if (cardp
->usb_event_cause
& 0xffff0000) {
683 libertas_send_tx_feedback(priv
);
684 spin_unlock(&priv
->adapter
->driver_lock
);
687 cardp
->usb_event_cause
= le32_to_cpu(cardp
->usb_event_cause
) << 3;
688 cardp
->usb_int_cause
|= his_cardevent
;
690 libertas_interrupt(priv
->wlan_dev
.netdev
);
691 spin_unlock(&priv
->adapter
->driver_lock
);
699 if_usb_submit_rx_urb(priv
);
701 lbs_deb_leave(LBS_DEB_USB
);
705 * @brief This function downloads data to FW
706 * @param priv pointer to wlan_private structure
707 * @param type type of data
708 * @param buf pointer to data buffer
709 * @param len number of bytes
712 static int if_usb_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
716 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
718 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
719 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
721 if (type
== MVMS_CMD
) {
722 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
723 priv
->wlan_dev
.dnld_sent
= DNLD_CMD_SENT
;
724 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
728 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
729 priv
->wlan_dev
.dnld_sent
= DNLD_DATA_SENT
;
730 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
734 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
737 usb_tx_block(priv
, cardp
->bulk_out_buffer
, nb
+ MESSAGE_HEADER_LEN
);
742 /* called with adapter->driver_lock held */
743 static int if_usb_get_int_status(wlan_private
* priv
, u8
* ireg
)
745 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
747 *ireg
= cardp
->usb_int_cause
;
748 cardp
->usb_int_cause
= 0;
750 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
755 static int if_usb_read_event_cause(wlan_private
* priv
)
757 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
758 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
759 /* Re-submit rx urb here to avoid event lost issue */
760 if_usb_submit_rx_urb(priv
);
764 static int if_usb_reset_device(wlan_private
*priv
)
768 lbs_deb_enter(LBS_DEB_USB
);
769 ret
= libertas_prepare_and_send_command(priv
, cmd_802_11_reset
,
770 cmd_act_halt
, 0, 0, NULL
);
771 msleep_interruptible(10);
773 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
777 static int if_usb_unregister_dev(wlan_private
* priv
)
781 /* Need to send a Reset command to device before USB resources freed
782 * and wlan_remove_card() called, then device can handle FW download
786 if_usb_reset_device(priv
);
793 * @brief This function register usb device and initialize parameter
794 * @param priv pointer to wlan_private
797 static int if_usb_register_dev(wlan_private
* priv
)
799 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
801 lbs_deb_enter(LBS_DEB_USB
);
804 cardp
->eth_dev
= priv
->wlan_dev
.netdev
;
805 priv
->hotplug_device
= &(cardp
->udev
->dev
);
807 SET_NETDEV_DEV(cardp
->eth_dev
, &(cardp
->udev
->dev
));
808 SET_NETDEV_DEV(priv
->mesh_dev
, &(cardp
->udev
->dev
));
810 lbs_deb_usbd(&cardp
->udev
->dev
, "udev pointer is at %p\n",
813 lbs_deb_leave(LBS_DEB_USB
);
819 static int if_usb_prog_firmware(wlan_private
* priv
)
821 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
823 static int reset_count
= 10;
826 lbs_deb_enter(LBS_DEB_USB
);
828 cardp
->rinfo
.priv
= priv
;
831 if (if_usb_submit_rx_urb_fwload(priv
) < 0) {
832 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
837 cardp
->bootcmdresp
= 0;
841 /* Issue Boot command = 1, Boot from Download-FW */
842 if_usb_issue_boot_command(priv
, BOOT_CMD_FW_BY_USB
);
843 /* wait for command response */
846 msleep_interruptible(100);
847 } while (cardp
->bootcmdresp
== 0 && j
< 10);
848 } while (cardp
->bootcmdresp
== 0 && i
< 5);
850 if (cardp
->bootcmdresp
== 0) {
851 if (--reset_count
>= 0) {
852 libertas_do_reset(priv
);
859 priv
->adapter
->fw_ready
= 0;
861 cardp
->totalbytes
= 0;
862 cardp
->fwlastblksent
= 0;
864 cardp
->fwdnldover
= 0;
865 cardp
->fwseqnum
= -1;
866 cardp
->totalbytes
= 0;
867 cardp
->fwfinalblk
= 0;
869 if_prog_firmware(priv
);
872 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
874 msleep_interruptible(100);
875 if (priv
->adapter
->surpriseremoved
|| i
>= 20)
877 } while (!cardp
->fwdnldover
);
879 if (!cardp
->fwdnldover
) {
880 lbs_pr_info("failed to load fw, resetting device!\n");
881 if (--reset_count
>= 0) {
882 libertas_do_reset(priv
);
886 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
891 if_usb_submit_rx_urb(priv
);
893 /* Delay 200 ms to waiting for the FW ready */
894 msleep_interruptible(200);
896 priv
->adapter
->fw_ready
= 1;
899 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
904 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
906 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
907 wlan_private
*priv
= cardp
->priv
;
909 lbs_deb_enter(LBS_DEB_USB
);
911 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
914 netif_device_detach(cardp
->eth_dev
);
915 netif_device_detach(priv
->mesh_dev
);
917 /* Unlink tx & rx urb */
918 usb_kill_urb(cardp
->tx_urb
);
919 usb_kill_urb(cardp
->rx_urb
);
921 cardp
->rx_urb_recall
= 1;
923 lbs_deb_leave(LBS_DEB_USB
);
927 static int if_usb_resume(struct usb_interface
*intf
)
929 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
930 wlan_private
*priv
= cardp
->priv
;
932 lbs_deb_enter(LBS_DEB_USB
);
934 cardp
->rx_urb_recall
= 0;
936 if_usb_submit_rx_urb(cardp
->priv
);
938 netif_device_attach(cardp
->eth_dev
);
939 netif_device_attach(priv
->mesh_dev
);
941 lbs_deb_leave(LBS_DEB_USB
);
945 #define if_usb_suspend NULL
946 #define if_usb_resume NULL
949 static struct usb_driver if_usb_driver
= {
951 .name
= usbdriver_name
,
952 /* probe function name */
953 .probe
= if_usb_probe
,
954 /* disconnect function name */
955 .disconnect
= if_usb_disconnect
,
956 /* device signature table */
957 .id_table
= if_usb_table
,
958 .suspend
= if_usb_suspend
,
959 .resume
= if_usb_resume
,
962 static int if_usb_init_module(void)
966 lbs_deb_enter(LBS_DEB_MAIN
);
968 if (libertas_fw_name
== NULL
) {
969 libertas_fw_name
= default_fw_name
;
972 ret
= usb_register(&if_usb_driver
);
974 lbs_deb_leave_args(LBS_DEB_MAIN
, "ret %d", ret
);
978 static void if_usb_exit_module(void)
980 struct list_head
*ptr
;
981 struct usb_card_rec
*cardp
;
983 lbs_deb_enter(LBS_DEB_MAIN
);
985 list_for_each(ptr
, &usb_devices
) {
986 cardp
= list_entry(ptr
, struct usb_card_rec
, list
);
987 if_usb_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");