2 * Marvell Wireless LAN device driver: USB specific handling
4 * Copyright (C) 2012-2014, Marvell International Ltd.
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
23 #define USB_VERSION "1.0"
25 static struct mwifiex_if_ops usb_ops
;
27 static struct usb_device_id mwifiex_usb_table
[] = {
29 {USB_DEVICE(USB8XXX_VID
, USB8766_PID_1
)},
30 {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID
, USB8766_PID_2
,
31 USB_CLASS_VENDOR_SPEC
,
32 USB_SUBCLASS_VENDOR_SPEC
, 0xff)},
34 {USB_DEVICE(USB8XXX_VID
, USB8797_PID_1
)},
35 {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID
, USB8797_PID_2
,
36 USB_CLASS_VENDOR_SPEC
,
37 USB_SUBCLASS_VENDOR_SPEC
, 0xff)},
39 {USB_DEVICE(USB8XXX_VID
, USB8801_PID_1
)},
40 {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID
, USB8801_PID_2
,
41 USB_CLASS_VENDOR_SPEC
,
42 USB_SUBCLASS_VENDOR_SPEC
, 0xff)},
44 {USB_DEVICE(USB8XXX_VID
, USB8997_PID_1
)},
45 {USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID
, USB8997_PID_2
,
46 USB_CLASS_VENDOR_SPEC
,
47 USB_SUBCLASS_VENDOR_SPEC
, 0xff)},
48 { } /* Terminating entry */
51 MODULE_DEVICE_TABLE(usb
, mwifiex_usb_table
);
53 static int mwifiex_usb_submit_rx_urb(struct urb_context
*ctx
, int size
);
55 /* This function handles received packet. Necessary action is taken based on
58 static int mwifiex_usb_recv(struct mwifiex_adapter
*adapter
,
59 struct sk_buff
*skb
, u8 ep
)
65 if (adapter
->hs_activated
)
66 mwifiex_process_hs_config(adapter
);
68 if (skb
->len
< INTF_HEADER_LEN
) {
69 mwifiex_dbg(adapter
, ERROR
,
70 "%s: invalid skb->len\n", __func__
);
75 case MWIFIEX_USB_EP_CMD_EVENT
:
76 mwifiex_dbg(adapter
, EVENT
,
77 "%s: EP_CMD_EVENT\n", __func__
);
78 skb_copy_from_linear_data(skb
, &tmp
, INTF_HEADER_LEN
);
79 recv_type
= le32_to_cpu(tmp
);
80 skb_pull(skb
, INTF_HEADER_LEN
);
83 case MWIFIEX_USB_TYPE_CMD
:
84 if (skb
->len
> MWIFIEX_SIZE_OF_CMD_BUFFER
) {
85 mwifiex_dbg(adapter
, ERROR
,
86 "CMD: skb->len too large\n");
88 goto exit_restore_skb
;
89 } else if (!adapter
->curr_cmd
) {
90 mwifiex_dbg(adapter
, WARN
, "CMD: no curr_cmd\n");
91 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
92 mwifiex_process_sleep_confirm_resp(
96 goto exit_restore_skb
;
99 goto exit_restore_skb
;
102 adapter
->curr_cmd
->resp_skb
= skb
;
103 adapter
->cmd_resp_received
= true;
105 case MWIFIEX_USB_TYPE_EVENT
:
106 if (skb
->len
< sizeof(u32
)) {
107 mwifiex_dbg(adapter
, ERROR
,
108 "EVENT: skb->len too small\n");
110 goto exit_restore_skb
;
112 skb_copy_from_linear_data(skb
, &tmp
, sizeof(u32
));
113 adapter
->event_cause
= le32_to_cpu(tmp
);
114 mwifiex_dbg(adapter
, EVENT
,
115 "event_cause %#x\n", adapter
->event_cause
);
117 if (skb
->len
> MAX_EVENT_SIZE
) {
118 mwifiex_dbg(adapter
, ERROR
,
119 "EVENT: event body too large\n");
121 goto exit_restore_skb
;
124 memcpy(adapter
->event_body
, skb
->data
+
125 MWIFIEX_EVENT_HEADER_LEN
, skb
->len
);
127 adapter
->event_received
= true;
128 adapter
->event_skb
= skb
;
131 mwifiex_dbg(adapter
, ERROR
,
132 "unknown recv_type %#x\n", recv_type
);
136 case MWIFIEX_USB_EP_DATA
:
137 mwifiex_dbg(adapter
, DATA
, "%s: EP_DATA\n", __func__
);
138 if (skb
->len
> MWIFIEX_RX_DATA_BUF_SIZE
) {
139 mwifiex_dbg(adapter
, ERROR
,
140 "DATA: skb->len too large\n");
144 skb_queue_tail(&adapter
->rx_data_q
, skb
);
145 adapter
->data_received
= true;
146 atomic_inc(&adapter
->rx_pending
);
149 mwifiex_dbg(adapter
, ERROR
,
150 "%s: unknown endport %#x\n", __func__
, ep
);
157 /* The buffer will be reused for further cmds/events */
158 skb_push(skb
, INTF_HEADER_LEN
);
163 static void mwifiex_usb_rx_complete(struct urb
*urb
)
165 struct urb_context
*context
= (struct urb_context
*)urb
->context
;
166 struct mwifiex_adapter
*adapter
= context
->adapter
;
167 struct sk_buff
*skb
= context
->skb
;
168 struct usb_card_rec
*card
;
169 int recv_length
= urb
->actual_length
;
172 if (!adapter
|| !adapter
->card
) {
173 pr_err("mwifiex adapter or card structure is not valid\n");
177 card
= (struct usb_card_rec
*)adapter
->card
;
178 if (card
->rx_cmd_ep
== context
->ep
)
179 atomic_dec(&card
->rx_cmd_urb_pending
);
181 atomic_dec(&card
->rx_data_urb_pending
);
184 if (urb
->status
|| (adapter
->surprise_removed
)) {
185 mwifiex_dbg(adapter
, ERROR
,
186 "URB status is failed: %d\n", urb
->status
);
187 /* Do not free skb in case of command ep */
188 if (card
->rx_cmd_ep
!= context
->ep
)
189 dev_kfree_skb_any(skb
);
192 if (skb
->len
> recv_length
)
193 skb_trim(skb
, recv_length
);
195 skb_put(skb
, recv_length
- skb
->len
);
197 status
= mwifiex_usb_recv(adapter
, skb
, context
->ep
);
199 mwifiex_dbg(adapter
, INFO
,
200 "info: recv_length=%d, status=%d\n",
201 recv_length
, status
);
202 if (status
== -EINPROGRESS
) {
203 mwifiex_queue_main_work(adapter
);
205 /* urb for data_ep is re-submitted now;
206 * urb for cmd_ep will be re-submitted in callback
207 * mwifiex_usb_recv_complete
209 if (card
->rx_cmd_ep
== context
->ep
)
213 mwifiex_dbg(adapter
, ERROR
,
214 "received data processing failed!\n");
216 /* Do not free skb in case of command ep */
217 if (card
->rx_cmd_ep
!= context
->ep
)
218 dev_kfree_skb_any(skb
);
220 } else if (urb
->status
) {
221 if (!adapter
->is_suspended
) {
222 mwifiex_dbg(adapter
, FATAL
,
223 "Card is removed: %d\n", urb
->status
);
224 adapter
->surprise_removed
= true;
226 dev_kfree_skb_any(skb
);
229 /* Do not free skb in case of command ep */
230 if (card
->rx_cmd_ep
!= context
->ep
)
231 dev_kfree_skb_any(skb
);
233 /* fall through setup_for_next */
237 if (card
->rx_cmd_ep
== context
->ep
)
238 size
= MWIFIEX_RX_CMD_BUF_SIZE
;
240 size
= MWIFIEX_RX_DATA_BUF_SIZE
;
242 if (card
->rx_cmd_ep
== context
->ep
) {
243 mwifiex_usb_submit_rx_urb(context
, size
);
245 if (atomic_read(&adapter
->rx_pending
) <= HIGH_RX_PENDING
) {
246 mwifiex_usb_submit_rx_urb(context
, size
);
255 static void mwifiex_usb_tx_complete(struct urb
*urb
)
257 struct urb_context
*context
= (struct urb_context
*)(urb
->context
);
258 struct mwifiex_adapter
*adapter
= context
->adapter
;
259 struct usb_card_rec
*card
= adapter
->card
;
260 struct usb_tx_data_port
*port
;
263 mwifiex_dbg(adapter
, INFO
,
264 "%s: status: %d\n", __func__
, urb
->status
);
266 if (context
->ep
== card
->tx_cmd_ep
) {
267 mwifiex_dbg(adapter
, CMD
,
268 "%s: CMD\n", __func__
);
269 atomic_dec(&card
->tx_cmd_urb_pending
);
270 adapter
->cmd_sent
= false;
272 mwifiex_dbg(adapter
, DATA
,
273 "%s: DATA\n", __func__
);
274 mwifiex_write_data_complete(adapter
, context
->skb
, 0,
275 urb
->status
? -1 : 0);
276 for (i
= 0; i
< MWIFIEX_TX_DATA_PORT
; i
++) {
277 port
= &card
->port
[i
];
278 if (context
->ep
== port
->tx_data_ep
) {
279 atomic_dec(&port
->tx_data_urb_pending
);
280 port
->block_status
= false;
284 adapter
->data_sent
= false;
287 if (card
->mc_resync_flag
)
288 mwifiex_multi_chan_resync(adapter
);
290 mwifiex_queue_main_work(adapter
);
295 static int mwifiex_usb_submit_rx_urb(struct urb_context
*ctx
, int size
)
297 struct mwifiex_adapter
*adapter
= ctx
->adapter
;
298 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
300 if (card
->rx_cmd_ep
!= ctx
->ep
) {
301 ctx
->skb
= dev_alloc_skb(size
);
303 mwifiex_dbg(adapter
, ERROR
,
304 "%s: dev_alloc_skb failed\n", __func__
);
309 if (card
->rx_cmd_ep
== ctx
->ep
&&
310 card
->rx_cmd_ep_type
== USB_ENDPOINT_XFER_INT
)
311 usb_fill_int_urb(ctx
->urb
, card
->udev
,
312 usb_rcvintpipe(card
->udev
, ctx
->ep
),
313 ctx
->skb
->data
, size
, mwifiex_usb_rx_complete
,
314 (void *)ctx
, card
->rx_cmd_interval
);
316 usb_fill_bulk_urb(ctx
->urb
, card
->udev
,
317 usb_rcvbulkpipe(card
->udev
, ctx
->ep
),
318 ctx
->skb
->data
, size
, mwifiex_usb_rx_complete
,
321 if (card
->rx_cmd_ep
== ctx
->ep
)
322 atomic_inc(&card
->rx_cmd_urb_pending
);
324 atomic_inc(&card
->rx_data_urb_pending
);
326 if (usb_submit_urb(ctx
->urb
, GFP_ATOMIC
)) {
327 mwifiex_dbg(adapter
, ERROR
, "usb_submit_urb failed\n");
328 dev_kfree_skb_any(ctx
->skb
);
331 if (card
->rx_cmd_ep
== ctx
->ep
)
332 atomic_dec(&card
->rx_cmd_urb_pending
);
334 atomic_dec(&card
->rx_data_urb_pending
);
342 static void mwifiex_usb_free(struct usb_card_rec
*card
)
344 struct usb_tx_data_port
*port
;
347 if (atomic_read(&card
->rx_cmd_urb_pending
) && card
->rx_cmd
.urb
)
348 usb_kill_urb(card
->rx_cmd
.urb
);
350 usb_free_urb(card
->rx_cmd
.urb
);
351 card
->rx_cmd
.urb
= NULL
;
353 if (atomic_read(&card
->rx_data_urb_pending
))
354 for (i
= 0; i
< MWIFIEX_RX_DATA_URB
; i
++)
355 if (card
->rx_data_list
[i
].urb
)
356 usb_kill_urb(card
->rx_data_list
[i
].urb
);
358 for (i
= 0; i
< MWIFIEX_RX_DATA_URB
; i
++) {
359 usb_free_urb(card
->rx_data_list
[i
].urb
);
360 card
->rx_data_list
[i
].urb
= NULL
;
363 for (i
= 0; i
< MWIFIEX_TX_DATA_PORT
; i
++) {
364 port
= &card
->port
[i
];
365 for (j
= 0; j
< MWIFIEX_TX_DATA_URB
; j
++) {
366 usb_kill_urb(port
->tx_data_list
[j
].urb
);
367 usb_free_urb(port
->tx_data_list
[j
].urb
);
368 port
->tx_data_list
[j
].urb
= NULL
;
372 usb_free_urb(card
->tx_cmd
.urb
);
373 card
->tx_cmd
.urb
= NULL
;
378 /* This function probes an mwifiex device and registers it. It allocates
379 * the card structure, initiates the device registration and initialization
380 * procedure by adding a logical interface.
382 static int mwifiex_usb_probe(struct usb_interface
*intf
,
383 const struct usb_device_id
*id
)
385 struct usb_device
*udev
= interface_to_usbdev(intf
);
386 struct usb_host_interface
*iface_desc
= intf
->cur_altsetting
;
387 struct usb_endpoint_descriptor
*epd
;
389 struct usb_card_rec
*card
;
390 u16 id_vendor
, id_product
, bcd_device
;
392 card
= devm_kzalloc(&intf
->dev
, sizeof(*card
), GFP_KERNEL
);
396 init_completion(&card
->fw_done
);
398 id_vendor
= le16_to_cpu(udev
->descriptor
.idVendor
);
399 id_product
= le16_to_cpu(udev
->descriptor
.idProduct
);
400 bcd_device
= le16_to_cpu(udev
->descriptor
.bcdDevice
);
401 pr_debug("info: VID/PID = %X/%X, Boot2 version = %X\n",
402 id_vendor
, id_product
, bcd_device
);
404 /* PID_1 is used for firmware downloading only */
405 switch (id_product
) {
410 card
->usb_boot_state
= USB8XXX_FW_DNLD
;
416 card
->usb_boot_state
= USB8XXX_FW_READY
;
419 pr_warn("unknown id_product %#x\n", id_product
);
420 card
->usb_boot_state
= USB8XXX_FW_DNLD
;
427 pr_debug("info: bcdUSB=%#x Device Class=%#x SubClass=%#x Protocol=%#x\n",
428 le16_to_cpu(udev
->descriptor
.bcdUSB
),
429 udev
->descriptor
.bDeviceClass
,
430 udev
->descriptor
.bDeviceSubClass
,
431 udev
->descriptor
.bDeviceProtocol
);
433 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
434 epd
= &iface_desc
->endpoint
[i
].desc
;
435 if (usb_endpoint_dir_in(epd
) &&
436 usb_endpoint_num(epd
) == MWIFIEX_USB_EP_CMD_EVENT
&&
437 (usb_endpoint_xfer_bulk(epd
) ||
438 usb_endpoint_xfer_int(epd
))) {
439 card
->rx_cmd_ep_type
= usb_endpoint_type(epd
);
440 card
->rx_cmd_interval
= epd
->bInterval
;
441 pr_debug("info: Rx CMD/EVT:: max pkt size: %d, addr: %d, ep_type: %d\n",
442 le16_to_cpu(epd
->wMaxPacketSize
),
443 epd
->bEndpointAddress
, card
->rx_cmd_ep_type
);
444 card
->rx_cmd_ep
= usb_endpoint_num(epd
);
445 atomic_set(&card
->rx_cmd_urb_pending
, 0);
447 if (usb_endpoint_dir_in(epd
) &&
448 usb_endpoint_num(epd
) == MWIFIEX_USB_EP_DATA
&&
449 usb_endpoint_xfer_bulk(epd
)) {
450 pr_debug("info: bulk IN: max pkt size: %d, addr: %d\n",
451 le16_to_cpu(epd
->wMaxPacketSize
),
452 epd
->bEndpointAddress
);
453 card
->rx_data_ep
= usb_endpoint_num(epd
);
454 atomic_set(&card
->rx_data_urb_pending
, 0);
456 if (usb_endpoint_dir_out(epd
) &&
457 usb_endpoint_num(epd
) == MWIFIEX_USB_EP_DATA
&&
458 usb_endpoint_xfer_bulk(epd
)) {
459 pr_debug("info: bulk OUT: max pkt size: %d, addr: %d\n",
460 le16_to_cpu(epd
->wMaxPacketSize
),
461 epd
->bEndpointAddress
);
462 card
->port
[0].tx_data_ep
= usb_endpoint_num(epd
);
463 atomic_set(&card
->port
[0].tx_data_urb_pending
, 0);
465 if (usb_endpoint_dir_out(epd
) &&
466 usb_endpoint_num(epd
) == MWIFIEX_USB_EP_DATA_CH2
&&
467 usb_endpoint_xfer_bulk(epd
)) {
468 pr_debug("info: bulk OUT chan2:\t"
469 "max pkt size: %d, addr: %d\n",
470 le16_to_cpu(epd
->wMaxPacketSize
),
471 epd
->bEndpointAddress
);
472 card
->port
[1].tx_data_ep
= usb_endpoint_num(epd
);
473 atomic_set(&card
->port
[1].tx_data_urb_pending
, 0);
475 if (usb_endpoint_dir_out(epd
) &&
476 usb_endpoint_num(epd
) == MWIFIEX_USB_EP_CMD_EVENT
&&
477 (usb_endpoint_xfer_bulk(epd
) ||
478 usb_endpoint_xfer_int(epd
))) {
479 card
->tx_cmd_ep_type
= usb_endpoint_type(epd
);
480 card
->tx_cmd_interval
= epd
->bInterval
;
481 pr_debug("info: bulk OUT: max pkt size: %d, addr: %d\n",
482 le16_to_cpu(epd
->wMaxPacketSize
),
483 epd
->bEndpointAddress
);
484 pr_debug("info: Tx CMD:: max pkt size: %d, addr: %d, ep_type: %d\n",
485 le16_to_cpu(epd
->wMaxPacketSize
),
486 epd
->bEndpointAddress
, card
->tx_cmd_ep_type
);
487 card
->tx_cmd_ep
= usb_endpoint_num(epd
);
488 atomic_set(&card
->tx_cmd_urb_pending
, 0);
489 card
->bulk_out_maxpktsize
=
490 le16_to_cpu(epd
->wMaxPacketSize
);
494 usb_set_intfdata(intf
, card
);
496 ret
= mwifiex_add_card(card
, &card
->fw_done
, &usb_ops
,
497 MWIFIEX_USB
, &card
->udev
->dev
);
499 pr_err("%s: mwifiex_add_card failed: %d\n", __func__
, ret
);
500 usb_reset_device(udev
);
509 /* Kernel needs to suspend all functions separately. Therefore all
510 * registered functions must have drivers with suspend and resume
511 * methods. Failing that the kernel simply removes the whole card.
513 * If already not suspended, this function allocates and sends a
514 * 'host sleep activate' request to the firmware and turns off the traffic.
516 static int mwifiex_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
518 struct usb_card_rec
*card
= usb_get_intfdata(intf
);
519 struct mwifiex_adapter
*adapter
;
520 struct usb_tx_data_port
*port
;
523 /* Might still be loading firmware */
524 wait_for_completion(&card
->fw_done
);
526 adapter
= card
->adapter
;
528 dev_err(&intf
->dev
, "card is not valid\n");
532 if (unlikely(adapter
->is_suspended
))
533 mwifiex_dbg(adapter
, WARN
,
534 "Device already suspended\n");
536 /* Enable the Host Sleep */
537 if (!mwifiex_enable_hs(adapter
)) {
538 mwifiex_dbg(adapter
, ERROR
,
539 "cmd: failed to suspend\n");
540 adapter
->hs_enabling
= false;
545 /* 'is_suspended' flag indicates device is suspended.
546 * It must be set here before the usb_kill_urb() calls. Reason
547 * is in the complete handlers, urb->status(= -ENOENT) and
548 * this flag is used in combination to distinguish between a
549 * 'suspended' state and a 'disconnect' one.
551 adapter
->is_suspended
= true;
552 adapter
->hs_enabling
= false;
554 if (atomic_read(&card
->rx_cmd_urb_pending
) && card
->rx_cmd
.urb
)
555 usb_kill_urb(card
->rx_cmd
.urb
);
557 if (atomic_read(&card
->rx_data_urb_pending
))
558 for (i
= 0; i
< MWIFIEX_RX_DATA_URB
; i
++)
559 if (card
->rx_data_list
[i
].urb
)
560 usb_kill_urb(card
->rx_data_list
[i
].urb
);
562 for (i
= 0; i
< MWIFIEX_TX_DATA_PORT
; i
++) {
563 port
= &card
->port
[i
];
564 for (j
= 0; j
< MWIFIEX_TX_DATA_URB
; j
++) {
565 if (port
->tx_data_list
[j
].urb
)
566 usb_kill_urb(port
->tx_data_list
[j
].urb
);
570 if (card
->tx_cmd
.urb
)
571 usb_kill_urb(card
->tx_cmd
.urb
);
576 /* Kernel needs to suspend all functions separately. Therefore all
577 * registered functions must have drivers with suspend and resume
578 * methods. Failing that the kernel simply removes the whole card.
580 * If already not resumed, this function turns on the traffic and
581 * sends a 'host sleep cancel' request to the firmware.
583 static int mwifiex_usb_resume(struct usb_interface
*intf
)
585 struct usb_card_rec
*card
= usb_get_intfdata(intf
);
586 struct mwifiex_adapter
*adapter
;
589 if (!card
->adapter
) {
590 dev_err(&intf
->dev
, "%s: card->adapter is NULL\n",
594 adapter
= card
->adapter
;
596 if (unlikely(!adapter
->is_suspended
)) {
597 mwifiex_dbg(adapter
, WARN
,
598 "Device already resumed\n");
602 /* Indicate device resumed. The netdev queue will be resumed only
603 * after the urbs have been re-submitted
605 adapter
->is_suspended
= false;
607 if (!atomic_read(&card
->rx_data_urb_pending
))
608 for (i
= 0; i
< MWIFIEX_RX_DATA_URB
; i
++)
609 mwifiex_usb_submit_rx_urb(&card
->rx_data_list
[i
],
610 MWIFIEX_RX_DATA_BUF_SIZE
);
612 if (!atomic_read(&card
->rx_cmd_urb_pending
)) {
613 card
->rx_cmd
.skb
= dev_alloc_skb(MWIFIEX_RX_CMD_BUF_SIZE
);
614 if (card
->rx_cmd
.skb
)
615 mwifiex_usb_submit_rx_urb(&card
->rx_cmd
,
616 MWIFIEX_RX_CMD_BUF_SIZE
);
619 /* Disable Host Sleep */
620 if (adapter
->hs_activated
)
621 mwifiex_cancel_hs(mwifiex_get_priv(adapter
,
622 MWIFIEX_BSS_ROLE_ANY
),
628 static void mwifiex_usb_disconnect(struct usb_interface
*intf
)
630 struct usb_card_rec
*card
= usb_get_intfdata(intf
);
631 struct mwifiex_adapter
*adapter
;
633 wait_for_completion(&card
->fw_done
);
635 adapter
= card
->adapter
;
636 if (!adapter
|| !adapter
->priv_num
)
639 if (card
->udev
->state
!= USB_STATE_NOTATTACHED
&& !adapter
->mfg_mode
) {
640 mwifiex_deauthenticate_all(adapter
);
642 mwifiex_init_shutdown_fw(mwifiex_get_priv(adapter
,
643 MWIFIEX_BSS_ROLE_ANY
),
644 MWIFIEX_FUNC_SHUTDOWN
);
647 mwifiex_usb_free(card
);
649 mwifiex_dbg(adapter
, FATAL
,
650 "%s: removing card\n", __func__
);
651 mwifiex_remove_card(adapter
);
653 usb_put_dev(interface_to_usbdev(intf
));
656 static struct usb_driver mwifiex_usb_driver
= {
657 .name
= "mwifiex_usb",
658 .probe
= mwifiex_usb_probe
,
659 .disconnect
= mwifiex_usb_disconnect
,
660 .id_table
= mwifiex_usb_table
,
661 .suspend
= mwifiex_usb_suspend
,
662 .resume
= mwifiex_usb_resume
,
666 static int mwifiex_usb_tx_init(struct mwifiex_adapter
*adapter
)
668 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
669 struct usb_tx_data_port
*port
;
672 card
->tx_cmd
.adapter
= adapter
;
673 card
->tx_cmd
.ep
= card
->tx_cmd_ep
;
675 card
->tx_cmd
.urb
= usb_alloc_urb(0, GFP_KERNEL
);
676 if (!card
->tx_cmd
.urb
)
679 for (i
= 0; i
< MWIFIEX_TX_DATA_PORT
; i
++) {
680 port
= &card
->port
[i
];
681 if (!port
->tx_data_ep
)
683 port
->tx_data_ix
= 0;
684 skb_queue_head_init(&port
->tx_aggr
.aggr_list
);
685 if (port
->tx_data_ep
== MWIFIEX_USB_EP_DATA
)
686 port
->block_status
= false;
688 port
->block_status
= true;
689 for (j
= 0; j
< MWIFIEX_TX_DATA_URB
; j
++) {
690 port
->tx_data_list
[j
].adapter
= adapter
;
691 port
->tx_data_list
[j
].ep
= port
->tx_data_ep
;
692 port
->tx_data_list
[j
].urb
=
693 usb_alloc_urb(0, GFP_KERNEL
);
694 if (!port
->tx_data_list
[j
].urb
)
702 static int mwifiex_usb_rx_init(struct mwifiex_adapter
*adapter
)
704 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
707 card
->rx_cmd
.adapter
= adapter
;
708 card
->rx_cmd
.ep
= card
->rx_cmd_ep
;
710 card
->rx_cmd
.urb
= usb_alloc_urb(0, GFP_KERNEL
);
711 if (!card
->rx_cmd
.urb
)
714 card
->rx_cmd
.skb
= dev_alloc_skb(MWIFIEX_RX_CMD_BUF_SIZE
);
715 if (!card
->rx_cmd
.skb
)
718 if (mwifiex_usb_submit_rx_urb(&card
->rx_cmd
, MWIFIEX_RX_CMD_BUF_SIZE
))
721 for (i
= 0; i
< MWIFIEX_RX_DATA_URB
; i
++) {
722 card
->rx_data_list
[i
].adapter
= adapter
;
723 card
->rx_data_list
[i
].ep
= card
->rx_data_ep
;
725 card
->rx_data_list
[i
].urb
= usb_alloc_urb(0, GFP_KERNEL
);
726 if (!card
->rx_data_list
[i
].urb
)
728 if (mwifiex_usb_submit_rx_urb(&card
->rx_data_list
[i
],
729 MWIFIEX_RX_DATA_BUF_SIZE
))
736 static int mwifiex_write_data_sync(struct mwifiex_adapter
*adapter
, u8
*pbuf
,
737 u32
*len
, u8 ep
, u32 timeout
)
739 struct usb_card_rec
*card
= adapter
->card
;
740 int actual_length
, ret
;
742 if (!(*len
% card
->bulk_out_maxpktsize
))
745 /* Send the data block */
746 ret
= usb_bulk_msg(card
->udev
, usb_sndbulkpipe(card
->udev
, ep
), pbuf
,
747 *len
, &actual_length
, timeout
);
749 mwifiex_dbg(adapter
, ERROR
,
750 "usb_bulk_msg for tx failed: %d\n", ret
);
754 *len
= actual_length
;
759 static int mwifiex_read_data_sync(struct mwifiex_adapter
*adapter
, u8
*pbuf
,
760 u32
*len
, u8 ep
, u32 timeout
)
762 struct usb_card_rec
*card
= adapter
->card
;
763 int actual_length
, ret
;
765 /* Receive the data response */
766 ret
= usb_bulk_msg(card
->udev
, usb_rcvbulkpipe(card
->udev
, ep
), pbuf
,
767 *len
, &actual_length
, timeout
);
769 mwifiex_dbg(adapter
, ERROR
,
770 "usb_bulk_msg for rx failed: %d\n", ret
);
774 *len
= actual_length
;
779 static void mwifiex_usb_port_resync(struct mwifiex_adapter
*adapter
)
781 struct usb_card_rec
*card
= adapter
->card
;
782 u8 active_port
= MWIFIEX_USB_EP_DATA
;
783 struct mwifiex_private
*priv
= NULL
;
786 if (adapter
->usb_mc_status
) {
787 for (i
= 0; i
< adapter
->priv_num
; i
++) {
788 priv
= adapter
->priv
[i
];
791 if ((priv
->bss_role
== MWIFIEX_BSS_ROLE_UAP
&&
792 !priv
->bss_started
) ||
793 (priv
->bss_role
== MWIFIEX_BSS_ROLE_STA
&&
794 !priv
->media_connected
))
795 priv
->usb_port
= MWIFIEX_USB_EP_DATA
;
797 for (i
= 0; i
< MWIFIEX_TX_DATA_PORT
; i
++)
798 card
->port
[i
].block_status
= false;
800 for (i
= 0; i
< adapter
->priv_num
; i
++) {
801 priv
= adapter
->priv
[i
];
804 if ((priv
->bss_role
== MWIFIEX_BSS_ROLE_UAP
&&
805 priv
->bss_started
) ||
806 (priv
->bss_role
== MWIFIEX_BSS_ROLE_STA
&&
807 priv
->media_connected
)) {
808 active_port
= priv
->usb_port
;
812 for (i
= 0; i
< adapter
->priv_num
; i
++) {
813 priv
= adapter
->priv
[i
];
815 priv
->usb_port
= active_port
;
817 for (i
= 0; i
< MWIFIEX_TX_DATA_PORT
; i
++) {
818 if (active_port
== card
->port
[i
].tx_data_ep
)
819 card
->port
[i
].block_status
= false;
821 card
->port
[i
].block_status
= true;
826 static bool mwifiex_usb_is_port_ready(struct mwifiex_private
*priv
)
828 struct usb_card_rec
*card
= priv
->adapter
->card
;
831 for (idx
= 0; idx
< MWIFIEX_TX_DATA_PORT
; idx
++) {
832 if (priv
->usb_port
== card
->port
[idx
].tx_data_ep
)
833 return !card
->port
[idx
].block_status
;
839 static inline u8
mwifiex_usb_data_sent(struct mwifiex_adapter
*adapter
)
841 struct usb_card_rec
*card
= adapter
->card
;
844 for (i
= 0; i
< MWIFIEX_TX_DATA_PORT
; i
++)
845 if (!card
->port
[i
].block_status
)
851 static int mwifiex_usb_construct_send_urb(struct mwifiex_adapter
*adapter
,
852 struct usb_tx_data_port
*port
, u8 ep
,
853 struct urb_context
*context
,
854 struct sk_buff
*skb_send
)
856 struct usb_card_rec
*card
= adapter
->card
;
857 int ret
= -EINPROGRESS
;
860 context
->adapter
= adapter
;
862 context
->skb
= skb_send
;
863 tx_urb
= context
->urb
;
865 if (ep
== card
->tx_cmd_ep
&&
866 card
->tx_cmd_ep_type
== USB_ENDPOINT_XFER_INT
)
867 usb_fill_int_urb(tx_urb
, card
->udev
,
868 usb_sndintpipe(card
->udev
, ep
), skb_send
->data
,
869 skb_send
->len
, mwifiex_usb_tx_complete
,
870 (void *)context
, card
->tx_cmd_interval
);
872 usb_fill_bulk_urb(tx_urb
, card
->udev
,
873 usb_sndbulkpipe(card
->udev
, ep
),
874 skb_send
->data
, skb_send
->len
,
875 mwifiex_usb_tx_complete
, (void *)context
);
877 tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
879 if (ep
== card
->tx_cmd_ep
)
880 atomic_inc(&card
->tx_cmd_urb_pending
);
882 atomic_inc(&port
->tx_data_urb_pending
);
884 if (ep
!= card
->tx_cmd_ep
&&
885 atomic_read(&port
->tx_data_urb_pending
) ==
886 MWIFIEX_TX_DATA_URB
) {
887 port
->block_status
= true;
888 adapter
->data_sent
= mwifiex_usb_data_sent(adapter
);
892 if (usb_submit_urb(tx_urb
, GFP_ATOMIC
)) {
893 mwifiex_dbg(adapter
, ERROR
,
894 "%s: usb_submit_urb failed\n", __func__
);
895 if (ep
== card
->tx_cmd_ep
) {
896 atomic_dec(&card
->tx_cmd_urb_pending
);
898 atomic_dec(&port
->tx_data_urb_pending
);
899 port
->block_status
= false;
900 adapter
->data_sent
= false;
901 if (port
->tx_data_ix
)
904 port
->tx_data_ix
= MWIFIEX_TX_DATA_URB
;
912 static int mwifiex_usb_prepare_tx_aggr_skb(struct mwifiex_adapter
*adapter
,
913 struct usb_tx_data_port
*port
,
914 struct sk_buff
**skb_send
)
916 struct sk_buff
*skb_aggr
, *skb_tmp
;
918 u16 align
= adapter
->bus_aggr
.tx_aggr_align
;
919 struct mwifiex_txinfo
*tx_info
= NULL
;
920 bool is_txinfo_set
= false;
922 skb_aggr
= mwifiex_alloc_dma_align_buf(port
->tx_aggr
.aggr_len
,
925 mwifiex_dbg(adapter
, ERROR
,
926 "%s: alloc skb_aggr failed\n", __func__
);
928 while ((skb_tmp
= skb_dequeue(&port
->tx_aggr
.aggr_list
)))
929 mwifiex_write_data_complete(adapter
, skb_tmp
, 0, -1);
931 port
->tx_aggr
.aggr_num
= 0;
932 port
->tx_aggr
.aggr_len
= 0;
936 tx_info
= MWIFIEX_SKB_TXCB(skb_aggr
);
937 memset(tx_info
, 0, sizeof(*tx_info
));
939 while ((skb_tmp
= skb_dequeue(&port
->tx_aggr
.aggr_list
))) {
940 /* padding for aligning next packet header*/
941 pad
= (align
- (skb_tmp
->len
& (align
- 1))) % align
;
942 payload
= skb_put(skb_aggr
, skb_tmp
->len
+ pad
);
943 memcpy(payload
, skb_tmp
->data
, skb_tmp
->len
);
944 if (skb_queue_empty(&port
->tx_aggr
.aggr_list
)) {
945 /* do not padding for last packet*/
946 *(u16
*)payload
= cpu_to_le16(skb_tmp
->len
);
947 *(u16
*)&payload
[2] =
948 cpu_to_le16(MWIFIEX_TYPE_AGGR_DATA_V2
| 0x80);
949 skb_trim(skb_aggr
, skb_aggr
->len
- pad
);
951 /* add aggregation interface header */
952 *(u16
*)payload
= cpu_to_le16(skb_tmp
->len
+ pad
);
953 *(u16
*)&payload
[2] =
954 cpu_to_le16(MWIFIEX_TYPE_AGGR_DATA_V2
);
957 if (!is_txinfo_set
) {
958 tx_info
->bss_num
= MWIFIEX_SKB_TXCB(skb_tmp
)->bss_num
;
959 tx_info
->bss_type
= MWIFIEX_SKB_TXCB(skb_tmp
)->bss_type
;
960 is_txinfo_set
= true;
963 port
->tx_aggr
.aggr_num
--;
964 port
->tx_aggr
.aggr_len
-= (skb_tmp
->len
+ pad
);
965 mwifiex_write_data_complete(adapter
, skb_tmp
, 0, 0);
968 tx_info
->pkt_len
= skb_aggr
->len
-
969 (sizeof(struct txpd
) + adapter
->intf_hdr_len
);
970 tx_info
->flags
|= MWIFIEX_BUF_FLAG_AGGR_PKT
;
972 port
->tx_aggr
.aggr_num
= 0;
973 port
->tx_aggr
.aggr_len
= 0;
974 *skb_send
= skb_aggr
;
979 /* This function prepare data packet to be send under usb tx aggregation
980 * protocol, check current usb aggregation status, link packet to aggrgation
981 * list if possible, work flow as below:
982 * (1) if only 1 packet available, add usb tx aggregation header and send.
983 * (2) if packet is able to aggregated, link it to current aggregation list.
984 * (3) if packet is not able to aggregated, aggregate and send exist packets
985 * in aggrgation list. Then, link packet in the list if there is more
986 * packet in transmit queue, otherwise try to transmit single packet.
988 static int mwifiex_usb_aggr_tx_data(struct mwifiex_adapter
*adapter
, u8 ep
,
990 struct mwifiex_tx_param
*tx_param
,
991 struct usb_tx_data_port
*port
)
994 u16 align
= adapter
->bus_aggr
.tx_aggr_align
;
995 struct sk_buff
*skb_send
= NULL
;
996 struct urb_context
*context
= NULL
;
997 struct txpd
*local_tx_pd
=
998 (struct txpd
*)((u8
*)skb
->data
+ adapter
->intf_hdr_len
);
999 u8 f_send_aggr_buf
= 0;
1000 u8 f_send_cur_buf
= 0;
1001 u8 f_precopy_cur_buf
= 0;
1002 u8 f_postcopy_cur_buf
= 0;
1005 /* padding to ensure each packet alginment */
1006 pad
= (align
- (skb
->len
& (align
- 1))) % align
;
1008 if (tx_param
&& tx_param
->next_pkt_len
) {
1009 /* next packet available in tx queue*/
1010 if (port
->tx_aggr
.aggr_len
+ skb
->len
+ pad
>
1011 adapter
->bus_aggr
.tx_aggr_max_size
) {
1012 f_send_aggr_buf
= 1;
1013 f_postcopy_cur_buf
= 1;
1015 /* current packet could be aggregated*/
1016 f_precopy_cur_buf
= 1;
1018 if (port
->tx_aggr
.aggr_len
+ skb
->len
+ pad
+
1019 tx_param
->next_pkt_len
>
1020 adapter
->bus_aggr
.tx_aggr_max_size
||
1021 port
->tx_aggr
.aggr_num
+ 2 >
1022 adapter
->bus_aggr
.tx_aggr_max_num
) {
1023 /* next packet could not be aggregated
1024 * send current aggregation buffer
1026 f_send_aggr_buf
= 1;
1030 /* last packet in tx queue */
1031 if (port
->tx_aggr
.aggr_num
> 0) {
1032 /* pending packets in aggregation buffer*/
1033 if (port
->tx_aggr
.aggr_len
+ skb
->len
+ pad
>
1034 adapter
->bus_aggr
.tx_aggr_max_size
) {
1035 /* current packet not be able to aggregated,
1036 * send aggr buffer first, then send packet.
1040 /* last packet, Aggregation and send */
1041 f_precopy_cur_buf
= 1;
1044 f_send_aggr_buf
= 1;
1046 /* no pending packets in aggregation buffer,
1047 * send current packet immediately
1053 if (local_tx_pd
->flags
& MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET
) {
1054 /* Send NULL packet immediately*/
1055 if (f_precopy_cur_buf
) {
1056 if (skb_queue_empty(&port
->tx_aggr
.aggr_list
)) {
1057 f_precopy_cur_buf
= 0;
1058 f_send_aggr_buf
= 0;
1061 f_send_aggr_buf
= 1;
1063 } else if (f_postcopy_cur_buf
) {
1065 f_postcopy_cur_buf
= 0;
1069 if (f_precopy_cur_buf
) {
1070 skb_queue_tail(&port
->tx_aggr
.aggr_list
, skb
);
1071 port
->tx_aggr
.aggr_len
+= (skb
->len
+ pad
);
1072 port
->tx_aggr
.aggr_num
++;
1075 if (f_send_aggr_buf
) {
1076 ret
= mwifiex_usb_prepare_tx_aggr_skb(adapter
, port
, &skb_send
);
1078 context
= &port
->tx_data_list
[port
->tx_data_ix
++];
1079 ret
= mwifiex_usb_construct_send_urb(adapter
, port
, ep
,
1082 mwifiex_write_data_complete(adapter
, skb_send
,
1087 if (f_send_cur_buf
) {
1088 if (f_send_aggr_buf
) {
1089 if (atomic_read(&port
->tx_data_urb_pending
) >=
1090 MWIFIEX_TX_DATA_URB
) {
1091 port
->block_status
= true;
1092 adapter
->data_sent
=
1093 mwifiex_usb_data_sent(adapter
);
1094 /* no available urb, postcopy packet*/
1095 f_postcopy_cur_buf
= 1;
1096 goto postcopy_cur_buf
;
1099 if (port
->tx_data_ix
>= MWIFIEX_TX_DATA_URB
)
1100 port
->tx_data_ix
= 0;
1103 payload
= skb
->data
;
1104 *(u16
*)&payload
[2] =
1105 cpu_to_le16(MWIFIEX_TYPE_AGGR_DATA_V2
| 0x80);
1106 *(u16
*)payload
= cpu_to_le16(skb
->len
);
1108 context
= &port
->tx_data_list
[port
->tx_data_ix
++];
1109 return mwifiex_usb_construct_send_urb(adapter
, port
, ep
,
1114 if (f_postcopy_cur_buf
) {
1115 skb_queue_tail(&port
->tx_aggr
.aggr_list
, skb
);
1116 port
->tx_aggr
.aggr_len
+= (skb
->len
+ pad
);
1117 port
->tx_aggr
.aggr_num
++;
1120 return -EINPROGRESS
;
1123 /* This function write a command/data packet to card. */
1124 static int mwifiex_usb_host_to_card(struct mwifiex_adapter
*adapter
, u8 ep
,
1125 struct sk_buff
*skb
,
1126 struct mwifiex_tx_param
*tx_param
)
1128 struct usb_card_rec
*card
= adapter
->card
;
1129 struct urb_context
*context
= NULL
;
1130 struct usb_tx_data_port
*port
= NULL
;
1133 if (adapter
->is_suspended
) {
1134 mwifiex_dbg(adapter
, ERROR
,
1135 "%s: not allowed while suspended\n", __func__
);
1139 if (adapter
->surprise_removed
) {
1140 mwifiex_dbg(adapter
, ERROR
, "%s: device removed\n", __func__
);
1144 mwifiex_dbg(adapter
, INFO
, "%s: ep=%d\n", __func__
, ep
);
1146 if (ep
== card
->tx_cmd_ep
) {
1147 context
= &card
->tx_cmd
;
1149 /* get the data port structure for endpoint */
1150 for (idx
= 0; idx
< MWIFIEX_TX_DATA_PORT
; idx
++) {
1151 if (ep
== card
->port
[idx
].tx_data_ep
) {
1152 port
= &card
->port
[idx
];
1153 if (atomic_read(&port
->tx_data_urb_pending
)
1154 >= MWIFIEX_TX_DATA_URB
) {
1155 port
->block_status
= true;
1156 adapter
->data_sent
=
1157 mwifiex_usb_data_sent(adapter
);
1160 if (port
->tx_data_ix
>= MWIFIEX_TX_DATA_URB
)
1161 port
->tx_data_ix
= 0;
1167 mwifiex_dbg(adapter
, ERROR
, "Wrong usb tx data port\n");
1171 if (adapter
->bus_aggr
.enable
)
1172 return mwifiex_usb_aggr_tx_data(adapter
, ep
, skb
,
1175 context
= &port
->tx_data_list
[port
->tx_data_ix
++];
1178 return mwifiex_usb_construct_send_urb(adapter
, port
, ep
, context
, skb
);
1181 /* This function register usb device and initialize parameter. */
1182 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
1184 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
1186 card
->adapter
= adapter
;
1188 switch (le16_to_cpu(card
->udev
->descriptor
.idProduct
)) {
1191 adapter
->tx_buf_size
= MWIFIEX_TX_DATA_BUF_SIZE_4K
;
1192 strcpy(adapter
->fw_name
, USB8997_DEFAULT_FW_NAME
);
1193 adapter
->ext_scan
= true;
1197 adapter
->tx_buf_size
= MWIFIEX_TX_DATA_BUF_SIZE_2K
;
1198 strcpy(adapter
->fw_name
, USB8766_DEFAULT_FW_NAME
);
1199 adapter
->ext_scan
= true;
1203 adapter
->tx_buf_size
= MWIFIEX_TX_DATA_BUF_SIZE_2K
;
1204 strcpy(adapter
->fw_name
, USB8801_DEFAULT_FW_NAME
);
1205 adapter
->ext_scan
= false;
1210 adapter
->tx_buf_size
= MWIFIEX_TX_DATA_BUF_SIZE_2K
;
1211 strcpy(adapter
->fw_name
, USB8797_DEFAULT_FW_NAME
);
1215 adapter
->usb_mc_status
= false;
1216 adapter
->usb_mc_setup
= false;
1221 static void mwifiex_usb_cleanup_tx_aggr(struct mwifiex_adapter
*adapter
)
1223 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
1224 struct usb_tx_data_port
*port
;
1225 struct sk_buff
*skb_tmp
;
1228 if (adapter
->bus_aggr
.enable
) {
1229 for (idx
= 0; idx
< MWIFIEX_TX_DATA_PORT
; idx
++) {
1230 port
= &card
->port
[idx
];
1232 skb_dequeue(&port
->tx_aggr
.aggr_list
)))
1233 mwifiex_write_data_complete(adapter
, skb_tmp
,
1239 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
1241 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
1243 if (adapter
->bus_aggr
.enable
)
1244 mwifiex_usb_cleanup_tx_aggr(adapter
);
1246 card
->adapter
= NULL
;
1249 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1250 struct mwifiex_fw_image
*fw
)
1253 u8
*firmware
= fw
->fw_buf
, *recv_buff
;
1254 u32 retries
= USB8XXX_FW_MAX_RETRY
+ 1;
1256 u32 fw_seqnum
= 0, tlen
= 0, dnld_cmd
= 0;
1257 struct fw_data
*fwdata
;
1258 struct fw_sync_header sync_fw
;
1259 u8 check_winner
= 1;
1262 mwifiex_dbg(adapter
, ERROR
,
1263 "No firmware image found! Terminating download\n");
1268 /* Allocate memory for transmit */
1269 fwdata
= kzalloc(FW_DNLD_TX_BUF_SIZE
, GFP_KERNEL
);
1275 /* Allocate memory for receive */
1276 recv_buff
= kzalloc(FW_DNLD_RX_BUF_SIZE
, GFP_KERNEL
);
1283 /* Send pseudo data to check winner status first */
1285 memset(&fwdata
->fw_hdr
, 0, sizeof(struct fw_header
));
1288 /* copy the header of the fw_data to get the length */
1289 memcpy(&fwdata
->fw_hdr
, &firmware
[tlen
],
1290 sizeof(struct fw_header
));
1292 dlen
= le32_to_cpu(fwdata
->fw_hdr
.data_len
);
1293 dnld_cmd
= le32_to_cpu(fwdata
->fw_hdr
.dnld_cmd
);
1294 tlen
+= sizeof(struct fw_header
);
1296 /* Command 7 doesn't have data length field */
1297 if (dnld_cmd
== FW_CMD_7
)
1300 memcpy(fwdata
->data
, &firmware
[tlen
], dlen
);
1302 fwdata
->seq_num
= cpu_to_le32(fw_seqnum
);
1306 /* If the send/receive fails or CRC occurs then retry */
1308 u8
*buf
= (u8
*)fwdata
;
1309 u32 len
= FW_DATA_XMIT_SIZE
;
1311 /* send the firmware block */
1312 ret
= mwifiex_write_data_sync(adapter
, buf
, &len
,
1313 MWIFIEX_USB_EP_CMD_EVENT
,
1314 MWIFIEX_USB_TIMEOUT
);
1316 mwifiex_dbg(adapter
, ERROR
,
1317 "write_data_sync: failed: %d\n",
1323 len
= FW_DNLD_RX_BUF_SIZE
;
1325 /* Receive the firmware block response */
1326 ret
= mwifiex_read_data_sync(adapter
, buf
, &len
,
1327 MWIFIEX_USB_EP_CMD_EVENT
,
1328 MWIFIEX_USB_TIMEOUT
);
1330 mwifiex_dbg(adapter
, ERROR
,
1331 "read_data_sync: failed: %d\n",
1336 memcpy(&sync_fw
, recv_buff
,
1337 sizeof(struct fw_sync_header
));
1339 /* check 1st firmware block resp for highest bit set */
1341 if (le32_to_cpu(sync_fw
.cmd
) & 0x80000000) {
1342 mwifiex_dbg(adapter
, WARN
,
1343 "USB is not the winner %#x\n",
1346 /* returning success */
1351 mwifiex_dbg(adapter
, MSG
,
1352 "start to download FW...\n");
1358 /* check the firmware block response for CRC errors */
1360 mwifiex_dbg(adapter
, ERROR
,
1361 "FW received block with CRC %#x\n",
1367 retries
= USB8XXX_FW_MAX_RETRY
+ 1;
1371 } while ((dnld_cmd
!= FW_HAS_LAST_BLOCK
) && retries
);
1374 mwifiex_dbg(adapter
, MSG
,
1375 "info: FW download over, size %d bytes\n", tlen
);
1386 static int mwifiex_usb_dnld_fw(struct mwifiex_adapter
*adapter
,
1387 struct mwifiex_fw_image
*fw
)
1390 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
1392 if (card
->usb_boot_state
== USB8XXX_FW_DNLD
) {
1393 ret
= mwifiex_prog_fw_w_helper(adapter
, fw
);
1397 /* Boot state changes after successful firmware download */
1398 if (card
->usb_boot_state
== USB8XXX_FW_DNLD
)
1402 ret
= mwifiex_usb_rx_init(adapter
);
1404 ret
= mwifiex_usb_tx_init(adapter
);
1409 static void mwifiex_submit_rx_urb(struct mwifiex_adapter
*adapter
, u8 ep
)
1411 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
1413 skb_push(card
->rx_cmd
.skb
, INTF_HEADER_LEN
);
1414 if ((ep
== card
->rx_cmd_ep
) &&
1415 (!atomic_read(&card
->rx_cmd_urb_pending
)))
1416 mwifiex_usb_submit_rx_urb(&card
->rx_cmd
,
1417 MWIFIEX_RX_CMD_BUF_SIZE
);
1422 static int mwifiex_usb_cmd_event_complete(struct mwifiex_adapter
*adapter
,
1423 struct sk_buff
*skb
)
1425 mwifiex_submit_rx_urb(adapter
, MWIFIEX_USB_EP_CMD_EVENT
);
1430 /* This function wakes up the card. */
1431 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter
*adapter
)
1433 /* Simulation of HS_AWAKE event */
1434 adapter
->pm_wakeup_fw_try
= false;
1435 del_timer(&adapter
->wakeup_timer
);
1436 adapter
->pm_wakeup_card_req
= false;
1437 adapter
->ps_state
= PS_STATE_AWAKE
;
1442 static void mwifiex_usb_submit_rem_rx_urbs(struct mwifiex_adapter
*adapter
)
1444 struct usb_card_rec
*card
= (struct usb_card_rec
*)adapter
->card
;
1446 struct urb_context
*ctx
;
1448 for (i
= 0; i
< MWIFIEX_RX_DATA_URB
; i
++) {
1449 if (card
->rx_data_list
[i
].skb
)
1451 ctx
= &card
->rx_data_list
[i
];
1452 mwifiex_usb_submit_rx_urb(ctx
, MWIFIEX_RX_DATA_BUF_SIZE
);
1456 /* This function is called after the card has woken up. */
1458 mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter
*adapter
)
1463 static struct mwifiex_if_ops usb_ops
= {
1464 .register_dev
= mwifiex_register_dev
,
1465 .unregister_dev
= mwifiex_unregister_dev
,
1466 .wakeup
= mwifiex_pm_wakeup_card
,
1467 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
1470 .dnld_fw
= mwifiex_usb_dnld_fw
,
1471 .cmdrsp_complete
= mwifiex_usb_cmd_event_complete
,
1472 .event_complete
= mwifiex_usb_cmd_event_complete
,
1473 .host_to_card
= mwifiex_usb_host_to_card
,
1474 .submit_rem_rx_urbs
= mwifiex_usb_submit_rem_rx_urbs
,
1475 .multi_port_resync
= mwifiex_usb_port_resync
,
1476 .is_port_ready
= mwifiex_usb_is_port_ready
,
1479 module_usb_driver(mwifiex_usb_driver
);
1481 MODULE_AUTHOR("Marvell International Ltd.");
1482 MODULE_DESCRIPTION("Marvell WiFi-Ex USB Driver version" USB_VERSION
);
1483 MODULE_VERSION(USB_VERSION
);
1484 MODULE_LICENSE("GPL v2");
1485 MODULE_FIRMWARE(USB8766_DEFAULT_FW_NAME
);
1486 MODULE_FIRMWARE(USB8797_DEFAULT_FW_NAME
);
1487 MODULE_FIRMWARE(USB8801_DEFAULT_FW_NAME
);
1488 MODULE_FIRMWARE(USB8997_DEFAULT_FW_NAME
);