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>
16 #define MESSAGE_HEADER_LEN 4
18 static const char usbdriver_name
[] = "usb8xxx";
19 static u8
*default_fw_name
= "usb8388.bin";
21 char *libertas_fw_name
= NULL
;
22 module_param_named(fw_name
, libertas_fw_name
, charp
, 0644);
26 static struct net_device
*libertas_devs
[MAX_DEVS
];
27 static int libertas_found
= 0;
29 static struct usb_device_id if_usb_table
[] = {
30 /* Enter the device signature inside */
31 { USB_DEVICE(0x1286, 0x2001) },
32 { USB_DEVICE(0x05a3, 0x8388) },
33 {} /* Terminating entry */
36 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
38 static void if_usb_receive(struct urb
*urb
);
39 static void if_usb_receive_fwload(struct urb
*urb
);
40 static int reset_device(wlan_private
*priv
);
41 static int if_usb_register_dev(wlan_private
* priv
);
42 static int if_usb_unregister_dev(wlan_private
*);
43 static int if_usb_prog_firmware(wlan_private
*);
44 static int if_usb_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
);
45 static int if_usb_get_int_status(wlan_private
* priv
, u8
*);
46 static int if_usb_read_event_cause(wlan_private
*);
49 * @brief call back function to handle the status of the URB
50 * @param urb pointer to urb structure
53 static void if_usb_write_bulk_callback(struct urb
*urb
)
55 wlan_private
*priv
= (wlan_private
*) (urb
->context
);
56 wlan_adapter
*adapter
= priv
->adapter
;
57 struct net_device
*dev
= priv
->wlan_dev
.netdev
;
59 /* handle the transmission complete validations */
61 if (urb
->status
!= 0) {
62 /* print the failure status number for debug */
63 lbs_pr_info("URB in failure status\n");
66 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
67 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
70 priv
->wlan_dev
.dnld_sent
= DNLD_RES_RECEIVED
;
71 /* Wake main thread if commands are pending */
72 if (!adapter
->cur_cmd
)
73 wake_up_interruptible(&priv
->mainthread
.waitq
);
74 if ((adapter
->connect_status
== libertas_connected
)) {
75 netif_wake_queue(dev
);
76 netif_wake_queue(priv
->mesh_dev
);
84 * @brief free tx/rx urb, skb and rx buffer
85 * @param cardp pointer usb_card_rec
88 void if_usb_free(struct usb_card_rec
*cardp
)
90 lbs_deb_enter(LBS_DEB_USB
);
92 /* Unlink tx & rx urb */
93 usb_kill_urb(cardp
->tx_urb
);
94 usb_kill_urb(cardp
->rx_urb
);
96 usb_free_urb(cardp
->tx_urb
);
99 usb_free_urb(cardp
->rx_urb
);
100 cardp
->rx_urb
= NULL
;
102 kfree(cardp
->bulk_out_buffer
);
103 cardp
->bulk_out_buffer
= NULL
;
105 lbs_deb_leave(LBS_DEB_USB
);
109 * @brief sets the configuration values
110 * @param ifnum interface number
111 * @param id pointer to usb_device_id
112 * @return 0 on success, error code on failure
114 static int if_usb_probe(struct usb_interface
*intf
,
115 const struct usb_device_id
*id
)
117 struct usb_device
*udev
;
118 struct usb_host_interface
*iface_desc
;
119 struct usb_endpoint_descriptor
*endpoint
;
121 struct usb_card_rec
*usb_cardp
;
124 udev
= interface_to_usbdev(intf
);
126 usb_cardp
= kzalloc(sizeof(struct usb_card_rec
), GFP_KERNEL
);
128 lbs_pr_err("Out of memory allocating private data.\n");
132 usb_cardp
->udev
= udev
;
133 iface_desc
= intf
->cur_altsetting
;
135 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
136 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
137 udev
->descriptor
.bcdUSB
,
138 udev
->descriptor
.bDeviceClass
,
139 udev
->descriptor
.bDeviceSubClass
,
140 udev
->descriptor
.bDeviceProtocol
);
142 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
143 endpoint
= &iface_desc
->endpoint
[i
].desc
;
144 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
145 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
146 USB_ENDPOINT_XFER_BULK
)) {
147 /* we found a bulk in endpoint */
148 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
149 endpoint
->wMaxPacketSize
);
152 usb_alloc_urb(0, GFP_KERNEL
))) {
153 lbs_deb_usbd(&udev
->dev
,
154 "Rx URB allocation failed\n");
157 usb_cardp
->rx_urb_recall
= 0;
159 usb_cardp
->bulk_in_size
=
160 endpoint
->wMaxPacketSize
;
161 usb_cardp
->bulk_in_endpointAddr
=
163 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
164 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
165 endpoint
->bEndpointAddress
);
169 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
171 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
172 USB_ENDPOINT_XFER_BULK
)) {
173 /* We found bulk out endpoint */
176 usb_alloc_urb(0, GFP_KERNEL
))) {
177 lbs_deb_usbd(&udev
->dev
,
178 "Tx URB allocation failed\n");
182 usb_cardp
->bulk_out_size
=
183 endpoint
->wMaxPacketSize
;
184 lbs_deb_usbd(&udev
->dev
,
185 "Bulk out size is %d\n",
186 endpoint
->wMaxPacketSize
);
187 usb_cardp
->bulk_out_endpointAddr
=
188 endpoint
->bEndpointAddress
;
189 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
190 endpoint
->bEndpointAddress
);
191 usb_cardp
->bulk_out_buffer
=
192 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
195 if (!usb_cardp
->bulk_out_buffer
) {
196 lbs_deb_usbd(&udev
->dev
,
197 "Could not allocate buffer\n");
204 /* At this point libertas_add_card() will be called. Don't worry
205 * about keeping pwlanpriv around since it will be set on our
206 * usb device data in -> add() -> hw_register_dev() -> if_usb_register_dev.
208 if (!(priv
= libertas_add_card(usb_cardp
)))
211 if (libertas_add_mesh(priv
))
214 priv
->hw_register_dev
= if_usb_register_dev
;
215 priv
->hw_unregister_dev
= if_usb_unregister_dev
;
216 priv
->hw_prog_firmware
= if_usb_prog_firmware
;
217 priv
->hw_host_to_card
= if_usb_host_to_card
;
218 priv
->hw_get_int_status
= if_usb_get_int_status
;
219 priv
->hw_read_event_cause
= if_usb_read_event_cause
;
221 if (libertas_activate_card(priv
, libertas_fw_name
))
222 goto err_activate_card
;
224 if (libertas_found
< MAX_DEVS
) {
225 libertas_devs
[libertas_found
] = priv
->wlan_dev
.netdev
;
230 usb_set_intfdata(intf
, usb_cardp
);
233 * return card structure, which can be got back in the
234 * diconnect function as the ptr
240 unregister_netdev(priv
->mesh_dev
);
241 free_netdev(priv
->mesh_dev
);
243 free_netdev(priv
->wlan_dev
.netdev
);
244 kfree(priv
->adapter
);
246 if_usb_free(usb_cardp
);
253 * @brief free resource and cleanup
254 * @param udev pointer to usb_device
255 * @param ptr pointer to usb_cardp
258 static void if_usb_disconnect(struct usb_interface
*intf
)
260 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
261 wlan_private
*priv
= (wlan_private
*) cardp
->priv
;
262 wlan_adapter
*adapter
= NULL
;
265 adapter
= priv
->adapter
;
268 * Update Surprise removed to TRUE
270 adapter
->surpriseremoved
= 1;
272 for (i
= 0; i
<libertas_found
; i
++) {
273 if (libertas_devs
[i
]==priv
->wlan_dev
.netdev
) {
274 libertas_devs
[i
] = libertas_devs
[--libertas_found
];
275 libertas_devs
[libertas_found
] = NULL
;
280 /* card is removed and we can call wlan_remove_card */
281 lbs_deb_usbd(&cardp
->udev
->dev
, "call remove card\n");
282 libertas_remove_mesh(priv
);
283 libertas_remove_card(priv
);
285 /* Unlink and free urb */
288 usb_set_intfdata(intf
, NULL
);
289 usb_put_dev(interface_to_usbdev(intf
));
295 * @brief This function download FW
296 * @param priv pointer to wlan_private
299 static int if_prog_firmware(wlan_private
* priv
)
301 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
302 struct FWData
*fwdata
;
303 struct fwheader
*fwheader
;
304 u8
*firmware
= priv
->firmware
->data
;
306 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
311 fwheader
= &fwdata
->fwheader
;
313 if (!cardp
->CRC_OK
) {
314 cardp
->totalbytes
= cardp
->fwlastblksent
;
315 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
319 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
323 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
324 sizeof(struct fwheader
));
326 cardp
->fwlastblksent
= cardp
->totalbytes
;
327 cardp
->totalbytes
+= sizeof(struct fwheader
);
329 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
330 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
331 fwdata
->fwheader
.datalength
);
334 lbs_deb_usbd(&cardp->udev->dev,
335 "Data length = %d\n", fwdata->fwheader.datalength);
338 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
340 fwdata
->seqnum
= cardp
->fwseqnum
;
341 cardp
->lastseqnum
= fwdata
->seqnum
;
342 cardp
->totalbytes
+= fwdata
->fwheader
.datalength
;
344 if (fwheader
->dnldcmd
== FW_HAS_DATA_TO_RECV
) {
346 lbs_deb_usbd(&cardp->udev->dev, "There is data to follow\n");
347 lbs_deb_usbd(&cardp->udev->dev,
348 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
351 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
352 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
354 } else if (fwdata
->fwheader
.dnldcmd
== FW_HAS_LAST_BLOCK
) {
356 lbs_deb_usbd(&cardp->udev->dev,
357 "Host has finished FW downloading\n");
358 lbs_deb_usbd(&cardp->udev->dev,
359 "Donwloading FW JUMP BLOCK\n");
361 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
362 usb_tx_block(priv
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
363 cardp
->fwfinalblk
= 1;
367 lbs_deb_usbd(&cardp->udev->dev,
368 "The firmware download is done size is %d\n",
377 static int libertas_do_reset(wlan_private
*priv
)
380 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
382 lbs_deb_enter(LBS_DEB_USB
);
384 ret
= usb_reset_device(cardp
->udev
);
391 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
397 * @brief This function transfer the data to the device.
398 * @param priv pointer to wlan_private
399 * @param payload pointer to payload data
400 * @param nb data length
403 int usb_tx_block(wlan_private
* priv
, u8
* payload
, u16 nb
)
405 /* pointer to card structure */
406 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
409 /* check if device is removed */
410 if (priv
->adapter
->surpriseremoved
) {
411 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
415 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
416 usb_sndbulkpipe(cardp
->udev
,
417 cardp
->bulk_out_endpointAddr
),
418 payload
, nb
, if_usb_write_bulk_callback
, priv
);
420 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
422 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
423 /* transfer failed */
424 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed\n");
427 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
435 static int __if_usb_submit_rx_urb(wlan_private
* priv
,
439 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
441 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
444 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
445 lbs_pr_err("No free skb\n");
451 /* Fill the receive configuration URB and initialise the Rx call back */
452 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
453 usb_rcvbulkpipe(cardp
->udev
,
454 cardp
->bulk_in_endpointAddr
),
455 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
456 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
459 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
461 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
462 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
463 /* handle failure conditions */
464 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed\n");
467 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
475 static inline int if_usb_submit_rx_urb_fwload(wlan_private
* priv
)
477 return __if_usb_submit_rx_urb(priv
, &if_usb_receive_fwload
);
480 static inline int if_usb_submit_rx_urb(wlan_private
* priv
)
482 return __if_usb_submit_rx_urb(priv
, &if_usb_receive
);
485 static void if_usb_receive_fwload(struct urb
*urb
)
487 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
488 wlan_private
*priv
= rinfo
->priv
;
489 struct sk_buff
*skb
= rinfo
->skb
;
490 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
491 struct fwsyncheader
*syncfwheader
;
492 struct bootcmdrespStr bootcmdresp
;
495 lbs_deb_usbd(&cardp
->udev
->dev
,
496 "URB status is failed during fw load\n");
501 if (cardp
->bootcmdresp
== 0) {
502 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
503 sizeof(bootcmdresp
));
504 if (cardp
->udev
->descriptor
.bcdDevice
< 0x3106) {
506 if_usb_submit_rx_urb_fwload(priv
);
507 cardp
->bootcmdresp
= 1;
508 lbs_deb_usbd(&cardp
->udev
->dev
,
509 "Received valid boot command response\n");
512 if (bootcmdresp
.u32magicnumber
!= BOOT_CMD_MAGIC_NUMBER
) {
514 "boot cmd response wrong magic number (0x%x)\n",
515 bootcmdresp
.u32magicnumber
);
516 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
518 "boot cmd response cmd_tag error (%d)\n",
519 bootcmdresp
.u8cmd_tag
);
520 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
522 "boot cmd response result error (%d)\n",
523 bootcmdresp
.u8result
);
525 cardp
->bootcmdresp
= 1;
526 lbs_deb_usbd(&cardp
->udev
->dev
,
527 "Received valid boot command response\n");
530 if_usb_submit_rx_urb_fwload(priv
);
534 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
536 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
541 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
542 sizeof(struct fwsyncheader
));
544 if (!syncfwheader
->cmd
) {
546 lbs_deb_usbd(&cardp->udev->dev,
547 "FW received Blk with correct CRC\n");
548 lbs_deb_usbd(&cardp->udev->dev,
549 "FW received Blk seqnum = %d\n",
550 syncfwheader->seqnum);
554 lbs_deb_usbd(&cardp
->udev
->dev
,
555 "FW received Blk with CRC error\n");
561 if (cardp
->fwfinalblk
) {
562 cardp
->fwdnldover
= 1;
566 if_prog_firmware(priv
);
568 if_usb_submit_rx_urb_fwload(priv
);
576 #define MRVDRV_MIN_PKT_LEN 30
578 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
579 struct usb_card_rec
*cardp
,
582 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
583 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
584 lbs_deb_usbd(&cardp
->udev
->dev
,
585 "Packet length is Invalid\n");
590 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
591 skb_put(skb
, recvlength
);
592 skb_pull(skb
, MESSAGE_HEADER_LEN
);
593 libertas_process_rxed_packet(priv
, skb
);
594 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
597 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
599 struct usb_card_rec
*cardp
,
603 if (recvlength
> MRVDRV_SIZE_OF_CMD_BUFFER
) {
604 lbs_deb_usbd(&cardp
->udev
->dev
,
605 "The receive buffer is too large\n");
613 spin_lock(&priv
->adapter
->driver_lock
);
614 /* take care of cur_cmd = NULL case by reading the
615 * data to clear the interrupt */
616 if (!priv
->adapter
->cur_cmd
) {
617 cmdbuf
= priv
->wlan_dev
.upld_buf
;
618 priv
->adapter
->hisregcpy
&= ~his_cmdupldrdy
;
620 cmdbuf
= priv
->adapter
->cur_cmd
->bufvirtualaddr
;
622 cardp
->usb_int_cause
|= his_cmdupldrdy
;
623 priv
->wlan_dev
.upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
624 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
625 priv
->wlan_dev
.upld_len
);
628 libertas_interrupt(priv
->wlan_dev
.netdev
);
629 spin_unlock(&priv
->adapter
->driver_lock
);
631 lbs_deb_usbd(&cardp
->udev
->dev
,
632 "Wake up main thread to handle cmd response\n");
638 * @brief This function reads of the packet into the upload buff,
639 * wake up the main thread and initialise the Rx callack.
641 * @param urb pointer to struct urb
644 static void if_usb_receive(struct urb
*urb
)
646 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
647 wlan_private
*priv
= rinfo
->priv
;
648 struct sk_buff
*skb
= rinfo
->skb
;
649 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
651 int recvlength
= urb
->actual_length
;
655 lbs_deb_enter(LBS_DEB_USB
);
659 lbs_deb_usbd(&cardp
->udev
->dev
,
660 "URB status is failed\n");
665 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
666 memcpy(&recvtype
, recvbuff
, sizeof(u32
));
667 lbs_deb_usbd(&cardp
->udev
->dev
,
668 "Recv length = 0x%x\n", recvlength
);
669 lbs_deb_usbd(&cardp
->udev
->dev
,
670 "Receive type = 0x%X\n", recvtype
);
671 recvtype
= le32_to_cpu(recvtype
);
672 lbs_deb_usbd(&cardp
->udev
->dev
,
673 "Receive type after = 0x%X\n", recvtype
);
674 } else if (urb
->status
)
680 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
683 case CMD_TYPE_REQUEST
:
684 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
687 case CMD_TYPE_INDICATION
:
688 /* Event cause handling */
689 spin_lock(&priv
->adapter
->driver_lock
);
690 cardp
->usb_event_cause
= *(u32
*) (recvbuff
+ MESSAGE_HEADER_LEN
);
691 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
692 cardp
->usb_event_cause
);
693 if (cardp
->usb_event_cause
& 0xffff0000) {
694 libertas_send_tx_feedback(priv
);
695 spin_unlock(&priv
->adapter
->driver_lock
);
698 cardp
->usb_event_cause
= le32_to_cpu(cardp
->usb_event_cause
) << 3;
699 cardp
->usb_int_cause
|= his_cardevent
;
701 libertas_interrupt(priv
->wlan_dev
.netdev
);
702 spin_unlock(&priv
->adapter
->driver_lock
);
710 if_usb_submit_rx_urb(priv
);
712 lbs_deb_leave(LBS_DEB_USB
);
716 * @brief This function downloads data to FW
717 * @param priv pointer to wlan_private structure
718 * @param type type of data
719 * @param buf pointer to data buffer
720 * @param len number of bytes
723 static int if_usb_host_to_card(wlan_private
* priv
, u8 type
, u8
* payload
, u16 nb
)
727 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
729 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
730 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
732 if (type
== MVMS_CMD
) {
733 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
734 priv
->wlan_dev
.dnld_sent
= DNLD_CMD_SENT
;
735 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
739 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
740 priv
->wlan_dev
.dnld_sent
= DNLD_DATA_SENT
;
741 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
745 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
748 usb_tx_block(priv
, cardp
->bulk_out_buffer
, nb
+ MESSAGE_HEADER_LEN
);
753 /* called with adapter->driver_lock held */
754 static int if_usb_get_int_status(wlan_private
* priv
, u8
* ireg
)
756 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
758 *ireg
= cardp
->usb_int_cause
;
759 cardp
->usb_int_cause
= 0;
761 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
766 static int if_usb_read_event_cause(wlan_private
* priv
)
768 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
769 priv
->adapter
->eventcause
= cardp
->usb_event_cause
;
770 /* Re-submit rx urb here to avoid event lost issue */
771 if_usb_submit_rx_urb(priv
);
775 static int reset_device(wlan_private
*priv
)
779 lbs_deb_enter(LBS_DEB_USB
);
780 ret
= libertas_prepare_and_send_command(priv
, cmd_802_11_reset
,
781 cmd_act_halt
, 0, 0, NULL
);
782 msleep_interruptible(10);
784 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
788 static int if_usb_unregister_dev(wlan_private
* priv
)
792 /* Need to send a Reset command to device before USB resources freed
793 * and wlan_remove_card() called, then device can handle FW download
804 * @brief This function register usb device and initialize parameter
805 * @param priv pointer to wlan_private
808 static int if_usb_register_dev(wlan_private
* priv
)
810 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->wlan_dev
.card
;
812 lbs_deb_enter(LBS_DEB_USB
);
815 cardp
->eth_dev
= priv
->wlan_dev
.netdev
;
816 priv
->hotplug_device
= &(cardp
->udev
->dev
);
818 SET_NETDEV_DEV(cardp
->eth_dev
, &(cardp
->udev
->dev
));
819 SET_NETDEV_DEV(priv
->mesh_dev
, &(cardp
->udev
->dev
));
821 lbs_deb_usbd(&cardp
->udev
->dev
, "udev pointer is at %p\n",
824 lbs_deb_leave(LBS_DEB_USB
);
830 static int if_usb_prog_firmware(wlan_private
* priv
)
832 struct usb_card_rec
*cardp
= priv
->wlan_dev
.card
;
834 static int reset_count
= 10;
837 lbs_deb_enter(LBS_DEB_USB
);
839 cardp
->rinfo
.priv
= priv
;
842 if (if_usb_submit_rx_urb_fwload(priv
) < 0) {
843 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
848 cardp
->bootcmdresp
= 0;
852 /* Issue Boot command = 1, Boot from Download-FW */
853 if_usb_issue_boot_command(priv
, BOOT_CMD_FW_BY_USB
);
854 /* wait for command response */
857 msleep_interruptible(100);
858 } while (cardp
->bootcmdresp
== 0 && j
< 10);
859 } while (cardp
->bootcmdresp
== 0 && i
< 5);
861 if (cardp
->bootcmdresp
== 0) {
862 if (--reset_count
>= 0) {
863 libertas_do_reset(priv
);
870 priv
->adapter
->fw_ready
= 0;
872 cardp
->totalbytes
= 0;
873 cardp
->fwlastblksent
= 0;
875 cardp
->fwdnldover
= 0;
876 cardp
->fwseqnum
= -1;
877 cardp
->totalbytes
= 0;
878 cardp
->fwfinalblk
= 0;
880 if_prog_firmware(priv
);
883 lbs_deb_usbd(&cardp
->udev
->dev
,"Wlan sched timeout\n");
885 msleep_interruptible(100);
886 if (priv
->adapter
->surpriseremoved
|| i
>= 20)
888 } while (!cardp
->fwdnldover
);
890 if (!cardp
->fwdnldover
) {
891 lbs_pr_info("failed to load fw, resetting device!\n");
892 if (--reset_count
>= 0) {
893 libertas_do_reset(priv
);
897 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
902 if_usb_submit_rx_urb(priv
);
904 /* Delay 200 ms to waiting for the FW ready */
905 msleep_interruptible(200);
907 priv
->adapter
->fw_ready
= 1;
910 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
915 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
917 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
918 wlan_private
*priv
= cardp
->priv
;
920 lbs_deb_enter(LBS_DEB_USB
);
922 if (priv
->adapter
->psstate
!= PS_STATE_FULL_POWER
)
925 netif_device_detach(cardp
->eth_dev
);
926 netif_device_detach(priv
->mesh_dev
);
928 /* Unlink tx & rx urb */
929 usb_kill_urb(cardp
->tx_urb
);
930 usb_kill_urb(cardp
->rx_urb
);
932 cardp
->rx_urb_recall
= 1;
934 lbs_deb_leave(LBS_DEB_USB
);
938 static int if_usb_resume(struct usb_interface
*intf
)
940 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
941 wlan_private
*priv
= cardp
->priv
;
943 lbs_deb_enter(LBS_DEB_USB
);
945 cardp
->rx_urb_recall
= 0;
947 if_usb_submit_rx_urb(cardp
->priv
);
949 netif_device_attach(cardp
->eth_dev
);
950 netif_device_attach(priv
->mesh_dev
);
952 lbs_deb_leave(LBS_DEB_USB
);
956 #define if_usb_suspend NULL
957 #define if_usb_resume NULL
960 static struct usb_driver if_usb_driver
= {
962 .name
= usbdriver_name
,
963 /* probe function name */
964 .probe
= if_usb_probe
,
965 /* disconnect function name */
966 .disconnect
= if_usb_disconnect
,
967 /* device signature table */
968 .id_table
= if_usb_table
,
969 .suspend
= if_usb_suspend
,
970 .resume
= if_usb_resume
,
973 static int if_usb_init_module(void)
977 lbs_deb_enter(LBS_DEB_MAIN
);
979 if (libertas_fw_name
== NULL
) {
980 libertas_fw_name
= default_fw_name
;
983 ret
= usb_register(&if_usb_driver
);
985 lbs_deb_leave_args(LBS_DEB_MAIN
, "ret %d", ret
);
989 static void if_usb_exit_module(void)
993 lbs_deb_enter(LBS_DEB_MAIN
);
995 for (i
= 0; i
<libertas_found
; i
++) {
996 wlan_private
*priv
= libertas_devs
[i
]->priv
;
1000 /* API unregisters the driver from USB subsystem */
1001 usb_deregister(&if_usb_driver
);
1003 lbs_deb_leave(LBS_DEB_MAIN
);
1006 module_init(if_usb_init_module
);
1007 module_exit(if_usb_exit_module
);
1009 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1010 MODULE_AUTHOR("Marvell International Ltd.");
1011 MODULE_LICENSE("GPL");