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>
10 #define DRV_NAME "usb8xxx"
19 #define MESSAGE_HEADER_LEN 4
21 static char *lbs_fw_name
= "usb8388.bin";
22 module_param_named(fw_name
, lbs_fw_name
, charp
, 0644);
24 static struct usb_device_id if_usb_table
[] = {
25 /* Enter the device signature inside */
26 { USB_DEVICE(0x1286, 0x2001) },
27 { USB_DEVICE(0x05a3, 0x8388) },
28 {} /* Terminating entry */
31 MODULE_DEVICE_TABLE(usb
, if_usb_table
);
33 static void if_usb_receive(struct urb
*urb
);
34 static void if_usb_receive_fwload(struct urb
*urb
);
35 static int if_usb_prog_firmware(struct usb_card_rec
*cardp
);
36 static int if_usb_host_to_card(struct lbs_private
*priv
,
40 static int if_usb_get_int_status(struct lbs_private
*priv
, u8
*);
41 static int if_usb_read_event_cause(struct lbs_private
*);
42 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
*payload
, u16 nb
);
43 static void if_usb_free(struct usb_card_rec
*cardp
);
44 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
);
45 static int if_usb_reset_device(struct usb_card_rec
*cardp
);
48 * @brief call back function to handle the status of the URB
49 * @param urb pointer to urb structure
52 static void if_usb_write_bulk_callback(struct urb
*urb
)
54 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) urb
->context
;
56 /* handle the transmission complete validations */
58 if (urb
->status
== 0) {
59 struct lbs_private
*priv
= cardp
->priv
;
62 lbs_deb_usbd(&urb->dev->dev, "URB status is successfull\n");
63 lbs_deb_usbd(&urb->dev->dev, "Actual length transmitted %d\n",
67 /* Used for both firmware TX and regular TX. priv isn't
68 * valid at firmware load time.
71 lbs_host_to_card_done(priv
);
73 /* print the failure status number for debug */
74 lbs_pr_info("URB in failure status: %d\n", urb
->status
);
81 * @brief free tx/rx urb, skb and rx buffer
82 * @param cardp pointer usb_card_rec
85 static void if_usb_free(struct usb_card_rec
*cardp
)
87 lbs_deb_enter(LBS_DEB_USB
);
89 /* Unlink tx & rx urb */
90 usb_kill_urb(cardp
->tx_urb
);
91 usb_kill_urb(cardp
->rx_urb
);
93 usb_free_urb(cardp
->tx_urb
);
96 usb_free_urb(cardp
->rx_urb
);
99 kfree(cardp
->bulk_out_buffer
);
100 cardp
->bulk_out_buffer
= NULL
;
102 lbs_deb_leave(LBS_DEB_USB
);
105 static void if_usb_set_boot2_ver(struct lbs_private
*priv
)
107 struct cmd_ds_set_boot2_ver b2_cmd
;
110 b2_cmd
.version
= priv
->boot2_version
;
112 if (lbs_cmd(priv
, CMD_SET_BOOT2_VER
, b2_cmd
, NULL
, 0))
113 lbs_deb_usb("Setting boot2 version failed\n");
116 static void if_usb_fw_timeo(unsigned long priv
)
118 struct usb_card_rec
*cardp
= (void *)priv
;
120 if (cardp
->fwdnldover
) {
121 lbs_deb_usb("Download complete, no event. Assuming success\n");
123 lbs_pr_err("Download timed out\n");
124 cardp
->surprise_removed
= 1;
126 wake_up(&cardp
->fw_wq
);
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
;
140 struct lbs_private
*priv
;
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");
152 setup_timer(&cardp
->fw_timeout
, if_usb_fw_timeo
, (unsigned long)cardp
);
153 init_waitqueue_head(&cardp
->fw_wq
);
156 iface_desc
= intf
->cur_altsetting
;
158 lbs_deb_usbd(&udev
->dev
, "bcdUSB = 0x%X bDeviceClass = 0x%X"
159 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
160 le16_to_cpu(udev
->descriptor
.bcdUSB
),
161 udev
->descriptor
.bDeviceClass
,
162 udev
->descriptor
.bDeviceSubClass
,
163 udev
->descriptor
.bDeviceProtocol
);
165 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
166 endpoint
= &iface_desc
->endpoint
[i
].desc
;
167 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
168 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
169 USB_ENDPOINT_XFER_BULK
)) {
170 /* we found a bulk in endpoint */
171 lbs_deb_usbd(&udev
->dev
, "Bulk in size is %d\n",
172 le16_to_cpu(endpoint
->wMaxPacketSize
));
173 if (!(cardp
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
174 lbs_deb_usbd(&udev
->dev
,
175 "Rx URB allocation failed\n");
178 cardp
->rx_urb_recall
= 0;
180 cardp
->bulk_in_size
=
181 le16_to_cpu(endpoint
->wMaxPacketSize
);
182 cardp
->bulk_in_endpointAddr
=
184 bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
185 lbs_deb_usbd(&udev
->dev
, "in_endpoint = %d\n",
186 endpoint
->bEndpointAddress
);
190 bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) ==
192 && ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
193 USB_ENDPOINT_XFER_BULK
)) {
194 /* We found bulk out endpoint */
195 if (!(cardp
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
196 lbs_deb_usbd(&udev
->dev
,
197 "Tx URB allocation failed\n");
201 cardp
->bulk_out_size
=
202 le16_to_cpu(endpoint
->wMaxPacketSize
);
203 lbs_deb_usbd(&udev
->dev
,
204 "Bulk out size is %d\n",
205 le16_to_cpu(endpoint
->wMaxPacketSize
));
206 cardp
->bulk_out_endpointAddr
=
207 endpoint
->bEndpointAddress
;
208 lbs_deb_usbd(&udev
->dev
, "out_endpoint = %d\n",
209 endpoint
->bEndpointAddress
);
210 cardp
->bulk_out_buffer
=
211 kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE
,
214 if (!cardp
->bulk_out_buffer
) {
215 lbs_deb_usbd(&udev
->dev
,
216 "Could not allocate buffer\n");
222 /* Upload firmware */
223 cardp
->rinfo
.cardp
= cardp
;
224 if (if_usb_prog_firmware(cardp
)) {
225 lbs_deb_usbd(&udev
->dev
, "FW upload failed");
226 goto err_prog_firmware
;
229 if (!(priv
= lbs_add_card(cardp
, &udev
->dev
)))
230 goto err_prog_firmware
;
233 cardp
->priv
->fw_ready
= 1;
235 cardp
->eth_dev
= priv
->dev
;
237 priv
->hw_host_to_card
= if_usb_host_to_card
;
238 priv
->hw_get_int_status
= if_usb_get_int_status
;
239 priv
->hw_read_event_cause
= if_usb_read_event_cause
;
240 priv
->boot2_version
= udev
->descriptor
.bcdDevice
;
242 if_usb_submit_rx_urb(cardp
);
244 if (lbs_start_card(priv
))
247 if_usb_set_boot2_ver(priv
);
250 usb_set_intfdata(intf
, cardp
);
255 lbs_remove_card(priv
);
257 if_usb_reset_device(cardp
);
266 * @brief free resource and cleanup
267 * @param intf USB interface structure
270 static void if_usb_disconnect(struct usb_interface
*intf
)
272 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
273 struct lbs_private
*priv
= (struct lbs_private
*) cardp
->priv
;
275 lbs_deb_enter(LBS_DEB_MAIN
);
277 /* Update Surprise removed to TRUE */
278 cardp
->surprise_removed
= 1;
282 priv
->surpriseremoved
= 1;
284 lbs_remove_card(priv
);
287 /* this is (apparently?) necessary for future usage of the device */
288 lbs_prepare_and_send_command(priv
, CMD_802_11_RESET
, CMD_ACT_HALT
,
291 /* Unlink and free urb */
294 usb_set_intfdata(intf
, NULL
);
295 usb_put_dev(interface_to_usbdev(intf
));
297 lbs_deb_leave(LBS_DEB_MAIN
);
301 * @brief This function download FW
302 * @param priv pointer to struct lbs_private
305 static int if_usb_send_fw_pkt(struct usb_card_rec
*cardp
)
307 struct FWData
*fwdata
;
308 struct fwheader
*fwheader
;
309 u8
*firmware
= cardp
->fw
->data
;
311 fwdata
= kmalloc(sizeof(struct FWData
), GFP_ATOMIC
);
316 fwheader
= &fwdata
->fwheader
;
318 if (!cardp
->CRC_OK
) {
319 cardp
->totalbytes
= cardp
->fwlastblksent
;
320 cardp
->fwseqnum
= cardp
->lastseqnum
- 1;
324 lbs_deb_usbd(&cardp->udev->dev, "totalbytes = %d\n",
328 memcpy(fwheader
, &firmware
[cardp
->totalbytes
],
329 sizeof(struct fwheader
));
331 cardp
->fwlastblksent
= cardp
->totalbytes
;
332 cardp
->totalbytes
+= sizeof(struct fwheader
);
334 /* lbs_deb_usbd(&cardp->udev->dev,"Copy Data\n"); */
335 memcpy(fwdata
->data
, &firmware
[cardp
->totalbytes
],
336 le32_to_cpu(fwdata
->fwheader
.datalength
));
339 lbs_deb_usbd(&cardp->udev->dev,
340 "Data length = %d\n", le32_to_cpu(fwdata->fwheader.datalength));
343 cardp
->fwseqnum
= cardp
->fwseqnum
+ 1;
345 fwdata
->seqnum
= cpu_to_le32(cardp
->fwseqnum
);
346 cardp
->lastseqnum
= cardp
->fwseqnum
;
347 cardp
->totalbytes
+= le32_to_cpu(fwdata
->fwheader
.datalength
);
349 if (fwheader
->dnldcmd
== cpu_to_le32(FW_HAS_DATA_TO_RECV
)) {
351 lbs_deb_usbd(&cardp->udev->dev, "There are data to follow\n");
352 lbs_deb_usbd(&cardp->udev->dev,
353 "seqnum = %d totalbytes = %d\n", cardp->fwseqnum,
356 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
357 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
359 } else if (fwdata
->fwheader
.dnldcmd
== cpu_to_le32(FW_HAS_LAST_BLOCK
)) {
361 lbs_deb_usbd(&cardp->udev->dev,
362 "Host has finished FW downloading\n");
363 lbs_deb_usbd(&cardp->udev->dev,
364 "Donwloading FW JUMP BLOCK\n");
366 memcpy(cardp
->bulk_out_buffer
, fwheader
, FW_DATA_XMIT_SIZE
);
367 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, FW_DATA_XMIT_SIZE
);
368 cardp
->fwfinalblk
= 1;
372 lbs_deb_usbd(&cardp->udev->dev,
373 "The firmware download is done size is %d\n",
382 static int if_usb_reset_device(struct usb_card_rec
*cardp
)
384 struct cmd_ds_command
*cmd
= (void *)&cardp
->bulk_out_buffer
[4];
387 lbs_deb_enter(LBS_DEB_USB
);
389 *(__le32
*)cardp
->bulk_out_buffer
= cpu_to_le32(CMD_TYPE_REQUEST
);
391 cmd
->command
= cpu_to_le16(CMD_802_11_RESET
);
392 cmd
->size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_reset
) + S_DS_GEN
);
393 cmd
->result
= cpu_to_le16(0);
394 cmd
->seqnum
= cpu_to_le16(0x5a5a);
395 cmd
->params
.reset
.action
= cpu_to_le16(CMD_ACT_HALT
);
396 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, 4 + S_DS_GEN
+ sizeof(struct cmd_ds_802_11_reset
));
399 ret
= usb_reset_device(cardp
->udev
);
402 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
408 * @brief This function transfer the data to the device.
409 * @param priv pointer to struct lbs_private
410 * @param payload pointer to payload data
411 * @param nb data length
414 static int usb_tx_block(struct usb_card_rec
*cardp
, u8
* payload
, u16 nb
)
418 /* check if device is removed */
419 if (cardp
->surprise_removed
) {
420 lbs_deb_usbd(&cardp
->udev
->dev
, "Device removed\n");
424 usb_fill_bulk_urb(cardp
->tx_urb
, cardp
->udev
,
425 usb_sndbulkpipe(cardp
->udev
,
426 cardp
->bulk_out_endpointAddr
),
427 payload
, nb
, if_usb_write_bulk_callback
, cardp
);
429 cardp
->tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
431 if ((ret
= usb_submit_urb(cardp
->tx_urb
, GFP_ATOMIC
))) {
432 /* transfer failed */
433 lbs_deb_usbd(&cardp
->udev
->dev
, "usb_submit_urb failed: %d\n", ret
);
436 /* lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb success\n"); */
444 static int __if_usb_submit_rx_urb(struct usb_card_rec
*cardp
,
445 void (*callbackfn
)(struct urb
*urb
))
448 struct read_cb_info
*rinfo
= &cardp
->rinfo
;
451 if (!(skb
= dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
))) {
452 lbs_pr_err("No free skb\n");
458 /* Fill the receive configuration URB and initialise the Rx call back */
459 usb_fill_bulk_urb(cardp
->rx_urb
, cardp
->udev
,
460 usb_rcvbulkpipe(cardp
->udev
,
461 cardp
->bulk_in_endpointAddr
),
462 (void *) (skb
->tail
+ (size_t) IPFIELD_ALIGN_OFFSET
),
463 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
, callbackfn
,
466 cardp
->rx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
468 /* lbs_deb_usbd(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); */
469 if ((ret
= usb_submit_urb(cardp
->rx_urb
, GFP_ATOMIC
))) {
470 /* handle failure conditions */
471 lbs_deb_usbd(&cardp
->udev
->dev
, "Submit Rx URB failed: %d\n", ret
);
476 /* lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB success\n"); */
484 static int if_usb_submit_rx_urb_fwload(struct usb_card_rec
*cardp
)
486 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive_fwload
);
489 static int if_usb_submit_rx_urb(struct usb_card_rec
*cardp
)
491 return __if_usb_submit_rx_urb(cardp
, &if_usb_receive
);
494 static void if_usb_receive_fwload(struct urb
*urb
)
496 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
497 struct sk_buff
*skb
= rinfo
->skb
;
498 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)rinfo
->cardp
;
499 struct fwsyncheader
*syncfwheader
;
500 struct bootcmdrespStr bootcmdresp
;
503 lbs_deb_usbd(&cardp
->udev
->dev
,
504 "URB status is failed during fw load\n");
509 if (cardp
->fwdnldover
) {
510 __le32
*tmp
= (__le32
*)(skb
->data
+ IPFIELD_ALIGN_OFFSET
);
512 if (tmp
[0] == cpu_to_le32(CMD_TYPE_INDICATION
) &&
513 tmp
[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY
)) {
514 lbs_pr_info("Firmware ready event received\n");
515 wake_up(&cardp
->fw_wq
);
517 lbs_deb_usb("Waiting for confirmation; got %x %x\n", le32_to_cpu(tmp
[0]),
518 le32_to_cpu(tmp
[1]));
519 if_usb_submit_rx_urb_fwload(cardp
);
524 if (cardp
->bootcmdresp
<= 0) {
525 memcpy (&bootcmdresp
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
526 sizeof(bootcmdresp
));
527 if (le16_to_cpu(cardp
->udev
->descriptor
.bcdDevice
) < 0x3106) {
529 if_usb_submit_rx_urb_fwload(cardp
);
530 cardp
->bootcmdresp
= 1;
531 lbs_deb_usbd(&cardp
->udev
->dev
,
532 "Received valid boot command response\n");
535 if (bootcmdresp
.u32magicnumber
!= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
)) {
536 if (bootcmdresp
.u32magicnumber
== cpu_to_le32(CMD_TYPE_REQUEST
) ||
537 bootcmdresp
.u32magicnumber
== cpu_to_le32(CMD_TYPE_DATA
) ||
538 bootcmdresp
.u32magicnumber
== cpu_to_le32(CMD_TYPE_INDICATION
)) {
539 if (!cardp
->bootcmdresp
)
540 lbs_pr_info("Firmware already seems alive; resetting\n");
541 cardp
->bootcmdresp
= -1;
543 lbs_pr_info("boot cmd response wrong magic number (0x%x)\n",
544 le32_to_cpu(bootcmdresp
.u32magicnumber
));
546 } else if (bootcmdresp
.u8cmd_tag
!= BOOT_CMD_FW_BY_USB
) {
548 "boot cmd response cmd_tag error (%d)\n",
549 bootcmdresp
.u8cmd_tag
);
550 } else if (bootcmdresp
.u8result
!= BOOT_CMD_RESP_OK
) {
552 "boot cmd response result error (%d)\n",
553 bootcmdresp
.u8result
);
555 cardp
->bootcmdresp
= 1;
556 lbs_deb_usbd(&cardp
->udev
->dev
,
557 "Received valid boot command response\n");
560 if_usb_submit_rx_urb_fwload(cardp
);
564 syncfwheader
= kmalloc(sizeof(struct fwsyncheader
), GFP_ATOMIC
);
566 lbs_deb_usbd(&cardp
->udev
->dev
, "Failure to allocate syncfwheader\n");
571 memcpy(syncfwheader
, skb
->data
+ IPFIELD_ALIGN_OFFSET
,
572 sizeof(struct fwsyncheader
));
574 if (!syncfwheader
->cmd
) {
576 lbs_deb_usbd(&cardp->udev->dev,
577 "FW received Blk with correct CRC\n");
578 lbs_deb_usbd(&cardp->udev->dev,
579 "FW received Blk seqnum = %d\n",
580 syncfwheader->seqnum);
584 lbs_deb_usbd(&cardp
->udev
->dev
,
585 "FW received Blk with CRC error\n");
591 /* reschedule timer for 200ms hence */
592 mod_timer(&cardp
->fw_timeout
, jiffies
+ (HZ
/5));
594 if (cardp
->fwfinalblk
) {
595 cardp
->fwdnldover
= 1;
599 if_usb_send_fw_pkt(cardp
);
602 if_usb_submit_rx_urb_fwload(cardp
);
609 #define MRVDRV_MIN_PKT_LEN 30
611 static inline void process_cmdtypedata(int recvlength
, struct sk_buff
*skb
,
612 struct usb_card_rec
*cardp
,
613 struct lbs_private
*priv
)
615 if (recvlength
> MRVDRV_ETH_RX_PACKET_BUFFER_SIZE
+
616 MESSAGE_HEADER_LEN
|| recvlength
< MRVDRV_MIN_PKT_LEN
) {
617 lbs_deb_usbd(&cardp
->udev
->dev
,
618 "Packet length is Invalid\n");
623 skb_reserve(skb
, IPFIELD_ALIGN_OFFSET
);
624 skb_put(skb
, recvlength
);
625 skb_pull(skb
, MESSAGE_HEADER_LEN
);
626 lbs_process_rxed_packet(priv
, skb
);
627 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
630 static inline void process_cmdrequest(int recvlength
, u8
*recvbuff
,
632 struct usb_card_rec
*cardp
,
633 struct lbs_private
*priv
)
636 if (recvlength
> LBS_CMD_BUFFER_SIZE
) {
637 lbs_deb_usbd(&cardp
->udev
->dev
,
638 "The receive buffer is too large\n");
646 spin_lock(&priv
->driver_lock
);
647 /* take care of cur_cmd = NULL case by reading the
648 * data to clear the interrupt */
649 if (!priv
->cur_cmd
) {
650 cmdbuf
= priv
->upld_buf
;
651 priv
->hisregcpy
&= ~MRVDRV_CMD_UPLD_RDY
;
653 cmdbuf
= (u8
*) priv
->cur_cmd
->cmdbuf
;
655 cardp
->usb_int_cause
|= MRVDRV_CMD_UPLD_RDY
;
656 priv
->upld_len
= (recvlength
- MESSAGE_HEADER_LEN
);
657 memcpy(cmdbuf
, recvbuff
+ MESSAGE_HEADER_LEN
,
662 spin_unlock(&priv
->driver_lock
);
664 lbs_deb_usbd(&cardp
->udev
->dev
,
665 "Wake up main thread to handle cmd response\n");
671 * @brief This function reads of the packet into the upload buff,
672 * wake up the main thread and initialise the Rx callack.
674 * @param urb pointer to struct urb
677 static void if_usb_receive(struct urb
*urb
)
679 struct read_cb_info
*rinfo
= (struct read_cb_info
*)urb
->context
;
680 struct sk_buff
*skb
= rinfo
->skb
;
681 struct usb_card_rec
*cardp
= (struct usb_card_rec
*) rinfo
->cardp
;
682 struct lbs_private
*priv
= cardp
->priv
;
684 int recvlength
= urb
->actual_length
;
688 lbs_deb_enter(LBS_DEB_USB
);
694 lbs_deb_usbd(&cardp
->udev
->dev
,
695 "URB status is failed\n");
700 recvbuff
= skb
->data
+ IPFIELD_ALIGN_OFFSET
;
701 memcpy(&tmp
, recvbuff
, sizeof(u32
));
702 recvtype
= le32_to_cpu(tmp
);
703 lbs_deb_usbd(&cardp
->udev
->dev
,
704 "Recv length = 0x%x, Recv type = 0x%X\n",
705 recvlength
, recvtype
);
706 } else if (urb
->status
) {
713 process_cmdtypedata(recvlength
, skb
, cardp
, priv
);
716 case CMD_TYPE_REQUEST
:
717 process_cmdrequest(recvlength
, recvbuff
, skb
, cardp
, priv
);
720 case CMD_TYPE_INDICATION
:
721 /* Event cause handling */
722 spin_lock(&priv
->driver_lock
);
723 cardp
->usb_event_cause
= le32_to_cpu(*(__le32
*) (recvbuff
+ MESSAGE_HEADER_LEN
));
724 lbs_deb_usbd(&cardp
->udev
->dev
,"**EVENT** 0x%X\n",
725 cardp
->usb_event_cause
);
726 if (cardp
->usb_event_cause
& 0xffff0000) {
727 lbs_send_tx_feedback(priv
);
728 spin_unlock(&priv
->driver_lock
);
731 cardp
->usb_event_cause
<<= 3;
732 cardp
->usb_int_cause
|= MRVDRV_CARDEVENT
;
735 spin_unlock(&priv
->driver_lock
);
738 lbs_deb_usbd(&cardp
->udev
->dev
, "Unknown command type 0x%X\n",
745 if_usb_submit_rx_urb(cardp
);
747 lbs_deb_leave(LBS_DEB_USB
);
751 * @brief This function downloads data to FW
752 * @param priv pointer to struct lbs_private structure
753 * @param type type of data
754 * @param buf pointer to data buffer
755 * @param len number of bytes
758 static int if_usb_host_to_card(struct lbs_private
*priv
,
763 struct usb_card_rec
*cardp
= (struct usb_card_rec
*)priv
->card
;
765 lbs_deb_usbd(&cardp
->udev
->dev
,"*** type = %u\n", type
);
766 lbs_deb_usbd(&cardp
->udev
->dev
,"size after = %d\n", nb
);
768 if (type
== MVMS_CMD
) {
769 __le32 tmp
= cpu_to_le32(CMD_TYPE_REQUEST
);
770 priv
->dnld_sent
= DNLD_CMD_SENT
;
771 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
775 __le32 tmp
= cpu_to_le32(CMD_TYPE_DATA
);
776 priv
->dnld_sent
= DNLD_DATA_SENT
;
777 memcpy(cardp
->bulk_out_buffer
, (u8
*) & tmp
,
781 memcpy((cardp
->bulk_out_buffer
+ MESSAGE_HEADER_LEN
), payload
, nb
);
783 return usb_tx_block(cardp
, cardp
->bulk_out_buffer
,
784 nb
+ MESSAGE_HEADER_LEN
);
787 /* called with priv->driver_lock held */
788 static int if_usb_get_int_status(struct lbs_private
*priv
, u8
*ireg
)
790 struct usb_card_rec
*cardp
= priv
->card
;
792 *ireg
= cardp
->usb_int_cause
;
793 cardp
->usb_int_cause
= 0;
795 lbs_deb_usbd(&cardp
->udev
->dev
,"Int cause is 0x%X\n", *ireg
);
800 static int if_usb_read_event_cause(struct lbs_private
*priv
)
802 struct usb_card_rec
*cardp
= priv
->card
;
804 priv
->eventcause
= cardp
->usb_event_cause
;
805 /* Re-submit rx urb here to avoid event lost issue */
806 if_usb_submit_rx_urb(cardp
);
811 * @brief This function issues Boot command to the Boot2 code
812 * @param ivalue 1:Boot from FW by USB-Download
813 * 2:Boot from FW in EEPROM
816 static int if_usb_issue_boot_command(struct usb_card_rec
*cardp
, int ivalue
)
818 struct bootcmdstr sbootcmd
;
821 /* Prepare command */
822 sbootcmd
.u32magicnumber
= cpu_to_le32(BOOT_CMD_MAGIC_NUMBER
);
823 sbootcmd
.u8cmd_tag
= ivalue
;
825 sbootcmd
.au8dumy
[i
]=0x00;
826 memcpy(cardp
->bulk_out_buffer
, &sbootcmd
, sizeof(struct bootcmdstr
));
829 usb_tx_block(cardp
, cardp
->bulk_out_buffer
, sizeof(struct bootcmdstr
));
836 * @brief This function checks the validity of Boot2/FW image.
838 * @param data pointer to image
842 static int check_fwfile_format(u8
*data
, u32 totlen
)
845 u32 blksize
, offset
, len
;
852 struct fwheader
*fwh
= (void *)data
;
854 bincmd
= le32_to_cpu(fwh
->dnldcmd
);
855 blksize
= le32_to_cpu(fwh
->datalength
);
857 case FW_HAS_DATA_TO_RECV
:
858 offset
= sizeof(struct fwheader
) + blksize
;
864 case FW_HAS_LAST_BLOCK
:
875 lbs_pr_err("firmware file format check FAIL\n");
877 lbs_deb_fw("firmware file format check PASS\n");
883 static int if_usb_prog_firmware(struct usb_card_rec
*cardp
)
886 static int reset_count
= 10;
889 lbs_deb_enter(LBS_DEB_USB
);
891 if ((ret
= request_firmware(&cardp
->fw
, lbs_fw_name
,
892 &cardp
->udev
->dev
)) < 0) {
893 lbs_pr_err("request_firmware() failed with %#x\n", ret
);
894 lbs_pr_err("firmware %s not found\n", lbs_fw_name
);
898 if (check_fwfile_format(cardp
->fw
->data
, cardp
->fw
->size
))
902 if (if_usb_submit_rx_urb_fwload(cardp
) < 0) {
903 lbs_deb_usbd(&cardp
->udev
->dev
, "URB submission is failed\n");
908 cardp
->bootcmdresp
= 0;
912 /* Issue Boot command = 1, Boot from Download-FW */
913 if_usb_issue_boot_command(cardp
, BOOT_CMD_FW_BY_USB
);
914 /* wait for command response */
917 msleep_interruptible(100);
918 } while (cardp
->bootcmdresp
== 0 && j
< 10);
919 } while (cardp
->bootcmdresp
== 0 && i
< 5);
921 if (cardp
->bootcmdresp
<= 0) {
922 if (--reset_count
>= 0) {
923 if_usb_reset_device(cardp
);
931 cardp
->totalbytes
= 0;
932 cardp
->fwlastblksent
= 0;
934 cardp
->fwdnldover
= 0;
935 cardp
->fwseqnum
= -1;
936 cardp
->totalbytes
= 0;
937 cardp
->fwfinalblk
= 0;
939 /* Send the first firmware packet... */
940 if_usb_send_fw_pkt(cardp
);
942 /* ... and wait for the process to complete */
943 wait_event_interruptible(cardp
->fw_wq
, cardp
->surprise_removed
|| cardp
->fwdnldover
);
945 del_timer_sync(&cardp
->fw_timeout
);
946 usb_kill_urb(cardp
->rx_urb
);
948 if (!cardp
->fwdnldover
) {
949 lbs_pr_info("failed to load fw, resetting device!\n");
950 if (--reset_count
>= 0) {
951 if_usb_reset_device(cardp
);
955 lbs_pr_info("FW download failure, time = %d ms\n", i
* 100);
961 release_firmware(cardp
->fw
);
965 lbs_deb_leave_args(LBS_DEB_USB
, "ret %d", ret
);
971 static int if_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
973 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
974 struct lbs_private
*priv
= cardp
->priv
;
976 lbs_deb_enter(LBS_DEB_USB
);
978 if (priv
->psstate
!= PS_STATE_FULL_POWER
)
981 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
982 /* Mesh autostart must be activated while sleeping
983 * On resume it will go back to the current state
985 struct cmd_ds_mesh_access mesh_access
;
986 memset(&mesh_access
, 0, sizeof(mesh_access
));
988 mesh_access
.data
[0] = cpu_to_le32(1);
989 lbs_mesh_access(priv
, CMD_ACT_MESH_SET_AUTOSTART_ENABLED
, &mesh_access
);
992 netif_device_detach(cardp
->eth_dev
);
993 netif_device_detach(priv
->mesh_dev
);
995 /* Unlink tx & rx urb */
996 usb_kill_urb(cardp
->tx_urb
);
997 usb_kill_urb(cardp
->rx_urb
);
999 cardp
->rx_urb_recall
= 1;
1001 lbs_deb_leave(LBS_DEB_USB
);
1005 static int if_usb_resume(struct usb_interface
*intf
)
1007 struct usb_card_rec
*cardp
= usb_get_intfdata(intf
);
1008 struct lbs_private
*priv
= cardp
->priv
;
1010 lbs_deb_enter(LBS_DEB_USB
);
1012 cardp
->rx_urb_recall
= 0;
1014 if_usb_submit_rx_urb(cardp
);
1016 netif_device_attach(cardp
->eth_dev
);
1017 netif_device_attach(priv
->mesh_dev
);
1019 if (priv
->mesh_dev
&& !priv
->mesh_autostart_enabled
) {
1020 /* Mesh autostart was activated while sleeping
1021 * Disable it if appropriate
1023 struct cmd_ds_mesh_access mesh_access
;
1024 memset(&mesh_access
, 0, sizeof(mesh_access
));
1025 mesh_access
.data
[0] = cpu_to_le32(0);
1026 lbs_mesh_access(priv
, CMD_ACT_MESH_SET_AUTOSTART_ENABLED
, &mesh_access
);
1029 lbs_deb_leave(LBS_DEB_USB
);
1033 #define if_usb_suspend NULL
1034 #define if_usb_resume NULL
1037 static struct usb_driver if_usb_driver
= {
1039 .probe
= if_usb_probe
,
1040 .disconnect
= if_usb_disconnect
,
1041 .id_table
= if_usb_table
,
1042 .suspend
= if_usb_suspend
,
1043 .resume
= if_usb_resume
,
1046 static int __init
if_usb_init_module(void)
1050 lbs_deb_enter(LBS_DEB_MAIN
);
1052 ret
= usb_register(&if_usb_driver
);
1054 lbs_deb_leave_args(LBS_DEB_MAIN
, "ret %d", ret
);
1058 static void __exit
if_usb_exit_module(void)
1060 lbs_deb_enter(LBS_DEB_MAIN
);
1062 usb_deregister(&if_usb_driver
);
1064 lbs_deb_leave(LBS_DEB_MAIN
);
1067 module_init(if_usb_init_module
);
1068 module_exit(if_usb_exit_module
);
1070 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1071 MODULE_AUTHOR("Marvell International Ltd.");
1072 MODULE_LICENSE("GPL");