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 static 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_prog_firmware(struct usb_card_rec
*cardp
);
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
*);
52 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
*payload
, u16 nb
);
53 static void if_usb_free(struct usb_card_rec
*cardp
);
54 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
);
55 static int if_usb_reset_device(struct usb_card_rec
*cardp
);
58 * @brief call back function to handle the status of the URB
59 * @param urb pointer to urb structure
62 static void if_usb_write_bulk_callback(struct urb
*urb
)
64 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) urb
->context
;
66 /* handle the transmission complete validations */
68 if (urb
->status
== 0) {
69 wlan_private
*priv
= cardp
->priv
;
72 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
73 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
77 /* Used for both firmware TX and regular TX. priv isn't
78 * valid at firmware load time.
81 wlan_adapter
*adapter
= priv
->adapter
;
82 struct net_device
*dev
= priv
->dev
;
84 priv
->dnld_sent
= DNLD_RES_RECEIVED
;
86 /* Wake main thread if commands are pending */
87 if (!adapter
->cur_cmd
)
88 wake_up_interruptible(&priv
->waitq
);
90 if ((adapter
->connect_status
== LIBERTAS_CONNECTED
)) {
91 netif_wake_queue(dev
);
92 netif_wake_queue(priv
->mesh_dev
);
96 /* print the failure status number for debug */
97 lbs_pr_info("URB in failure status: %d\n", urb
->status
);
104 * @brief free tx/rx urb, skb and rx buffer
105 * @param cardp pointer usb_card_rec
108 static void if_usb_free(struct usb_card_rec
*cardp
)
110 lbs_deb_enter(LBS_DEB_USB
);
112 /* Unlink tx & rx urb */
113 usb_kill_urb(cardp
->tx_urb
);
114 usb_kill_urb(cardp
->rx_urb
);
116 usb_free_urb(cardp
->tx_urb
);
117 cardp
->tx_urb
= NULL
;
119 usb_free_urb(cardp
->rx_urb
);
120 cardp
->rx_urb
= NULL
;
122 kfree(cardp
->bulk_out_buffer
);
123 cardp
->bulk_out_buffer
= NULL
;
125 lbs_deb_leave(LBS_DEB_USB
);
129 * @brief sets the configuration values
130 * @param ifnum interface number
131 * @param id pointer to usb_device_id
132 * @return 0 on success, error code on failure
134 static int if_usb_probe(struct usb_interface
*intf
,
135 const struct usb_device_id
*id
)
137 struct usb_device
*udev
;
138 struct usb_host_interface
*iface_desc
;
139 struct usb_endpoint_descriptor
*endpoint
;
141 struct usb_card_rec
*cardp
;
144 udev
= interface_to_usbdev(intf
);
146 cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
148 lbs_pr_err("Out of memory allocating private data.\n");
153 iface_desc
= intf
->cur_altsetting
;
155 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
156 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
157 le16_to_cpu(udev
->descriptor
.bcdUSB
),
158 udev
->descriptor
.bDeviceClass
,
159 udev
->descriptor
.bDeviceSubClass
,
160 udev
->descriptor
.bDeviceProtocol
);
162 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
163 endpoint
= &iface_desc
->endpoint
[i
].desc
;
164 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
165 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
166 USB_ENDPOINT_XFER_BULK
)) {
167 /* we found a bulk in endpoint */
168 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
169 le16_to_cpu(endpoint
->wMaxPacketSize
));
170 if (!(cardp
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
171 lbs_deb_usbd(&udev
->dev
,
172 "Rx URB allocation failed\n");
175 cardp
->rx_urb_recall
= 0;
177 cardp
->bulk_in_size
=
178 le16_to_cpu(endpoint
->wMaxPacketSize
);
179 cardp
->bulk_in_endpointAddr
=
181 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
182 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
183 endpoint
->bEndpointAddress
);
187 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
189 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
190 USB_ENDPOINT_XFER_BULK
)) {
191 /* We found bulk out endpoint */
192 if (!(cardp
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
193 lbs_deb_usbd(&udev
->dev
,
194 "Tx URB allocation failed\n");
198 cardp
->bulk_out_size
=
199 le16_to_cpu(endpoint
->wMaxPacketSize
);
200 lbs_deb_usbd(&udev
->dev
,
201 "Bulk out size is %d\n",
202 le16_to_cpu(endpoint
->wMaxPacketSize
));
203 cardp
->bulk_out_endpointAddr
=
204 endpoint
->bEndpointAddress
;
205 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
206 endpoint
->bEndpointAddress
);
207 cardp
->bulk_out_buffer
=
208 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
211 if (!cardp
->bulk_out_buffer
) {
212 lbs_deb_usbd(&udev
->dev
,
213 "Could not allocate buffer\n");
219 /* Upload firmware */
220 cardp
->rinfo
.cardp
= cardp
;
221 if (if_usb_prog_firmware(cardp
)) {
222 lbs_deb_usbd(&udev
->dev
, "FW upload failed");
223 goto err_prog_firmware
;
226 if (!(priv
= libertas_add_card(cardp
, &udev
->dev
)))
227 goto err_prog_firmware
;
231 if (libertas_add_mesh(priv
, &udev
->dev
))
234 cardp
->eth_dev
= priv
->dev
;
236 priv
->hw_host_to_card
= if_usb_host_to_card
;
237 priv
->hw_get_int_status
= if_usb_get_int_status
;
238 priv
->hw_read_event_cause
= if_usb_read_event_cause
;
239 priv
->boot2_version
= udev
->descriptor
.bcdDevice
;
241 /* Delay 200 ms to waiting for the FW ready */
242 if_usb_submit_rx_urb(cardp
);
243 msleep_interruptible(200);
244 priv
->adapter
->fw_ready
= 1;
246 if (libertas_start_card(priv
))
249 list_add_tail(&cardp
->list
, &usb_devices
);
252 usb_set_intfdata(intf
, cardp
);
257 libertas_remove_mesh(priv
);
259 libertas_remove_card(priv
);
261 if_usb_reset_device(cardp
);
270 * @brief free resource and cleanup
271 * @param intf USB interface structure
274 static void if_usb_disconnect(struct usb_interface
*intf
)
276 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
277 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
279 lbs_deb_enter(LBS_DEB_MAIN
);
281 /* Update Surprise removed to TRUE */
282 cardp
->surprise_removed
= 1;
284 list_del(&cardp
->list
);
287 wlan_adapter
*adapter
= priv
->adapter
;
289 adapter
->surpriseremoved
= 1;
290 libertas_stop_card(priv
);
291 libertas_remove_mesh(priv
);
292 libertas_remove_card(priv
);
295 /* Unlink and free urb */
298 usb_set_intfdata(intf
, NULL
);
299 usb_put_dev(interface_to_usbdev(intf
));
301 lbs_deb_leave(LBS_DEB_MAIN
);
305 * @brief This function download FW
306 * @param priv pointer to wlan_private
309 static int if_prog_firmware(struct usb_card_rec
*cardp
)
311 struct FWData
*fwdata
;
312 struct fwheader
*fwheader
;
313 u8
*firmware
= cardp
->fw
->data
;
315 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
320 fwheader
= &fwdata
->fwheader
;
322 if (!cardp
->CRC_OK
) {
323 cardp
->totalbytes
= cardp
->fwlastblksent
;
324 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
328 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
332 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
333 sizeof(struct fwheader
));
335 cardp
->fwlastblksent
= cardp
->totalbytes
;
336 cardp
->totalbytes
+= sizeof(struct fwheader
);
338 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
339 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
340 le32_to_cpu(fwdata
->fwheader
.datalength
));
343 lbs_deb_usbd(&cardp->udev->dev,
344 "Data length = %d\n", le32_to_cpu(fwdata->fwheader.datalength));
347 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
349 fwdata
->seqnum
= cpu_to_le32(cardp
->fwseqnum
);
350 cardp
->lastseqnum
= cardp
->fwseqnum
;
351 cardp
->totalbytes
+= le32_to_cpu(fwdata
->fwheader
.datalength
);
353 if (fwheader
->dnldcmd
== cpu_to_le32(FW_HAS_DATA_TO_RECV
)) {
355 lbs_deb_usbd(&cardp->udev->dev, "There are data to follow\n");
356 lbs_deb_usbd(&cardp->udev->dev,
357 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
360 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
361 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
363 } else if (fwdata
->fwheader
.dnldcmd
== cpu_to_le32(FW_HAS_LAST_BLOCK
)) {
365 lbs_deb_usbd(&cardp->udev->dev,
366 "Host has finished FW downloading\n");
367 lbs_deb_usbd(&cardp->udev->dev,
368 "Donwloading FW JUMP BLOCK\n");
370 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
371 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
372 cardp
->fwfinalblk
= 1;
376 lbs_deb_usbd(&cardp->udev->dev,
377 "The firmware download is done size is %d\n",
386 static int if_usb_reset_device(struct usb_card_rec
*cardp
)
389 wlan_private
* priv
= cardp
->priv
;
391 lbs_deb_enter(LBS_DEB_USB
);
393 /* Try a USB port reset first, if that fails send the reset
394 * command to the firmware.
396 ret
= usb_reset_device(cardp
->udev
);
399 ret
= libertas_reset_device(priv
);
403 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
409 * @brief This function transfer the data to the device.
410 * @param priv pointer to wlan_private
411 * @param payload pointer to payload data
412 * @param nb data length
415 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
* payload
, u16 nb
)
419 /* check if device is removed */
420 if (cardp
->surprise_removed
) {
421 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
425 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
426 usb_sndbulkpipe(cardp
->udev
,
427 cardp
->bulk_out_endpointAddr
),
428 payload
, nb
, if_usb_write_bulk_callback
, cardp
);
430 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
432 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
433 /* transfer failed */
434 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
437 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
445 static int __if_usb_submit_rx_urb(struct usb_card_rec
*cardp
,
446 void (*callbackfn
)(struct urb
*urb
))
449 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
452 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
453 lbs_pr_err("No free skb\n");
459 /* Fill the receive configuration URB and initialise the Rx call back */
460 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
461 usb_rcvbulkpipe(cardp
->udev
,
462 cardp
->bulk_in_endpointAddr
),
463 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
464 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
467 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
469 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
470 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
471 /* handle failure conditions */
472 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
475 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
483 static int if_usb_submit_rx_urb_fwload(struct usb_card_rec
*cardp
)
485 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive_fwload
);
488 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
)
490 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive
);
493 static void if_usb_receive_fwload(struct urb
*urb
)
495 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
496 struct sk_buff
*skb
= rinfo
->skb
;
497 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)rinfo
->cardp
;
498 struct fwsyncheader
*syncfwheader
;
499 struct bootcmdrespStr bootcmdresp
;
502 lbs_deb_usbd(&cardp
->udev
->dev
,
503 "URB status is failed during fw load\n");
508 if (cardp
->bootcmdresp
== 0) {
509 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
510 sizeof(bootcmdresp
));
511 if (le16_to_cpu(cardp
->udev
->descriptor
.bcdDevice
) < 0x3106) {
513 if_usb_submit_rx_urb_fwload(cardp
);
514 cardp
->bootcmdresp
= 1;
515 lbs_deb_usbd(&cardp
->udev
->dev
,
516 "Received valid boot command response\n");
519 if (bootcmdresp
.u32magicnumber
!= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
)) {
521 "boot cmd response wrong magic number (0x%x)\n",
522 le32_to_cpu(bootcmdresp
.u32magicnumber
));
523 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
525 "boot cmd response cmd_tag error (%d)\n",
526 bootcmdresp
.u8cmd_tag
);
527 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
529 "boot cmd response result error (%d)\n",
530 bootcmdresp
.u8result
);
532 cardp
->bootcmdresp
= 1;
533 lbs_deb_usbd(&cardp
->udev
->dev
,
534 "Received valid boot command response\n");
537 if_usb_submit_rx_urb_fwload(cardp
);
541 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
543 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
548 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
549 sizeof(struct fwsyncheader
));
551 if (!syncfwheader
->cmd
) {
553 lbs_deb_usbd(&cardp->udev->dev,
554 "FW received Blk with correct CRC\n");
555 lbs_deb_usbd(&cardp->udev->dev,
556 "FW received Blk seqnum = %d\n",
557 syncfwheader->seqnum);
561 lbs_deb_usbd(&cardp
->udev
->dev
,
562 "FW received Blk with CRC error\n");
568 if (cardp
->fwfinalblk
) {
569 cardp
->fwdnldover
= 1;
573 if_prog_firmware(cardp
);
575 if_usb_submit_rx_urb_fwload(cardp
);
583 #define MRVDRV_MIN_PKT_LEN 30
585 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
586 struct usb_card_rec
*cardp
,
589 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
590 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
591 lbs_deb_usbd(&cardp
->udev
->dev
,
592 "Packet length is Invalid\n");
597 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
598 skb_put(skb
, recvlength
);
599 skb_pull(skb
, MESSAGE_HEADER_LEN
);
600 libertas_process_rxed_packet(priv
, skb
);
601 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
604 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
606 struct usb_card_rec
*cardp
,
610 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
611 lbs_deb_usbd(&cardp
->udev
->dev
,
612 "The receive buffer is too large\n");
620 spin_lock(&priv
->adapter
->driver_lock
);
621 /* take care of cur_cmd = NULL case by reading the
622 * data to clear the interrupt */
623 if (!priv
->adapter
->cur_cmd
) {
624 cmdbuf
= priv
->upld_buf
;
625 priv
->adapter
->hisregcpy
&= ~MRVDRV_CMD_UPLD_RDY
;
627 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
629 cardp
->usb_int_cause
|= MRVDRV_CMD_UPLD_RDY
;
630 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
631 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
635 libertas_interrupt(priv
->dev
);
636 spin_unlock(&priv
->adapter
->driver_lock
);
638 lbs_deb_usbd(&cardp
->udev
->dev
,
639 "Wake up main thread to handle cmd response\n");
645 * @brief This function reads of the packet into the upload buff,
646 * wake up the main thread and initialise the Rx callack.
648 * @param urb pointer to struct urb
651 static void if_usb_receive(struct urb
*urb
)
653 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
654 struct sk_buff
*skb
= rinfo
->skb
;
655 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) rinfo
->cardp
;
656 wlan_private
* priv
= cardp
->priv
;
658 int recvlength
= urb
->actual_length
;
662 lbs_deb_enter(LBS_DEB_USB
);
668 lbs_deb_usbd(&cardp
->udev
->dev
,
669 "URB status is failed\n");
674 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
675 memcpy(&tmp
, recvbuff
, sizeof(u32
));
676 recvtype
= le32_to_cpu(tmp
);
677 lbs_deb_usbd(&cardp
->udev
->dev
,
678 "Recv length = 0x%x, Recv type = 0x%X\n",
679 recvlength
, recvtype
);
680 } else if (urb
->status
)
685 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
688 case CMD_TYPE_REQUEST
:
689 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
692 case CMD_TYPE_INDICATION
:
693 /* Event cause handling */
694 spin_lock(&priv
->adapter
->driver_lock
);
695 cardp
->usb_event_cause
= le32_to_cpu(*(__le32
*) (recvbuff
+ MESSAGE_HEADER_LEN
));
696 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
697 cardp
->usb_event_cause
);
698 if (cardp
->usb_event_cause
& 0xffff0000) {
699 libertas_send_tx_feedback(priv
);
700 spin_unlock(&priv
->adapter
->driver_lock
);
703 cardp
->usb_event_cause
<<= 3;
704 cardp
->usb_int_cause
|= MRVDRV_CARDEVENT
;
706 libertas_interrupt(priv
->dev
);
707 spin_unlock(&priv
->adapter
->driver_lock
);
710 lbs_deb_usbd(&cardp
->udev
->dev
, "Unknown command type 0x%X\n",
717 if_usb_submit_rx_urb(cardp
);
719 lbs_deb_leave(LBS_DEB_USB
);
723 * @brief This function downloads data to FW
724 * @param priv pointer to wlan_private structure
725 * @param type type of data
726 * @param buf pointer to data buffer
727 * @param len number of bytes
730 static int if_usb_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
732 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
734 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
735 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
737 if (type
== MVMS_CMD
) {
738 __le32 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
739 priv
->dnld_sent
= DNLD_CMD_SENT
;
740 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
744 __le32 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
745 priv
->dnld_sent
= DNLD_DATA_SENT
;
746 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
750 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
752 return usb_tx_block(cardp
, cardp
->bulk_out_buffer
,
753 nb
+ MESSAGE_HEADER_LEN
);
756 /* called with adapter->driver_lock held */
757 static int if_usb_get_int_status(wlan_private
* priv
, u8
* ireg
)
759 struct usb_card_rec
*cardp
= priv
->card
;
761 *ireg
= cardp
->usb_int_cause
;
762 cardp
->usb_int_cause
= 0;
764 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
769 static int if_usb_read_event_cause(wlan_private
* priv
)
771 struct usb_card_rec
*cardp
= priv
->card
;
773 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
774 /* Re-submit rx urb here to avoid event lost issue */
775 if_usb_submit_rx_urb(cardp
);
780 * @brief This function issues Boot command to the Boot2 code
781 * @param ivalue 1:Boot from FW by USB-Download
782 * 2:Boot from FW in EEPROM
785 static int if_usb_issue_boot_command(struct usb_card_rec
*cardp
, int ivalue
)
787 struct bootcmdstr sbootcmd
;
790 /* Prepare command */
791 sbootcmd
.u32magicnumber
= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
);
792 sbootcmd
.u8cmd_tag
= ivalue
;
794 sbootcmd
.au8dumy
[i
]=0x00;
795 memcpy(cardp
->bulk_out_buffer
, &sbootcmd
, sizeof(struct bootcmdstr
));
798 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, sizeof(struct bootcmdstr
));
805 * @brief This function checks the validity of Boot2/FW image.
807 * @param data pointer to image
811 static int check_fwfile_format(u8
*data
, u32 totlen
)
814 u32 blksize
, offset
, len
;
821 struct fwheader
*fwh
= (void *)data
;
823 bincmd
= le32_to_cpu(fwh
->dnldcmd
);
824 blksize
= le32_to_cpu(fwh
->datalength
);
826 case FW_HAS_DATA_TO_RECV
:
827 offset
= sizeof(struct fwheader
) + blksize
;
833 case FW_HAS_LAST_BLOCK
:
844 lbs_pr_err("firmware file format check FAIL\n");
846 lbs_deb_fw("firmware file format check PASS\n");
852 static int if_usb_prog_firmware(struct usb_card_rec
*cardp
)
855 static int reset_count
= 10;
858 lbs_deb_enter(LBS_DEB_USB
);
860 if ((ret
= request_firmware(&cardp
->fw
, libertas_fw_name
,
861 &cardp
->udev
->dev
)) < 0) {
862 lbs_pr_err("request_firmware() failed with %#x\n", ret
);
863 lbs_pr_err("firmware %s not found\n", libertas_fw_name
);
867 if (check_fwfile_format(cardp
->fw
->data
, cardp
->fw
->size
))
871 if (if_usb_submit_rx_urb_fwload(cardp
) < 0) {
872 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
877 cardp
->bootcmdresp
= 0;
881 /* Issue Boot command = 1, Boot from Download-FW */
882 if_usb_issue_boot_command(cardp
, BOOT_CMD_FW_BY_USB
);
883 /* wait for command response */
886 msleep_interruptible(100);
887 } while (cardp
->bootcmdresp
== 0 && j
< 10);
888 } while (cardp
->bootcmdresp
== 0 && i
< 5);
890 if (cardp
->bootcmdresp
== 0) {
891 if (--reset_count
>= 0) {
892 if_usb_reset_device(cardp
);
900 cardp
->totalbytes
= 0;
901 cardp
->fwlastblksent
= 0;
903 cardp
->fwdnldover
= 0;
904 cardp
->fwseqnum
= -1;
905 cardp
->totalbytes
= 0;
906 cardp
->fwfinalblk
= 0;
908 if_prog_firmware(cardp
);
911 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
913 msleep_interruptible(100);
914 if (cardp
->surprise_removed
|| i
>= 20)
916 } while (!cardp
->fwdnldover
);
918 if (!cardp
->fwdnldover
) {
919 lbs_pr_info("failed to load fw, resetting device!\n");
920 if (--reset_count
>= 0) {
921 if_usb_reset_device(cardp
);
925 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
931 release_firmware(cardp
->fw
);
935 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
941 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
943 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
944 wlan_private
*priv
= cardp
->priv
;
946 lbs_deb_enter(LBS_DEB_USB
);
948 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
951 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
952 /* Mesh autostart must be activated while sleeping
953 * On resume it will go back to the current state
955 struct cmd_ds_mesh_access mesh_access
;
956 memset(&mesh_access
, 0, sizeof(mesh_access
));
957 mesh_access
.data
[0] = cpu_to_le32(1);
958 libertas_prepare_and_send_command(priv
,
960 CMD_ACT_MESH_SET_AUTOSTART_ENABLED
,
961 CMD_OPTION_WAITFORRSP
, 0, (void *)&mesh_access
);
964 netif_device_detach(cardp
->eth_dev
);
965 netif_device_detach(priv
->mesh_dev
);
967 /* Unlink tx & rx urb */
968 usb_kill_urb(cardp
->tx_urb
);
969 usb_kill_urb(cardp
->rx_urb
);
971 cardp
->rx_urb_recall
= 1;
973 lbs_deb_leave(LBS_DEB_USB
);
977 static int if_usb_resume(struct usb_interface
*intf
)
979 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
980 wlan_private
*priv
= cardp
->priv
;
982 lbs_deb_enter(LBS_DEB_USB
);
984 cardp
->rx_urb_recall
= 0;
986 if_usb_submit_rx_urb(cardp
->priv
);
988 netif_device_attach(cardp
->eth_dev
);
989 netif_device_attach(priv
->mesh_dev
);
991 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
992 /* Mesh autostart was activated while sleeping
993 * Disable it if appropriate
995 struct cmd_ds_mesh_access mesh_access
;
996 memset(&mesh_access
, 0, sizeof(mesh_access
));
997 mesh_access
.data
[0] = cpu_to_le32(0);
998 libertas_prepare_and_send_command(priv
,
1000 CMD_ACT_MESH_SET_AUTOSTART_ENABLED
,
1001 CMD_OPTION_WAITFORRSP
, 0, (void *)&mesh_access
);
1004 lbs_deb_leave(LBS_DEB_USB
);
1008 #define if_usb_suspend NULL
1009 #define if_usb_resume NULL
1012 static struct usb_driver if_usb_driver
= {
1014 .name
= usbdriver_name
,
1015 /* probe function name */
1016 .probe
= if_usb_probe
,
1017 /* disconnect function name */
1018 .disconnect
= if_usb_disconnect
,
1019 /* device signature table */
1020 .id_table
= if_usb_table
,
1021 .suspend
= if_usb_suspend
,
1022 .resume
= if_usb_resume
,
1025 static int if_usb_init_module(void)
1029 lbs_deb_enter(LBS_DEB_MAIN
);
1031 if (libertas_fw_name
== NULL
) {
1032 libertas_fw_name
= default_fw_name
;
1035 ret
= usb_register(&if_usb_driver
);
1037 lbs_deb_leave_args(LBS_DEB_MAIN
, "ret %d", ret
);
1041 static void if_usb_exit_module(void)
1043 struct usb_card_rec
*cardp
, *cardp_temp
;
1045 lbs_deb_enter(LBS_DEB_MAIN
);
1047 list_for_each_entry_safe(cardp
, cardp_temp
, &usb_devices
, list
) {
1048 libertas_prepare_and_send_command(cardp
->priv
, CMD_802_11_RESET
,
1049 CMD_ACT_HALT
, 0, 0, NULL
);
1052 /* API unregisters the driver from USB subsystem */
1053 usb_deregister(&if_usb_driver
);
1055 lbs_deb_leave(LBS_DEB_MAIN
);
1058 module_init(if_usb_init_module
);
1059 module_exit(if_usb_exit_module
);
1061 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1062 MODULE_AUTHOR("Marvell International Ltd.");
1063 MODULE_LICENSE("GPL");