1 /*
2  * Marvell Wireless LAN device driver: USB specific handling
3  *
4  * Copyright (C) 2012-2014, Marvell International Ltd.
5  *
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.
13  *
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.
18  */
19 
20 #include "main.h"
21 #include "usb.h"
22 
23 #define USB_VERSION	"1.0"
24 
25 static u8 user_rmmod;
26 static struct mwifiex_if_ops usb_ops;
27 static struct semaphore add_remove_card_sem;
28 
29 static struct usb_device_id mwifiex_usb_table[] = {
30 	/* 8766 */
31 	{USB_DEVICE(USB8XXX_VID, USB8766_PID_1)},
32 	{USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8766_PID_2,
33 				       USB_CLASS_VENDOR_SPEC,
34 				       USB_SUBCLASS_VENDOR_SPEC, 0xff)},
35 	/* 8797 */
36 	{USB_DEVICE(USB8XXX_VID, USB8797_PID_1)},
37 	{USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8797_PID_2,
38 				       USB_CLASS_VENDOR_SPEC,
39 				       USB_SUBCLASS_VENDOR_SPEC, 0xff)},
40 	/* 8801 */
41 	{USB_DEVICE(USB8XXX_VID, USB8801_PID_1)},
42 	{USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8801_PID_2,
43 				       USB_CLASS_VENDOR_SPEC,
44 				       USB_SUBCLASS_VENDOR_SPEC, 0xff)},
45 	/* 8997 */
46 	{USB_DEVICE(USB8XXX_VID, USB8997_PID_1)},
47 	{USB_DEVICE_AND_INTERFACE_INFO(USB8XXX_VID, USB8997_PID_2,
48 				       USB_CLASS_VENDOR_SPEC,
49 				       USB_SUBCLASS_VENDOR_SPEC, 0xff)},
50 	{ }	/* Terminating entry */
51 };
52 
53 MODULE_DEVICE_TABLE(usb, mwifiex_usb_table);
54 
55 static int mwifiex_usb_submit_rx_urb(struct urb_context *ctx, int size);
56 
57 /* This function handles received packet. Necessary action is taken based on
58  * cmd/event/data.
59  */
60 static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
61 			    struct sk_buff *skb, u8 ep)
62 {
63 	u32 recv_type;
64 	__le32 tmp;
65 	int ret;
66 
67 	if (adapter->hs_activated)
68 		mwifiex_process_hs_config(adapter);
69 
70 	if (skb->len < INTF_HEADER_LEN) {
71 		mwifiex_dbg(adapter, ERROR,
72 			    "%s: invalid skb->len\n", __func__);
73 		return -1;
74 	}
75 
76 	switch (ep) {
77 	case MWIFIEX_USB_EP_CMD_EVENT:
78 		mwifiex_dbg(adapter, EVENT,
79 			    "%s: EP_CMD_EVENT\n", __func__);
80 		skb_copy_from_linear_data(skb, &tmp, INTF_HEADER_LEN);
81 		recv_type = le32_to_cpu(tmp);
82 		skb_pull(skb, INTF_HEADER_LEN);
83 
84 		switch (recv_type) {
85 		case MWIFIEX_USB_TYPE_CMD:
86 			if (skb->len > MWIFIEX_SIZE_OF_CMD_BUFFER) {
87 				mwifiex_dbg(adapter, ERROR,
88 					    "CMD: skb->len too large\n");
89 				ret = -1;
90 				goto exit_restore_skb;
91 			} else if (!adapter->curr_cmd) {
92 				mwifiex_dbg(adapter, WARN, "CMD: no curr_cmd\n");
93 				if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
94 					mwifiex_process_sleep_confirm_resp(
95 							adapter, skb->data,
96 							skb->len);
97 					ret = 0;
98 					goto exit_restore_skb;
99 				}
100 				ret = -1;
101 				goto exit_restore_skb;
102 			}
103 
104 			adapter->curr_cmd->resp_skb = skb;
105 			adapter->cmd_resp_received = true;
106 			break;
107 		case MWIFIEX_USB_TYPE_EVENT:
108 			if (skb->len < sizeof(u32)) {
109 				mwifiex_dbg(adapter, ERROR,
110 					    "EVENT: skb->len too small\n");
111 				ret = -1;
112 				goto exit_restore_skb;
113 			}
114 			skb_copy_from_linear_data(skb, &tmp, sizeof(u32));
115 			adapter->event_cause = le32_to_cpu(tmp);
116 			mwifiex_dbg(adapter, EVENT,
117 				    "event_cause %#x\n", adapter->event_cause);
118 
119 			if (skb->len > MAX_EVENT_SIZE) {
120 				mwifiex_dbg(adapter, ERROR,
121 					    "EVENT: event body too large\n");
122 				ret = -1;
123 				goto exit_restore_skb;
124 			}
125 
126 			memcpy(adapter->event_body, skb->data +
127 			       MWIFIEX_EVENT_HEADER_LEN, skb->len);
128 
129 			adapter->event_received = true;
130 			adapter->event_skb = skb;
131 			break;
132 		default:
133 			mwifiex_dbg(adapter, ERROR,
134 				    "unknown recv_type %#x\n", recv_type);
135 			return -1;
136 		}
137 		break;
138 	case MWIFIEX_USB_EP_DATA:
139 		mwifiex_dbg(adapter, DATA, "%s: EP_DATA\n", __func__);
140 		if (skb->len > MWIFIEX_RX_DATA_BUF_SIZE) {
141 			mwifiex_dbg(adapter, ERROR,
142 				    "DATA: skb->len too large\n");
143 			return -1;
144 		}
145 
146 		skb_queue_tail(&adapter->rx_data_q, skb);
147 		adapter->data_received = true;
148 		atomic_inc(&adapter->rx_pending);
149 		break;
150 	default:
151 		mwifiex_dbg(adapter, ERROR,
152 			    "%s: unknown endport %#x\n", __func__, ep);
153 		return -1;
154 	}
155 
156 	return -EINPROGRESS;
157 
158 exit_restore_skb:
159 	/* The buffer will be reused for further cmds/events */
160 	skb_push(skb, INTF_HEADER_LEN);
161 
162 	return ret;
163 }
164 
165 static void mwifiex_usb_rx_complete(struct urb *urb)
166 {
167 	struct urb_context *context = (struct urb_context *)urb->context;
168 	struct mwifiex_adapter *adapter = context->adapter;
169 	struct sk_buff *skb = context->skb;
170 	struct usb_card_rec *card;
171 	int recv_length = urb->actual_length;
172 	int size, status;
173 
174 	if (!adapter || !adapter->card) {
175 		pr_err("mwifiex adapter or card structure is not valid\n");
176 		return;
177 	}
178 
179 	card = (struct usb_card_rec *)adapter->card;
180 	if (card->rx_cmd_ep == context->ep)
181 		atomic_dec(&card->rx_cmd_urb_pending);
182 	else
183 		atomic_dec(&card->rx_data_urb_pending);
184 
185 	if (recv_length) {
186 		if (urb->status || (adapter->surprise_removed)) {
187 			mwifiex_dbg(adapter, ERROR,
188 				    "URB status is failed: %d\n", urb->status);
189 			/* Do not free skb in case of command ep */
190 			if (card->rx_cmd_ep != context->ep)
191 				dev_kfree_skb_any(skb);
192 			goto setup_for_next;
193 		}
194 		if (skb->len > recv_length)
195 			skb_trim(skb, recv_length);
196 		else
197 			skb_put(skb, recv_length - skb->len);
198 
199 		status = mwifiex_usb_recv(adapter, skb, context->ep);
200 
201 		mwifiex_dbg(adapter, INFO,
202 			    "info: recv_length=%d, status=%d\n",
203 			    recv_length, status);
204 		if (status == -EINPROGRESS) {
205 			mwifiex_queue_main_work(adapter);
206 
207 			/* urb for data_ep is re-submitted now;
208 			 * urb for cmd_ep will be re-submitted in callback
209 			 * mwifiex_usb_recv_complete
210 			 */
211 			if (card->rx_cmd_ep == context->ep)
212 				return;
213 		} else {
214 			if (status == -1)
215 				mwifiex_dbg(adapter, ERROR,
216 					    "received data processing failed!\n");
217 
218 			/* Do not free skb in case of command ep */
219 			if (card->rx_cmd_ep != context->ep)
220 				dev_kfree_skb_any(skb);
221 		}
222 	} else if (urb->status) {
223 		if (!adapter->is_suspended) {
224 			mwifiex_dbg(adapter, FATAL,
225 				    "Card is removed: %d\n", urb->status);
226 			adapter->surprise_removed = true;
227 		}
228 		dev_kfree_skb_any(skb);
229 		return;
230 	} else {
231 		/* Do not free skb in case of command ep */
232 		if (card->rx_cmd_ep != context->ep)
233 			dev_kfree_skb_any(skb);
234 
235 		/* fall through setup_for_next */
236 	}
237 
238 setup_for_next:
239 	if (card->rx_cmd_ep == context->ep)
240 		size = MWIFIEX_RX_CMD_BUF_SIZE;
241 	else
242 		size = MWIFIEX_RX_DATA_BUF_SIZE;
243 
244 	if (card->rx_cmd_ep == context->ep) {
245 		mwifiex_usb_submit_rx_urb(context, size);
246 	} else {
247 		if (atomic_read(&adapter->rx_pending) <= HIGH_RX_PENDING) {
248 			mwifiex_usb_submit_rx_urb(context, size);
249 		} else {
250 			context->skb = NULL;
251 		}
252 	}
253 
254 	return;
255 }
256 
257 static void mwifiex_usb_tx_complete(struct urb *urb)
258 {
259 	struct urb_context *context = (struct urb_context *)(urb->context);
260 	struct mwifiex_adapter *adapter = context->adapter;
261 	struct usb_card_rec *card = adapter->card;
262 	struct usb_tx_data_port *port;
263 	int i;
264 
265 	mwifiex_dbg(adapter, INFO,
266 		    "%s: status: %d\n", __func__, urb->status);
267 
268 	if (context->ep == card->tx_cmd_ep) {
269 		mwifiex_dbg(adapter, CMD,
270 			    "%s: CMD\n", __func__);
271 		atomic_dec(&card->tx_cmd_urb_pending);
272 		adapter->cmd_sent = false;
273 	} else {
274 		mwifiex_dbg(adapter, DATA,
275 			    "%s: DATA\n", __func__);
276 		mwifiex_write_data_complete(adapter, context->skb, 0,
277 					    urb->status ? -1 : 0);
278 		for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++) {
279 			port = &card->port[i];
280 			if (context->ep == port->tx_data_ep) {
281 				atomic_dec(&port->tx_data_urb_pending);
282 				port->block_status = false;
283 				break;
284 			}
285 		}
286 		adapter->data_sent = false;
287 	}
288 
289 	if (card->mc_resync_flag)
290 		mwifiex_multi_chan_resync(adapter);
291 
292 	mwifiex_queue_main_work(adapter);
293 
294 	return;
295 }
296 
297 static int mwifiex_usb_submit_rx_urb(struct urb_context *ctx, int size)
298 {
299 	struct mwifiex_adapter *adapter = ctx->adapter;
300 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
301 
302 	if (card->rx_cmd_ep != ctx->ep) {
303 		ctx->skb = dev_alloc_skb(size);
304 		if (!ctx->skb) {
305 			mwifiex_dbg(adapter, ERROR,
306 				    "%s: dev_alloc_skb failed\n", __func__);
307 			return -ENOMEM;
308 		}
309 	}
310 
311 	usb_fill_bulk_urb(ctx->urb, card->udev,
312 			  usb_rcvbulkpipe(card->udev, ctx->ep), ctx->skb->data,
313 			  size, mwifiex_usb_rx_complete, (void *)ctx);
314 
315 	if (card->rx_cmd_ep == ctx->ep)
316 		atomic_inc(&card->rx_cmd_urb_pending);
317 	else
318 		atomic_inc(&card->rx_data_urb_pending);
319 
320 	if (usb_submit_urb(ctx->urb, GFP_ATOMIC)) {
321 		mwifiex_dbg(adapter, ERROR, "usb_submit_urb failed\n");
322 		dev_kfree_skb_any(ctx->skb);
323 		ctx->skb = NULL;
324 
325 		if (card->rx_cmd_ep == ctx->ep)
326 			atomic_dec(&card->rx_cmd_urb_pending);
327 		else
328 			atomic_dec(&card->rx_data_urb_pending);
329 
330 		return -1;
331 	}
332 
333 	return 0;
334 }
335 
336 static void mwifiex_usb_free(struct usb_card_rec *card)
337 {
338 	struct usb_tx_data_port *port;
339 	int i, j;
340 
341 	if (atomic_read(&card->rx_cmd_urb_pending) && card->rx_cmd.urb)
342 		usb_kill_urb(card->rx_cmd.urb);
343 
344 	usb_free_urb(card->rx_cmd.urb);
345 	card->rx_cmd.urb = NULL;
346 
347 	if (atomic_read(&card->rx_data_urb_pending))
348 		for (i = 0; i < MWIFIEX_RX_DATA_URB; i++)
349 			if (card->rx_data_list[i].urb)
350 				usb_kill_urb(card->rx_data_list[i].urb);
351 
352 	for (i = 0; i < MWIFIEX_RX_DATA_URB; i++) {
353 		usb_free_urb(card->rx_data_list[i].urb);
354 		card->rx_data_list[i].urb = NULL;
355 	}
356 
357 	for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++) {
358 		port = &card->port[i];
359 		for (j = 0; j < MWIFIEX_TX_DATA_URB; j++) {
360 			usb_free_urb(port->tx_data_list[j].urb);
361 			port->tx_data_list[j].urb = NULL;
362 		}
363 	}
364 
365 	usb_free_urb(card->tx_cmd.urb);
366 	card->tx_cmd.urb = NULL;
367 
368 	return;
369 }
370 
371 /* This function probes an mwifiex device and registers it. It allocates
372  * the card structure, initiates the device registration and initialization
373  * procedure by adding a logical interface.
374  */
375 static int mwifiex_usb_probe(struct usb_interface *intf,
376 			     const struct usb_device_id *id)
377 {
378 	struct usb_device *udev = interface_to_usbdev(intf);
379 	struct usb_host_interface *iface_desc = intf->cur_altsetting;
380 	struct usb_endpoint_descriptor *epd;
381 	int ret, i;
382 	struct usb_card_rec *card;
383 	u16 id_vendor, id_product, bcd_device, bcd_usb;
384 
385 	card = kzalloc(sizeof(struct usb_card_rec), GFP_KERNEL);
386 	if (!card)
387 		return -ENOMEM;
388 
389 	id_vendor = le16_to_cpu(udev->descriptor.idVendor);
390 	id_product = le16_to_cpu(udev->descriptor.idProduct);
391 	bcd_device = le16_to_cpu(udev->descriptor.bcdDevice);
392 	bcd_usb = le16_to_cpu(udev->descriptor.bcdUSB);
393 	pr_debug("info: VID/PID = %X/%X, Boot2 version = %X\n",
394 		 id_vendor, id_product, bcd_device);
395 
396 	/* PID_1 is used for firmware downloading only */
397 	switch (id_product) {
398 	case USB8766_PID_1:
399 	case USB8797_PID_1:
400 	case USB8801_PID_1:
401 	case USB8997_PID_1:
402 		card->usb_boot_state = USB8XXX_FW_DNLD;
403 		break;
404 	case USB8766_PID_2:
405 	case USB8797_PID_2:
406 	case USB8801_PID_2:
407 	case USB8997_PID_2:
408 		card->usb_boot_state = USB8XXX_FW_READY;
409 		break;
410 	default:
411 		pr_warn("unknown id_product %#x\n", id_product);
412 		card->usb_boot_state = USB8XXX_FW_DNLD;
413 		break;
414 	}
415 
416 	card->udev = udev;
417 	card->intf = intf;
418 
419 	pr_debug("info: bcdUSB=%#x Device Class=%#x SubClass=%#x Protocol=%#x\n",
420 		 udev->descriptor.bcdUSB, udev->descriptor.bDeviceClass,
421 		 udev->descriptor.bDeviceSubClass,
422 		 udev->descriptor.bDeviceProtocol);
423 
424 	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
425 		epd = &iface_desc->endpoint[i].desc;
426 		if (usb_endpoint_dir_in(epd) &&
427 		    usb_endpoint_num(epd) == MWIFIEX_USB_EP_CMD_EVENT &&
428 		    usb_endpoint_xfer_bulk(epd)) {
429 			pr_debug("info: bulk IN: max pkt size: %d, addr: %d\n",
430 				 le16_to_cpu(epd->wMaxPacketSize),
431 				 epd->bEndpointAddress);
432 			card->rx_cmd_ep = usb_endpoint_num(epd);
433 			atomic_set(&card->rx_cmd_urb_pending, 0);
434 		}
435 		if (usb_endpoint_dir_in(epd) &&
436 		    usb_endpoint_num(epd) == MWIFIEX_USB_EP_DATA &&
437 		    usb_endpoint_xfer_bulk(epd)) {
438 			pr_debug("info: bulk IN: max pkt size: %d, addr: %d\n",
439 				 le16_to_cpu(epd->wMaxPacketSize),
440 				 epd->bEndpointAddress);
441 			card->rx_data_ep = usb_endpoint_num(epd);
442 			atomic_set(&card->rx_data_urb_pending, 0);
443 		}
444 		if (usb_endpoint_dir_out(epd) &&
445 		    usb_endpoint_num(epd) == MWIFIEX_USB_EP_DATA &&
446 		    usb_endpoint_xfer_bulk(epd)) {
447 			pr_debug("info: bulk OUT: max pkt size: %d, addr: %d\n",
448 				 le16_to_cpu(epd->wMaxPacketSize),
449 				 epd->bEndpointAddress);
450 			card->port[0].tx_data_ep = usb_endpoint_num(epd);
451 			atomic_set(&card->port[0].tx_data_urb_pending, 0);
452 		}
453 		if (usb_endpoint_dir_out(epd) &&
454 		    usb_endpoint_num(epd) == MWIFIEX_USB_EP_DATA_CH2 &&
455 		    usb_endpoint_xfer_bulk(epd)) {
456 			pr_debug("info: bulk OUT chan2:\t"
457 				 "max pkt size: %d, addr: %d\n",
458 				 le16_to_cpu(epd->wMaxPacketSize),
459 				 epd->bEndpointAddress);
460 			card->port[1].tx_data_ep = usb_endpoint_num(epd);
461 			atomic_set(&card->port[1].tx_data_urb_pending, 0);
462 		}
463 		if (usb_endpoint_dir_out(epd) &&
464 		    usb_endpoint_num(epd) == MWIFIEX_USB_EP_CMD_EVENT &&
465 		    usb_endpoint_xfer_bulk(epd)) {
466 			pr_debug("info: bulk OUT: max pkt size: %d, addr: %d\n",
467 				 le16_to_cpu(epd->wMaxPacketSize),
468 				 epd->bEndpointAddress);
469 			card->tx_cmd_ep = usb_endpoint_num(epd);
470 			atomic_set(&card->tx_cmd_urb_pending, 0);
471 			card->bulk_out_maxpktsize =
472 					le16_to_cpu(epd->wMaxPacketSize);
473 		}
474 	}
475 
476 	usb_set_intfdata(intf, card);
477 
478 	ret = mwifiex_add_card(card, &add_remove_card_sem, &usb_ops,
479 			       MWIFIEX_USB);
480 	if (ret) {
481 		pr_err("%s: mwifiex_add_card failed: %d\n", __func__, ret);
482 		usb_reset_device(udev);
483 		kfree(card);
484 		return ret;
485 	}
486 
487 	usb_get_dev(udev);
488 
489 	return 0;
490 }
491 
492 /* Kernel needs to suspend all functions separately. Therefore all
493  * registered functions must have drivers with suspend and resume
494  * methods. Failing that the kernel simply removes the whole card.
495  *
496  * If already not suspended, this function allocates and sends a
497  * 'host sleep activate' request to the firmware and turns off the traffic.
498  */
499 static int mwifiex_usb_suspend(struct usb_interface *intf, pm_message_t message)
500 {
501 	struct usb_card_rec *card = usb_get_intfdata(intf);
502 	struct mwifiex_adapter *adapter;
503 	struct usb_tx_data_port *port;
504 	int i, j;
505 
506 	if (!card || !card->adapter) {
507 		pr_err("%s: card or card->adapter is NULL\n", __func__);
508 		return 0;
509 	}
510 	adapter = card->adapter;
511 
512 	if (unlikely(adapter->is_suspended))
513 		mwifiex_dbg(adapter, WARN,
514 			    "Device already suspended\n");
515 
516 	mwifiex_enable_hs(adapter);
517 
518 	/* 'is_suspended' flag indicates device is suspended.
519 	 * It must be set here before the usb_kill_urb() calls. Reason
520 	 * is in the complete handlers, urb->status(= -ENOENT) and
521 	 * this flag is used in combination to distinguish between a
522 	 * 'suspended' state and a 'disconnect' one.
523 	 */
524 	adapter->is_suspended = true;
525 	adapter->hs_enabling = false;
526 
527 	if (atomic_read(&card->rx_cmd_urb_pending) && card->rx_cmd.urb)
528 		usb_kill_urb(card->rx_cmd.urb);
529 
530 	if (atomic_read(&card->rx_data_urb_pending))
531 		for (i = 0; i < MWIFIEX_RX_DATA_URB; i++)
532 			if (card->rx_data_list[i].urb)
533 				usb_kill_urb(card->rx_data_list[i].urb);
534 
535 	for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++) {
536 		port = &card->port[i];
537 		for (j = 0; j < MWIFIEX_TX_DATA_URB; j++) {
538 			if (port->tx_data_list[j].urb)
539 				usb_kill_urb(port->tx_data_list[j].urb);
540 		}
541 	}
542 
543 	if (card->tx_cmd.urb)
544 		usb_kill_urb(card->tx_cmd.urb);
545 
546 	return 0;
547 }
548 
549 /* Kernel needs to suspend all functions separately. Therefore all
550  * registered functions must have drivers with suspend and resume
551  * methods. Failing that the kernel simply removes the whole card.
552  *
553  * If already not resumed, this function turns on the traffic and
554  * sends a 'host sleep cancel' request to the firmware.
555  */
556 static int mwifiex_usb_resume(struct usb_interface *intf)
557 {
558 	struct usb_card_rec *card = usb_get_intfdata(intf);
559 	struct mwifiex_adapter *adapter;
560 	int i;
561 
562 	if (!card || !card->adapter) {
563 		pr_err("%s: card or card->adapter is NULL\n", __func__);
564 		return 0;
565 	}
566 	adapter = card->adapter;
567 
568 	if (unlikely(!adapter->is_suspended)) {
569 		mwifiex_dbg(adapter, WARN,
570 			    "Device already resumed\n");
571 		return 0;
572 	}
573 
574 	/* Indicate device resumed. The netdev queue will be resumed only
575 	 * after the urbs have been re-submitted
576 	 */
577 	adapter->is_suspended = false;
578 
579 	if (!atomic_read(&card->rx_data_urb_pending))
580 		for (i = 0; i < MWIFIEX_RX_DATA_URB; i++)
581 			mwifiex_usb_submit_rx_urb(&card->rx_data_list[i],
582 						  MWIFIEX_RX_DATA_BUF_SIZE);
583 
584 	if (!atomic_read(&card->rx_cmd_urb_pending)) {
585 		card->rx_cmd.skb = dev_alloc_skb(MWIFIEX_RX_CMD_BUF_SIZE);
586 		if (card->rx_cmd.skb)
587 			mwifiex_usb_submit_rx_urb(&card->rx_cmd,
588 						  MWIFIEX_RX_CMD_BUF_SIZE);
589 	}
590 
591 	/* Disable Host Sleep */
592 	if (adapter->hs_activated)
593 		mwifiex_cancel_hs(mwifiex_get_priv(adapter,
594 						   MWIFIEX_BSS_ROLE_ANY),
595 				  MWIFIEX_ASYNC_CMD);
596 
597 	return 0;
598 }
599 
600 static void mwifiex_usb_disconnect(struct usb_interface *intf)
601 {
602 	struct usb_card_rec *card = usb_get_intfdata(intf);
603 	struct mwifiex_adapter *adapter;
604 
605 	if (!card || !card->adapter) {
606 		pr_err("%s: card or card->adapter is NULL\n", __func__);
607 		return;
608 	}
609 
610 	adapter = card->adapter;
611 	if (!adapter->priv_num)
612 		return;
613 
614 	if (user_rmmod && !adapter->mfg_mode) {
615 #ifdef CONFIG_PM
616 		if (adapter->is_suspended)
617 			mwifiex_usb_resume(intf);
618 #endif
619 
620 		mwifiex_deauthenticate_all(adapter);
621 
622 		mwifiex_init_shutdown_fw(mwifiex_get_priv(adapter,
623 							  MWIFIEX_BSS_ROLE_ANY),
624 					 MWIFIEX_FUNC_SHUTDOWN);
625 	}
626 
627 	mwifiex_usb_free(card);
628 
629 	mwifiex_dbg(adapter, FATAL,
630 		    "%s: removing card\n", __func__);
631 	mwifiex_remove_card(adapter, &add_remove_card_sem);
632 
633 	usb_set_intfdata(intf, NULL);
634 	usb_put_dev(interface_to_usbdev(intf));
635 	kfree(card);
636 
637 	return;
638 }
639 
640 static struct usb_driver mwifiex_usb_driver = {
641 	.name = "mwifiex_usb",
642 	.probe = mwifiex_usb_probe,
643 	.disconnect = mwifiex_usb_disconnect,
644 	.id_table = mwifiex_usb_table,
645 	.suspend = mwifiex_usb_suspend,
646 	.resume = mwifiex_usb_resume,
647 	.soft_unbind = 1,
648 };
649 
650 static int mwifiex_usb_tx_init(struct mwifiex_adapter *adapter)
651 {
652 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
653 	struct usb_tx_data_port *port;
654 	int i, j;
655 
656 	card->tx_cmd.adapter = adapter;
657 	card->tx_cmd.ep = card->tx_cmd_ep;
658 
659 	card->tx_cmd.urb = usb_alloc_urb(0, GFP_KERNEL);
660 	if (!card->tx_cmd.urb)
661 		return -ENOMEM;
662 
663 	for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++) {
664 		port = &card->port[i];
665 		if (!port->tx_data_ep)
666 			continue;
667 		port->tx_data_ix = 0;
668 		if (port->tx_data_ep == MWIFIEX_USB_EP_DATA)
669 			port->block_status = false;
670 		else
671 			port->block_status = true;
672 		for (j = 0; j < MWIFIEX_TX_DATA_URB; j++) {
673 			port->tx_data_list[j].adapter = adapter;
674 			port->tx_data_list[j].ep = port->tx_data_ep;
675 			port->tx_data_list[j].urb =
676 					usb_alloc_urb(0, GFP_KERNEL);
677 			if (!port->tx_data_list[j].urb)
678 				return -ENOMEM;
679 		}
680 	}
681 
682 	return 0;
683 }
684 
685 static int mwifiex_usb_rx_init(struct mwifiex_adapter *adapter)
686 {
687 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
688 	int i;
689 
690 	card->rx_cmd.adapter = adapter;
691 	card->rx_cmd.ep = card->rx_cmd_ep;
692 
693 	card->rx_cmd.urb = usb_alloc_urb(0, GFP_KERNEL);
694 	if (!card->rx_cmd.urb)
695 		return -ENOMEM;
696 
697 	card->rx_cmd.skb = dev_alloc_skb(MWIFIEX_RX_CMD_BUF_SIZE);
698 	if (!card->rx_cmd.skb)
699 		return -ENOMEM;
700 
701 	if (mwifiex_usb_submit_rx_urb(&card->rx_cmd, MWIFIEX_RX_CMD_BUF_SIZE))
702 		return -1;
703 
704 	for (i = 0; i < MWIFIEX_RX_DATA_URB; i++) {
705 		card->rx_data_list[i].adapter = adapter;
706 		card->rx_data_list[i].ep = card->rx_data_ep;
707 
708 		card->rx_data_list[i].urb = usb_alloc_urb(0, GFP_KERNEL);
709 		if (!card->rx_data_list[i].urb)
710 			return -1;
711 		if (mwifiex_usb_submit_rx_urb(&card->rx_data_list[i],
712 					      MWIFIEX_RX_DATA_BUF_SIZE))
713 			return -1;
714 	}
715 
716 	return 0;
717 }
718 
719 static int mwifiex_write_data_sync(struct mwifiex_adapter *adapter, u8 *pbuf,
720 				   u32 *len, u8 ep, u32 timeout)
721 {
722 	struct usb_card_rec *card = adapter->card;
723 	int actual_length, ret;
724 
725 	if (!(*len % card->bulk_out_maxpktsize))
726 		(*len)++;
727 
728 	/* Send the data block */
729 	ret = usb_bulk_msg(card->udev, usb_sndbulkpipe(card->udev, ep), pbuf,
730 			   *len, &actual_length, timeout);
731 	if (ret) {
732 		mwifiex_dbg(adapter, ERROR,
733 			    "usb_bulk_msg for tx failed: %d\n", ret);
734 		return ret;
735 	}
736 
737 	*len = actual_length;
738 
739 	return ret;
740 }
741 
742 static int mwifiex_read_data_sync(struct mwifiex_adapter *adapter, u8 *pbuf,
743 				  u32 *len, u8 ep, u32 timeout)
744 {
745 	struct usb_card_rec *card = adapter->card;
746 	int actual_length, ret;
747 
748 	/* Receive the data response */
749 	ret = usb_bulk_msg(card->udev, usb_rcvbulkpipe(card->udev, ep), pbuf,
750 			   *len, &actual_length, timeout);
751 	if (ret) {
752 		mwifiex_dbg(adapter, ERROR,
753 			    "usb_bulk_msg for rx failed: %d\n", ret);
754 		return ret;
755 	}
756 
757 	*len = actual_length;
758 
759 	return ret;
760 }
761 
762 static void mwifiex_usb_port_resync(struct mwifiex_adapter *adapter)
763 {
764 	struct usb_card_rec *card = adapter->card;
765 	u8 active_port = MWIFIEX_USB_EP_DATA;
766 	struct mwifiex_private *priv = NULL;
767 	int i;
768 
769 	if (adapter->usb_mc_status) {
770 		for (i = 0; i < adapter->priv_num; i++) {
771 			priv = adapter->priv[i];
772 			if (!priv)
773 				continue;
774 			if ((priv->bss_role == MWIFIEX_BSS_ROLE_UAP &&
775 			     !priv->bss_started) ||
776 			    (priv->bss_role == MWIFIEX_BSS_ROLE_STA &&
777 			     !priv->media_connected))
778 				priv->usb_port = MWIFIEX_USB_EP_DATA;
779 		}
780 		for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++)
781 			card->port[i].block_status = false;
782 	} else {
783 		for (i = 0; i < adapter->priv_num; i++) {
784 			priv = adapter->priv[i];
785 			if (!priv)
786 				continue;
787 			if ((priv->bss_role == MWIFIEX_BSS_ROLE_UAP &&
788 			     priv->bss_started) ||
789 			    (priv->bss_role == MWIFIEX_BSS_ROLE_STA &&
790 			     priv->media_connected)) {
791 				active_port = priv->usb_port;
792 				break;
793 			}
794 		}
795 		for (i = 0; i < adapter->priv_num; i++) {
796 			priv = adapter->priv[i];
797 			if (priv)
798 				priv->usb_port = active_port;
799 		}
800 		for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++) {
801 			if (active_port == card->port[i].tx_data_ep)
802 				card->port[i].block_status = false;
803 			else
804 				card->port[i].block_status = true;
805 		}
806 	}
807 }
808 
809 static bool mwifiex_usb_is_port_ready(struct mwifiex_private *priv)
810 {
811 	struct usb_card_rec *card = priv->adapter->card;
812 	int idx;
813 
814 	for (idx = 0; idx < MWIFIEX_TX_DATA_PORT; idx++) {
815 		if (priv->usb_port == card->port[idx].tx_data_ep)
816 			return !card->port[idx].block_status;
817 	}
818 
819 	return false;
820 }
821 
822 static inline u8 mwifiex_usb_data_sent(struct mwifiex_adapter *adapter)
823 {
824 	struct usb_card_rec *card = adapter->card;
825 	int i;
826 
827 	for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++)
828 		if (!card->port[i].block_status)
829 			return false;
830 
831 	return true;
832 }
833 
834 /* This function write a command/data packet to card. */
835 static int mwifiex_usb_host_to_card(struct mwifiex_adapter *adapter, u8 ep,
836 				    struct sk_buff *skb,
837 				    struct mwifiex_tx_param *tx_param)
838 {
839 	struct usb_card_rec *card = adapter->card;
840 	struct urb_context *context = NULL;
841 	struct usb_tx_data_port *port = NULL;
842 	u8 *data = (u8 *)skb->data;
843 	struct urb *tx_urb;
844 	int idx, ret = -EINPROGRESS;
845 
846 	if (adapter->is_suspended) {
847 		mwifiex_dbg(adapter, ERROR,
848 			    "%s: not allowed while suspended\n", __func__);
849 		return -1;
850 	}
851 
852 	if (adapter->surprise_removed) {
853 		mwifiex_dbg(adapter, ERROR, "%s: device removed\n", __func__);
854 		return -1;
855 	}
856 
857 	mwifiex_dbg(adapter, INFO, "%s: ep=%d\n", __func__, ep);
858 
859 	if (ep == card->tx_cmd_ep) {
860 		context = &card->tx_cmd;
861 	} else {
862 		for (idx = 0; idx < MWIFIEX_TX_DATA_PORT; idx++) {
863 			if (ep == card->port[idx].tx_data_ep) {
864 				port = &card->port[idx];
865 				if (atomic_read(&port->tx_data_urb_pending)
866 				    >= MWIFIEX_TX_DATA_URB) {
867 					port->block_status = true;
868 					adapter->data_sent =
869 						mwifiex_usb_data_sent(adapter);
870 					return -EBUSY;
871 				}
872 				if (port->tx_data_ix >= MWIFIEX_TX_DATA_URB)
873 					port->tx_data_ix = 0;
874 				context =
875 					&port->tx_data_list[port->tx_data_ix++];
876 				break;
877 			}
878 		}
879 		if (!port) {
880 			mwifiex_dbg(adapter, ERROR, "Wrong usb tx data port\n");
881 			return -1;
882 		}
883 	}
884 
885 	context->adapter = adapter;
886 	context->ep = ep;
887 	context->skb = skb;
888 	tx_urb = context->urb;
889 
890 	usb_fill_bulk_urb(tx_urb, card->udev, usb_sndbulkpipe(card->udev, ep),
891 			  data, skb->len, mwifiex_usb_tx_complete,
892 			  (void *)context);
893 
894 	tx_urb->transfer_flags |= URB_ZERO_PACKET;
895 
896 	if (ep == card->tx_cmd_ep)
897 		atomic_inc(&card->tx_cmd_urb_pending);
898 	else
899 		atomic_inc(&port->tx_data_urb_pending);
900 
901 	if (ep != card->tx_cmd_ep &&
902 	    atomic_read(&port->tx_data_urb_pending) ==
903 					MWIFIEX_TX_DATA_URB) {
904 		port->block_status = true;
905 		adapter->data_sent = mwifiex_usb_data_sent(adapter);
906 		ret = -ENOSR;
907 	}
908 
909 	if (usb_submit_urb(tx_urb, GFP_ATOMIC)) {
910 		mwifiex_dbg(adapter, ERROR,
911 			    "%s: usb_submit_urb failed\n", __func__);
912 		if (ep == card->tx_cmd_ep) {
913 			atomic_dec(&card->tx_cmd_urb_pending);
914 		} else {
915 			atomic_dec(&port->tx_data_urb_pending);
916 			port->block_status = false;
917 			adapter->data_sent = false;
918 			if (port->tx_data_ix)
919 				port->tx_data_ix--;
920 			else
921 				port->tx_data_ix = MWIFIEX_TX_DATA_URB;
922 		}
923 		ret = -1;
924 	}
925 
926 	return ret;
927 }
928 
929 /* This function register usb device and initialize parameter. */
930 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
931 {
932 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
933 
934 	card->adapter = adapter;
935 	adapter->dev = &card->udev->dev;
936 
937 	switch (le16_to_cpu(card->udev->descriptor.idProduct)) {
938 	case USB8997_PID_1:
939 	case USB8997_PID_2:
940 		adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K;
941 		strcpy(adapter->fw_name, USB8997_DEFAULT_FW_NAME);
942 		adapter->ext_scan = true;
943 		break;
944 	case USB8766_PID_1:
945 	case USB8766_PID_2:
946 		adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
947 		strcpy(adapter->fw_name, USB8766_DEFAULT_FW_NAME);
948 		adapter->ext_scan = true;
949 		break;
950 	case USB8801_PID_1:
951 	case USB8801_PID_2:
952 		adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
953 		strcpy(adapter->fw_name, USB8801_DEFAULT_FW_NAME);
954 		adapter->ext_scan = false;
955 		break;
956 	case USB8797_PID_1:
957 	case USB8797_PID_2:
958 	default:
959 		adapter->tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
960 		strcpy(adapter->fw_name, USB8797_DEFAULT_FW_NAME);
961 		break;
962 	}
963 
964 	adapter->usb_mc_status = false;
965 	adapter->usb_mc_setup = false;
966 
967 	return 0;
968 }
969 
970 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
971 {
972 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
973 
974 	card->adapter = NULL;
975 }
976 
977 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
978 				    struct mwifiex_fw_image *fw)
979 {
980 	int ret = 0;
981 	u8 *firmware = fw->fw_buf, *recv_buff;
982 	u32 retries = USB8XXX_FW_MAX_RETRY + 1;
983 	u32 dlen;
984 	u32 fw_seqnum = 0, tlen = 0, dnld_cmd = 0;
985 	struct fw_data *fwdata;
986 	struct fw_sync_header sync_fw;
987 	u8 check_winner = 1;
988 
989 	if (!firmware) {
990 		mwifiex_dbg(adapter, ERROR,
991 			    "No firmware image found! Terminating download\n");
992 		ret = -1;
993 		goto fw_exit;
994 	}
995 
996 	/* Allocate memory for transmit */
997 	fwdata = kzalloc(FW_DNLD_TX_BUF_SIZE, GFP_KERNEL);
998 	if (!fwdata) {
999 		ret = -ENOMEM;
1000 		goto fw_exit;
1001 	}
1002 
1003 	/* Allocate memory for receive */
1004 	recv_buff = kzalloc(FW_DNLD_RX_BUF_SIZE, GFP_KERNEL);
1005 	if (!recv_buff) {
1006 		ret = -ENOMEM;
1007 		goto cleanup;
1008 	}
1009 
1010 	do {
1011 		/* Send pseudo data to check winner status first */
1012 		if (check_winner) {
1013 			memset(&fwdata->fw_hdr, 0, sizeof(struct fw_header));
1014 			dlen = 0;
1015 		} else {
1016 			/* copy the header of the fw_data to get the length */
1017 			memcpy(&fwdata->fw_hdr, &firmware[tlen],
1018 			       sizeof(struct fw_header));
1019 
1020 			dlen = le32_to_cpu(fwdata->fw_hdr.data_len);
1021 			dnld_cmd = le32_to_cpu(fwdata->fw_hdr.dnld_cmd);
1022 			tlen += sizeof(struct fw_header);
1023 
1024 			/* Command 7 doesn't have data length field */
1025 			if (dnld_cmd == FW_CMD_7)
1026 				dlen = 0;
1027 
1028 			memcpy(fwdata->data, &firmware[tlen], dlen);
1029 
1030 			fwdata->seq_num = cpu_to_le32(fw_seqnum);
1031 			tlen += dlen;
1032 		}
1033 
1034 		/* If the send/receive fails or CRC occurs then retry */
1035 		while (--retries) {
1036 			u8 *buf = (u8 *)fwdata;
1037 			u32 len = FW_DATA_XMIT_SIZE;
1038 
1039 			/* send the firmware block */
1040 			ret = mwifiex_write_data_sync(adapter, buf, &len,
1041 						MWIFIEX_USB_EP_CMD_EVENT,
1042 						MWIFIEX_USB_TIMEOUT);
1043 			if (ret) {
1044 				mwifiex_dbg(adapter, ERROR,
1045 					    "write_data_sync: failed: %d\n",
1046 					    ret);
1047 				continue;
1048 			}
1049 
1050 			buf = recv_buff;
1051 			len = FW_DNLD_RX_BUF_SIZE;
1052 
1053 			/* Receive the firmware block response */
1054 			ret = mwifiex_read_data_sync(adapter, buf, &len,
1055 						MWIFIEX_USB_EP_CMD_EVENT,
1056 						MWIFIEX_USB_TIMEOUT);
1057 			if (ret) {
1058 				mwifiex_dbg(adapter, ERROR,
1059 					    "read_data_sync: failed: %d\n",
1060 					    ret);
1061 				continue;
1062 			}
1063 
1064 			memcpy(&sync_fw, recv_buff,
1065 			       sizeof(struct fw_sync_header));
1066 
1067 			/* check 1st firmware block resp for highest bit set */
1068 			if (check_winner) {
1069 				if (le32_to_cpu(sync_fw.cmd) & 0x80000000) {
1070 					mwifiex_dbg(adapter, WARN,
1071 						    "USB is not the winner %#x\n",
1072 						    sync_fw.cmd);
1073 
1074 					/* returning success */
1075 					ret = 0;
1076 					goto cleanup;
1077 				}
1078 
1079 				mwifiex_dbg(adapter, MSG,
1080 					    "start to download FW...\n");
1081 
1082 				check_winner = 0;
1083 				break;
1084 			}
1085 
1086 			/* check the firmware block response for CRC errors */
1087 			if (sync_fw.cmd) {
1088 				mwifiex_dbg(adapter, ERROR,
1089 					    "FW received block with CRC %#x\n",
1090 					    sync_fw.cmd);
1091 				ret = -1;
1092 				continue;
1093 			}
1094 
1095 			retries = USB8XXX_FW_MAX_RETRY + 1;
1096 			break;
1097 		}
1098 		fw_seqnum++;
1099 	} while ((dnld_cmd != FW_HAS_LAST_BLOCK) && retries);
1100 
1101 cleanup:
1102 	mwifiex_dbg(adapter, MSG,
1103 		    "info: FW download over, size %d bytes\n", tlen);
1104 
1105 	kfree(recv_buff);
1106 	kfree(fwdata);
1107 
1108 	if (retries)
1109 		ret = 0;
1110 fw_exit:
1111 	return ret;
1112 }
1113 
1114 static int mwifiex_usb_dnld_fw(struct mwifiex_adapter *adapter,
1115 			struct mwifiex_fw_image *fw)
1116 {
1117 	int ret;
1118 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
1119 
1120 	if (card->usb_boot_state == USB8XXX_FW_DNLD) {
1121 		ret = mwifiex_prog_fw_w_helper(adapter, fw);
1122 		if (ret)
1123 			return -1;
1124 
1125 		/* Boot state changes after successful firmware download */
1126 		if (card->usb_boot_state == USB8XXX_FW_DNLD)
1127 			return -1;
1128 	}
1129 
1130 	ret = mwifiex_usb_rx_init(adapter);
1131 	if (!ret)
1132 		ret = mwifiex_usb_tx_init(adapter);
1133 
1134 	return ret;
1135 }
1136 
1137 static void mwifiex_submit_rx_urb(struct mwifiex_adapter *adapter, u8 ep)
1138 {
1139 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
1140 
1141 	skb_push(card->rx_cmd.skb, INTF_HEADER_LEN);
1142 	if ((ep == card->rx_cmd_ep) &&
1143 	    (!atomic_read(&card->rx_cmd_urb_pending)))
1144 		mwifiex_usb_submit_rx_urb(&card->rx_cmd,
1145 					  MWIFIEX_RX_CMD_BUF_SIZE);
1146 
1147 	return;
1148 }
1149 
1150 static int mwifiex_usb_cmd_event_complete(struct mwifiex_adapter *adapter,
1151 				       struct sk_buff *skb)
1152 {
1153 	mwifiex_submit_rx_urb(adapter, MWIFIEX_USB_EP_CMD_EVENT);
1154 
1155 	return 0;
1156 }
1157 
1158 /* This function wakes up the card. */
1159 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
1160 {
1161 	/* Simulation of HS_AWAKE event */
1162 	adapter->pm_wakeup_fw_try = false;
1163 	del_timer(&adapter->wakeup_timer);
1164 	adapter->pm_wakeup_card_req = false;
1165 	adapter->ps_state = PS_STATE_AWAKE;
1166 
1167 	return 0;
1168 }
1169 
1170 static void mwifiex_usb_submit_rem_rx_urbs(struct mwifiex_adapter *adapter)
1171 {
1172 	struct usb_card_rec *card = (struct usb_card_rec *)adapter->card;
1173 	int i;
1174 	struct urb_context *ctx;
1175 
1176 	for (i = 0; i < MWIFIEX_RX_DATA_URB; i++) {
1177 		if (card->rx_data_list[i].skb)
1178 			continue;
1179 		ctx = &card->rx_data_list[i];
1180 		mwifiex_usb_submit_rx_urb(ctx, MWIFIEX_RX_DATA_BUF_SIZE);
1181 	}
1182 }
1183 
1184 /* This function is called after the card has woken up. */
1185 static inline int
1186 mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
1187 {
1188 	return 0;
1189 }
1190 
1191 static struct mwifiex_if_ops usb_ops = {
1192 	.register_dev =		mwifiex_register_dev,
1193 	.unregister_dev =	mwifiex_unregister_dev,
1194 	.wakeup =		mwifiex_pm_wakeup_card,
1195 	.wakeup_complete =	mwifiex_pm_wakeup_card_complete,
1196 
1197 	/* USB specific */
1198 	.dnld_fw =		mwifiex_usb_dnld_fw,
1199 	.cmdrsp_complete =	mwifiex_usb_cmd_event_complete,
1200 	.event_complete =	mwifiex_usb_cmd_event_complete,
1201 	.host_to_card =		mwifiex_usb_host_to_card,
1202 	.submit_rem_rx_urbs =	mwifiex_usb_submit_rem_rx_urbs,
1203 	.multi_port_resync =	mwifiex_usb_port_resync,
1204 	.is_port_ready =	mwifiex_usb_is_port_ready,
1205 };
1206 
1207 /* This function initializes the USB driver module.
1208  *
1209  * This initiates the semaphore and registers the device with
1210  * USB bus.
1211  */
1212 static int mwifiex_usb_init_module(void)
1213 {
1214 	int ret;
1215 
1216 	pr_debug("Marvell USB8797 Driver\n");
1217 
1218 	sema_init(&add_remove_card_sem, 1);
1219 
1220 	ret = usb_register(&mwifiex_usb_driver);
1221 	if (ret)
1222 		pr_err("Driver register failed!\n");
1223 	else
1224 		pr_debug("info: Driver registered successfully!\n");
1225 
1226 	return ret;
1227 }
1228 
1229 /* This function cleans up the USB driver.
1230  *
1231  * The following major steps are followed in .disconnect for cleanup:
1232  *      - Resume the device if its suspended
1233  *      - Disconnect the device if connected
1234  *      - Shutdown the firmware
1235  *      - Unregister the device from USB bus.
1236  */
1237 static void mwifiex_usb_cleanup_module(void)
1238 {
1239 	if (!down_interruptible(&add_remove_card_sem))
1240 		up(&add_remove_card_sem);
1241 
1242 	/* set the flag as user is removing this module */
1243 	user_rmmod = 1;
1244 
1245 	usb_deregister(&mwifiex_usb_driver);
1246 }
1247 
1248 module_init(mwifiex_usb_init_module);
1249 module_exit(mwifiex_usb_cleanup_module);
1250 
1251 MODULE_AUTHOR("Marvell International Ltd.");
1252 MODULE_DESCRIPTION("Marvell WiFi-Ex USB Driver version" USB_VERSION);
1253 MODULE_VERSION(USB_VERSION);
1254 MODULE_LICENSE("GPL v2");
1255 MODULE_FIRMWARE(USB8766_DEFAULT_FW_NAME);
1256 MODULE_FIRMWARE(USB8797_DEFAULT_FW_NAME);
1257 MODULE_FIRMWARE(USB8801_DEFAULT_FW_NAME);
1258 MODULE_FIRMWARE(USB8997_DEFAULT_FW_NAME);
1259