xref: /openbmc/linux/drivers/net/wireless/ath/ath6kl/usb.c (revision 62ebaf2f)
1 /*
2  * Copyright (c) 2007-2011 Atheros Communications Inc.
3  * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include <linux/module.h>
19 #include <linux/usb.h>
20 
21 #include "debug.h"
22 #include "core.h"
23 
24 /* constants */
25 #define TX_URB_COUNT            32
26 #define RX_URB_COUNT            32
27 #define ATH6KL_USB_RX_BUFFER_SIZE  4096
28 
29 /* tx/rx pipes for usb */
30 enum ATH6KL_USB_PIPE_ID {
31 	ATH6KL_USB_PIPE_TX_CTRL = 0,
32 	ATH6KL_USB_PIPE_TX_DATA_LP,
33 	ATH6KL_USB_PIPE_TX_DATA_MP,
34 	ATH6KL_USB_PIPE_TX_DATA_HP,
35 	ATH6KL_USB_PIPE_RX_CTRL,
36 	ATH6KL_USB_PIPE_RX_DATA,
37 	ATH6KL_USB_PIPE_RX_DATA2,
38 	ATH6KL_USB_PIPE_RX_INT,
39 	ATH6KL_USB_PIPE_MAX
40 };
41 
42 #define ATH6KL_USB_PIPE_INVALID ATH6KL_USB_PIPE_MAX
43 
44 struct ath6kl_usb_pipe {
45 	struct list_head urb_list_head;
46 	struct usb_anchor urb_submitted;
47 	u32 urb_alloc;
48 	u32 urb_cnt;
49 	u32 urb_cnt_thresh;
50 	unsigned int usb_pipe_handle;
51 	u32 flags;
52 	u8 ep_address;
53 	u8 logical_pipe_num;
54 	struct ath6kl_usb *ar_usb;
55 	u16 max_packet_size;
56 	struct work_struct io_complete_work;
57 	struct sk_buff_head io_comp_queue;
58 	struct usb_endpoint_descriptor *ep_desc;
59 };
60 
61 #define ATH6KL_USB_PIPE_FLAG_TX    (1 << 0)
62 
63 /* usb device object */
64 struct ath6kl_usb {
65 	/* protects pipe->urb_list_head and  pipe->urb_cnt */
66 	spinlock_t cs_lock;
67 
68 	struct usb_device *udev;
69 	struct usb_interface *interface;
70 	struct ath6kl_usb_pipe pipes[ATH6KL_USB_PIPE_MAX];
71 	u8 *diag_cmd_buffer;
72 	u8 *diag_resp_buffer;
73 	struct ath6kl *ar;
74 	struct workqueue_struct *wq;
75 };
76 
77 /* usb urb object */
78 struct ath6kl_urb_context {
79 	struct list_head link;
80 	struct ath6kl_usb_pipe *pipe;
81 	struct sk_buff *skb;
82 	struct ath6kl *ar;
83 };
84 
85 /* USB endpoint definitions */
86 #define ATH6KL_USB_EP_ADDR_APP_CTRL_IN          0x81
87 #define ATH6KL_USB_EP_ADDR_APP_DATA_IN          0x82
88 #define ATH6KL_USB_EP_ADDR_APP_DATA2_IN         0x83
89 #define ATH6KL_USB_EP_ADDR_APP_INT_IN           0x84
90 
91 #define ATH6KL_USB_EP_ADDR_APP_CTRL_OUT         0x01
92 #define ATH6KL_USB_EP_ADDR_APP_DATA_LP_OUT      0x02
93 #define ATH6KL_USB_EP_ADDR_APP_DATA_MP_OUT      0x03
94 #define ATH6KL_USB_EP_ADDR_APP_DATA_HP_OUT      0x04
95 
96 /* diagnostic command defnitions */
97 #define ATH6KL_USB_CONTROL_REQ_SEND_BMI_CMD        1
98 #define ATH6KL_USB_CONTROL_REQ_RECV_BMI_RESP       2
99 #define ATH6KL_USB_CONTROL_REQ_DIAG_CMD            3
100 #define ATH6KL_USB_CONTROL_REQ_DIAG_RESP           4
101 
102 #define ATH6KL_USB_CTRL_DIAG_CC_READ               0
103 #define ATH6KL_USB_CTRL_DIAG_CC_WRITE              1
104 
105 struct ath6kl_usb_ctrl_diag_cmd_write {
106 	__le32 cmd;
107 	__le32 address;
108 	__le32 value;
109 	__le32 _pad[1];
110 } __packed;
111 
112 struct ath6kl_usb_ctrl_diag_cmd_read {
113 	__le32 cmd;
114 	__le32 address;
115 } __packed;
116 
117 struct ath6kl_usb_ctrl_diag_resp_read {
118 	__le32 value;
119 } __packed;
120 
121 /* function declarations */
122 static void ath6kl_usb_recv_complete(struct urb *urb);
123 
124 #define ATH6KL_USB_IS_BULK_EP(attr) (((attr) & 3) == 0x02)
125 #define ATH6KL_USB_IS_INT_EP(attr)  (((attr) & 3) == 0x03)
126 #define ATH6KL_USB_IS_ISOC_EP(attr)  (((attr) & 3) == 0x01)
127 #define ATH6KL_USB_IS_DIR_IN(addr)  ((addr) & 0x80)
128 
129 /* pipe/urb operations */
130 static struct ath6kl_urb_context *
ath6kl_usb_alloc_urb_from_pipe(struct ath6kl_usb_pipe * pipe)131 ath6kl_usb_alloc_urb_from_pipe(struct ath6kl_usb_pipe *pipe)
132 {
133 	struct ath6kl_urb_context *urb_context = NULL;
134 	unsigned long flags;
135 
136 	/* bail if this pipe is not initialized */
137 	if (!pipe->ar_usb)
138 		return NULL;
139 
140 	spin_lock_irqsave(&pipe->ar_usb->cs_lock, flags);
141 	if (!list_empty(&pipe->urb_list_head)) {
142 		urb_context =
143 		    list_first_entry(&pipe->urb_list_head,
144 				     struct ath6kl_urb_context, link);
145 		list_del(&urb_context->link);
146 		pipe->urb_cnt--;
147 	}
148 	spin_unlock_irqrestore(&pipe->ar_usb->cs_lock, flags);
149 
150 	return urb_context;
151 }
152 
ath6kl_usb_free_urb_to_pipe(struct ath6kl_usb_pipe * pipe,struct ath6kl_urb_context * urb_context)153 static void ath6kl_usb_free_urb_to_pipe(struct ath6kl_usb_pipe *pipe,
154 					struct ath6kl_urb_context *urb_context)
155 {
156 	unsigned long flags;
157 
158 	/* bail if this pipe is not initialized */
159 	if (!pipe->ar_usb)
160 		return;
161 
162 	spin_lock_irqsave(&pipe->ar_usb->cs_lock, flags);
163 	pipe->urb_cnt++;
164 
165 	list_add(&urb_context->link, &pipe->urb_list_head);
166 	spin_unlock_irqrestore(&pipe->ar_usb->cs_lock, flags);
167 }
168 
ath6kl_usb_cleanup_recv_urb(struct ath6kl_urb_context * urb_context)169 static void ath6kl_usb_cleanup_recv_urb(struct ath6kl_urb_context *urb_context)
170 {
171 	dev_kfree_skb(urb_context->skb);
172 	urb_context->skb = NULL;
173 
174 	ath6kl_usb_free_urb_to_pipe(urb_context->pipe, urb_context);
175 }
176 
ath6kl_usb_priv(struct ath6kl * ar)177 static inline struct ath6kl_usb *ath6kl_usb_priv(struct ath6kl *ar)
178 {
179 	return ar->hif_priv;
180 }
181 
182 /* pipe resource allocation/cleanup */
ath6kl_usb_alloc_pipe_resources(struct ath6kl_usb_pipe * pipe,int urb_cnt)183 static int ath6kl_usb_alloc_pipe_resources(struct ath6kl_usb_pipe *pipe,
184 					   int urb_cnt)
185 {
186 	struct ath6kl_urb_context *urb_context;
187 	int status = 0, i;
188 
189 	INIT_LIST_HEAD(&pipe->urb_list_head);
190 	init_usb_anchor(&pipe->urb_submitted);
191 
192 	for (i = 0; i < urb_cnt; i++) {
193 		urb_context = kzalloc(sizeof(struct ath6kl_urb_context),
194 				      GFP_KERNEL);
195 		if (urb_context == NULL) {
196 			status = -ENOMEM;
197 			goto fail_alloc_pipe_resources;
198 		}
199 
200 		urb_context->pipe = pipe;
201 
202 		/*
203 		 * we are only allocate the urb contexts here, the actual URB
204 		 * is allocated from the kernel as needed to do a transaction
205 		 */
206 		pipe->urb_alloc++;
207 		ath6kl_usb_free_urb_to_pipe(pipe, urb_context);
208 	}
209 
210 	ath6kl_dbg(ATH6KL_DBG_USB,
211 		   "ath6kl usb: alloc resources lpipe:%d hpipe:0x%X urbs:%d\n",
212 		   pipe->logical_pipe_num, pipe->usb_pipe_handle,
213 		   pipe->urb_alloc);
214 
215 fail_alloc_pipe_resources:
216 	return status;
217 }
218 
ath6kl_usb_free_pipe_resources(struct ath6kl_usb_pipe * pipe)219 static void ath6kl_usb_free_pipe_resources(struct ath6kl_usb_pipe *pipe)
220 {
221 	struct ath6kl_urb_context *urb_context;
222 
223 	if (pipe->ar_usb == NULL) {
224 		/* nothing allocated for this pipe */
225 		return;
226 	}
227 
228 	ath6kl_dbg(ATH6KL_DBG_USB,
229 		   "ath6kl usb: free resources lpipe:%d"
230 		   "hpipe:0x%X urbs:%d avail:%d\n",
231 		   pipe->logical_pipe_num, pipe->usb_pipe_handle,
232 		   pipe->urb_alloc, pipe->urb_cnt);
233 
234 	if (pipe->urb_alloc != pipe->urb_cnt) {
235 		ath6kl_dbg(ATH6KL_DBG_USB,
236 			   "ath6kl usb: urb leak! lpipe:%d"
237 			   "hpipe:0x%X urbs:%d avail:%d\n",
238 			   pipe->logical_pipe_num, pipe->usb_pipe_handle,
239 			   pipe->urb_alloc, pipe->urb_cnt);
240 	}
241 
242 	while (true) {
243 		urb_context = ath6kl_usb_alloc_urb_from_pipe(pipe);
244 		if (urb_context == NULL)
245 			break;
246 		kfree(urb_context);
247 	}
248 }
249 
ath6kl_usb_cleanup_pipe_resources(struct ath6kl_usb * ar_usb)250 static void ath6kl_usb_cleanup_pipe_resources(struct ath6kl_usb *ar_usb)
251 {
252 	int i;
253 
254 	for (i = 0; i < ATH6KL_USB_PIPE_MAX; i++)
255 		ath6kl_usb_free_pipe_resources(&ar_usb->pipes[i]);
256 }
257 
ath6kl_usb_get_logical_pipe_num(struct ath6kl_usb * ar_usb,u8 ep_address,int * urb_count)258 static u8 ath6kl_usb_get_logical_pipe_num(struct ath6kl_usb *ar_usb,
259 					  u8 ep_address, int *urb_count)
260 {
261 	u8 pipe_num = ATH6KL_USB_PIPE_INVALID;
262 
263 	switch (ep_address) {
264 	case ATH6KL_USB_EP_ADDR_APP_CTRL_IN:
265 		pipe_num = ATH6KL_USB_PIPE_RX_CTRL;
266 		*urb_count = RX_URB_COUNT;
267 		break;
268 	case ATH6KL_USB_EP_ADDR_APP_DATA_IN:
269 		pipe_num = ATH6KL_USB_PIPE_RX_DATA;
270 		*urb_count = RX_URB_COUNT;
271 		break;
272 	case ATH6KL_USB_EP_ADDR_APP_INT_IN:
273 		pipe_num = ATH6KL_USB_PIPE_RX_INT;
274 		*urb_count = RX_URB_COUNT;
275 		break;
276 	case ATH6KL_USB_EP_ADDR_APP_DATA2_IN:
277 		pipe_num = ATH6KL_USB_PIPE_RX_DATA2;
278 		*urb_count = RX_URB_COUNT;
279 		break;
280 	case ATH6KL_USB_EP_ADDR_APP_CTRL_OUT:
281 		pipe_num = ATH6KL_USB_PIPE_TX_CTRL;
282 		*urb_count = TX_URB_COUNT;
283 		break;
284 	case ATH6KL_USB_EP_ADDR_APP_DATA_LP_OUT:
285 		pipe_num = ATH6KL_USB_PIPE_TX_DATA_LP;
286 		*urb_count = TX_URB_COUNT;
287 		break;
288 	case ATH6KL_USB_EP_ADDR_APP_DATA_MP_OUT:
289 		pipe_num = ATH6KL_USB_PIPE_TX_DATA_MP;
290 		*urb_count = TX_URB_COUNT;
291 		break;
292 	case ATH6KL_USB_EP_ADDR_APP_DATA_HP_OUT:
293 		pipe_num = ATH6KL_USB_PIPE_TX_DATA_HP;
294 		*urb_count = TX_URB_COUNT;
295 		break;
296 	default:
297 		/* note: there may be endpoints not currently used */
298 		break;
299 	}
300 
301 	return pipe_num;
302 }
303 
ath6kl_usb_setup_pipe_resources(struct ath6kl_usb * ar_usb)304 static int ath6kl_usb_setup_pipe_resources(struct ath6kl_usb *ar_usb)
305 {
306 	struct usb_interface *interface = ar_usb->interface;
307 	struct usb_host_interface *iface_desc = interface->cur_altsetting;
308 	struct usb_endpoint_descriptor *endpoint;
309 	struct ath6kl_usb_pipe *pipe;
310 	int i, urbcount, status = 0;
311 	u8 pipe_num;
312 
313 	ath6kl_dbg(ATH6KL_DBG_USB, "setting up USB Pipes using interface\n");
314 
315 	/* walk descriptors and setup pipes */
316 	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
317 		endpoint = &iface_desc->endpoint[i].desc;
318 
319 		if (ATH6KL_USB_IS_BULK_EP(endpoint->bmAttributes)) {
320 			ath6kl_dbg(ATH6KL_DBG_USB,
321 				   "%s Bulk Ep:0x%2.2X maxpktsz:%d\n",
322 				   ATH6KL_USB_IS_DIR_IN
323 				   (endpoint->bEndpointAddress) ?
324 				   "RX" : "TX", endpoint->bEndpointAddress,
325 				   le16_to_cpu(endpoint->wMaxPacketSize));
326 		} else if (ATH6KL_USB_IS_INT_EP(endpoint->bmAttributes)) {
327 			ath6kl_dbg(ATH6KL_DBG_USB,
328 				   "%s Int Ep:0x%2.2X maxpktsz:%d interval:%d\n",
329 				   ATH6KL_USB_IS_DIR_IN
330 				   (endpoint->bEndpointAddress) ?
331 				   "RX" : "TX", endpoint->bEndpointAddress,
332 				   le16_to_cpu(endpoint->wMaxPacketSize),
333 				   endpoint->bInterval);
334 		} else if (ATH6KL_USB_IS_ISOC_EP(endpoint->bmAttributes)) {
335 			/* TODO for ISO */
336 			ath6kl_dbg(ATH6KL_DBG_USB,
337 				   "%s ISOC Ep:0x%2.2X maxpktsz:%d interval:%d\n",
338 				   ATH6KL_USB_IS_DIR_IN
339 				   (endpoint->bEndpointAddress) ?
340 				   "RX" : "TX", endpoint->bEndpointAddress,
341 				   le16_to_cpu(endpoint->wMaxPacketSize),
342 				   endpoint->bInterval);
343 		}
344 
345 		/* Ignore broken descriptors. */
346 		if (usb_endpoint_maxp(endpoint) == 0)
347 			continue;
348 
349 		urbcount = 0;
350 
351 		pipe_num =
352 		    ath6kl_usb_get_logical_pipe_num(ar_usb,
353 						    endpoint->bEndpointAddress,
354 						    &urbcount);
355 		if (pipe_num == ATH6KL_USB_PIPE_INVALID)
356 			continue;
357 
358 		pipe = &ar_usb->pipes[pipe_num];
359 		if (pipe->ar_usb != NULL) {
360 			/* hmmm..pipe was already setup */
361 			continue;
362 		}
363 
364 		pipe->ar_usb = ar_usb;
365 		pipe->logical_pipe_num = pipe_num;
366 		pipe->ep_address = endpoint->bEndpointAddress;
367 		pipe->max_packet_size = le16_to_cpu(endpoint->wMaxPacketSize);
368 
369 		if (ATH6KL_USB_IS_BULK_EP(endpoint->bmAttributes)) {
370 			if (ATH6KL_USB_IS_DIR_IN(pipe->ep_address)) {
371 				pipe->usb_pipe_handle =
372 				    usb_rcvbulkpipe(ar_usb->udev,
373 						    pipe->ep_address);
374 			} else {
375 				pipe->usb_pipe_handle =
376 				    usb_sndbulkpipe(ar_usb->udev,
377 						    pipe->ep_address);
378 			}
379 		} else if (ATH6KL_USB_IS_INT_EP(endpoint->bmAttributes)) {
380 			if (ATH6KL_USB_IS_DIR_IN(pipe->ep_address)) {
381 				pipe->usb_pipe_handle =
382 				    usb_rcvintpipe(ar_usb->udev,
383 						   pipe->ep_address);
384 			} else {
385 				pipe->usb_pipe_handle =
386 				    usb_sndintpipe(ar_usb->udev,
387 						   pipe->ep_address);
388 			}
389 		} else if (ATH6KL_USB_IS_ISOC_EP(endpoint->bmAttributes)) {
390 			/* TODO for ISO */
391 			if (ATH6KL_USB_IS_DIR_IN(pipe->ep_address)) {
392 				pipe->usb_pipe_handle =
393 				    usb_rcvisocpipe(ar_usb->udev,
394 						    pipe->ep_address);
395 			} else {
396 				pipe->usb_pipe_handle =
397 				    usb_sndisocpipe(ar_usb->udev,
398 						    pipe->ep_address);
399 			}
400 		}
401 
402 		pipe->ep_desc = endpoint;
403 
404 		if (!ATH6KL_USB_IS_DIR_IN(pipe->ep_address))
405 			pipe->flags |= ATH6KL_USB_PIPE_FLAG_TX;
406 
407 		status = ath6kl_usb_alloc_pipe_resources(pipe, urbcount);
408 		if (status != 0)
409 			break;
410 	}
411 
412 	return status;
413 }
414 
415 /* pipe operations */
ath6kl_usb_post_recv_transfers(struct ath6kl_usb_pipe * recv_pipe,int buffer_length)416 static void ath6kl_usb_post_recv_transfers(struct ath6kl_usb_pipe *recv_pipe,
417 					   int buffer_length)
418 {
419 	struct ath6kl_urb_context *urb_context;
420 	struct urb *urb;
421 	int usb_status;
422 
423 	while (true) {
424 		urb_context = ath6kl_usb_alloc_urb_from_pipe(recv_pipe);
425 		if (urb_context == NULL)
426 			break;
427 
428 		urb_context->skb = dev_alloc_skb(buffer_length);
429 		if (urb_context->skb == NULL)
430 			goto err_cleanup_urb;
431 
432 		urb = usb_alloc_urb(0, GFP_ATOMIC);
433 		if (urb == NULL)
434 			goto err_cleanup_urb;
435 
436 		usb_fill_bulk_urb(urb,
437 				  recv_pipe->ar_usb->udev,
438 				  recv_pipe->usb_pipe_handle,
439 				  urb_context->skb->data,
440 				  buffer_length,
441 				  ath6kl_usb_recv_complete, urb_context);
442 
443 		ath6kl_dbg(ATH6KL_DBG_USB_BULK,
444 			   "ath6kl usb: bulk recv submit:%d, 0x%X (ep:0x%2.2X), %d bytes buf:0x%p\n",
445 			   recv_pipe->logical_pipe_num,
446 			   recv_pipe->usb_pipe_handle, recv_pipe->ep_address,
447 			   buffer_length, urb_context->skb);
448 
449 		usb_anchor_urb(urb, &recv_pipe->urb_submitted);
450 		usb_status = usb_submit_urb(urb, GFP_ATOMIC);
451 
452 		if (usb_status) {
453 			ath6kl_dbg(ATH6KL_DBG_USB_BULK,
454 				   "ath6kl usb : usb bulk recv failed %d\n",
455 				   usb_status);
456 			usb_unanchor_urb(urb);
457 			usb_free_urb(urb);
458 			goto err_cleanup_urb;
459 		}
460 		usb_free_urb(urb);
461 	}
462 	return;
463 
464 err_cleanup_urb:
465 	ath6kl_usb_cleanup_recv_urb(urb_context);
466 	return;
467 }
468 
ath6kl_usb_flush_all(struct ath6kl_usb * ar_usb)469 static void ath6kl_usb_flush_all(struct ath6kl_usb *ar_usb)
470 {
471 	int i;
472 
473 	for (i = 0; i < ATH6KL_USB_PIPE_MAX; i++) {
474 		if (ar_usb->pipes[i].ar_usb != NULL)
475 			usb_kill_anchored_urbs(&ar_usb->pipes[i].urb_submitted);
476 	}
477 
478 	/*
479 	 * Flushing any pending I/O may schedule work this call will block
480 	 * until all scheduled work runs to completion.
481 	 */
482 	flush_workqueue(ar_usb->wq);
483 }
484 
ath6kl_usb_start_recv_pipes(struct ath6kl_usb * ar_usb)485 static void ath6kl_usb_start_recv_pipes(struct ath6kl_usb *ar_usb)
486 {
487 	/*
488 	 * note: control pipe is no longer used
489 	 * ar_usb->pipes[ATH6KL_USB_PIPE_RX_CTRL].urb_cnt_thresh =
490 	 *      ar_usb->pipes[ATH6KL_USB_PIPE_RX_CTRL].urb_alloc/2;
491 	 * ath6kl_usb_post_recv_transfers(&ar_usb->
492 	 *		pipes[ATH6KL_USB_PIPE_RX_CTRL],
493 	 *		ATH6KL_USB_RX_BUFFER_SIZE);
494 	 */
495 
496 	ar_usb->pipes[ATH6KL_USB_PIPE_RX_DATA].urb_cnt_thresh = 1;
497 
498 	ath6kl_usb_post_recv_transfers(&ar_usb->pipes[ATH6KL_USB_PIPE_RX_DATA],
499 				       ATH6KL_USB_RX_BUFFER_SIZE);
500 }
501 
502 /* hif usb rx/tx completion functions */
ath6kl_usb_recv_complete(struct urb * urb)503 static void ath6kl_usb_recv_complete(struct urb *urb)
504 {
505 	struct ath6kl_urb_context *urb_context = urb->context;
506 	struct ath6kl_usb_pipe *pipe = urb_context->pipe;
507 	struct sk_buff *skb = NULL;
508 	int status = 0;
509 
510 	ath6kl_dbg(ATH6KL_DBG_USB_BULK,
511 		   "%s: recv pipe: %d, stat:%d, len:%d urb:0x%p\n", __func__,
512 		   pipe->logical_pipe_num, urb->status, urb->actual_length,
513 		   urb);
514 
515 	if (urb->status != 0) {
516 		status = -EIO;
517 		switch (urb->status) {
518 		case -ECONNRESET:
519 		case -ENOENT:
520 		case -ESHUTDOWN:
521 			/*
522 			 * no need to spew these errors when device
523 			 * removed or urb killed due to driver shutdown
524 			 */
525 			status = -ECANCELED;
526 			break;
527 		default:
528 			ath6kl_dbg(ATH6KL_DBG_USB_BULK,
529 				   "%s recv pipe: %d (ep:0x%2.2X), failed:%d\n",
530 				   __func__, pipe->logical_pipe_num,
531 				   pipe->ep_address, urb->status);
532 			break;
533 		}
534 		goto cleanup_recv_urb;
535 	}
536 
537 	if (urb->actual_length == 0)
538 		goto cleanup_recv_urb;
539 
540 	skb = urb_context->skb;
541 
542 	/* we are going to pass it up */
543 	urb_context->skb = NULL;
544 	skb_put(skb, urb->actual_length);
545 
546 	/* note: queue implements a lock */
547 	skb_queue_tail(&pipe->io_comp_queue, skb);
548 	queue_work(pipe->ar_usb->wq, &pipe->io_complete_work);
549 
550 cleanup_recv_urb:
551 	ath6kl_usb_cleanup_recv_urb(urb_context);
552 
553 	if (status == 0 &&
554 	    pipe->urb_cnt >= pipe->urb_cnt_thresh) {
555 		/* our free urbs are piling up, post more transfers */
556 		ath6kl_usb_post_recv_transfers(pipe, ATH6KL_USB_RX_BUFFER_SIZE);
557 	}
558 }
559 
ath6kl_usb_usb_transmit_complete(struct urb * urb)560 static void ath6kl_usb_usb_transmit_complete(struct urb *urb)
561 {
562 	struct ath6kl_urb_context *urb_context = urb->context;
563 	struct ath6kl_usb_pipe *pipe = urb_context->pipe;
564 	struct sk_buff *skb;
565 
566 	ath6kl_dbg(ATH6KL_DBG_USB_BULK,
567 		   "%s: pipe: %d, stat:%d, len:%d\n",
568 		   __func__, pipe->logical_pipe_num, urb->status,
569 		   urb->actual_length);
570 
571 	if (urb->status != 0) {
572 		ath6kl_dbg(ATH6KL_DBG_USB_BULK,
573 			   "%s:  pipe: %d, failed:%d\n",
574 			   __func__, pipe->logical_pipe_num, urb->status);
575 	}
576 
577 	skb = urb_context->skb;
578 	urb_context->skb = NULL;
579 	ath6kl_usb_free_urb_to_pipe(urb_context->pipe, urb_context);
580 
581 	/* note: queue implements a lock */
582 	skb_queue_tail(&pipe->io_comp_queue, skb);
583 	queue_work(pipe->ar_usb->wq, &pipe->io_complete_work);
584 }
585 
ath6kl_usb_io_comp_work(struct work_struct * work)586 static void ath6kl_usb_io_comp_work(struct work_struct *work)
587 {
588 	struct ath6kl_usb_pipe *pipe = container_of(work,
589 						    struct ath6kl_usb_pipe,
590 						    io_complete_work);
591 	struct ath6kl_usb *ar_usb;
592 	struct sk_buff *skb;
593 
594 	ar_usb = pipe->ar_usb;
595 
596 	while ((skb = skb_dequeue(&pipe->io_comp_queue))) {
597 		if (pipe->flags & ATH6KL_USB_PIPE_FLAG_TX) {
598 			ath6kl_dbg(ATH6KL_DBG_USB_BULK,
599 				   "ath6kl usb xmit callback buf:0x%p\n", skb);
600 			ath6kl_core_tx_complete(ar_usb->ar, skb);
601 		} else {
602 			ath6kl_dbg(ATH6KL_DBG_USB_BULK,
603 				   "ath6kl usb recv callback buf:0x%p\n", skb);
604 			ath6kl_core_rx_complete(ar_usb->ar, skb,
605 						pipe->logical_pipe_num);
606 		}
607 	}
608 }
609 
610 #define ATH6KL_USB_MAX_DIAG_CMD (sizeof(struct ath6kl_usb_ctrl_diag_cmd_write))
611 #define ATH6KL_USB_MAX_DIAG_RESP (sizeof(struct ath6kl_usb_ctrl_diag_resp_read))
612 
ath6kl_usb_destroy(struct ath6kl_usb * ar_usb)613 static void ath6kl_usb_destroy(struct ath6kl_usb *ar_usb)
614 {
615 	ath6kl_usb_flush_all(ar_usb);
616 
617 	ath6kl_usb_cleanup_pipe_resources(ar_usb);
618 
619 	usb_set_intfdata(ar_usb->interface, NULL);
620 
621 	kfree(ar_usb->diag_cmd_buffer);
622 	kfree(ar_usb->diag_resp_buffer);
623 	destroy_workqueue(ar_usb->wq);
624 
625 	kfree(ar_usb);
626 }
627 
ath6kl_usb_create(struct usb_interface * interface)628 static struct ath6kl_usb *ath6kl_usb_create(struct usb_interface *interface)
629 {
630 	struct usb_device *dev = interface_to_usbdev(interface);
631 	struct ath6kl_usb *ar_usb;
632 	struct ath6kl_usb_pipe *pipe;
633 	int status = 0;
634 	int i;
635 
636 	/* ath6kl_usb_destroy() needs ar_usb != NULL && ar_usb->wq != NULL. */
637 	ar_usb = kzalloc(sizeof(struct ath6kl_usb), GFP_KERNEL);
638 	if (ar_usb == NULL)
639 		return NULL;
640 	ar_usb->wq = alloc_workqueue("ath6kl_wq", 0, 0);
641 	if (!ar_usb->wq) {
642 		kfree(ar_usb);
643 		return NULL;
644 	}
645 
646 	usb_set_intfdata(interface, ar_usb);
647 	spin_lock_init(&(ar_usb->cs_lock));
648 	ar_usb->udev = dev;
649 	ar_usb->interface = interface;
650 
651 	for (i = 0; i < ATH6KL_USB_PIPE_MAX; i++) {
652 		pipe = &ar_usb->pipes[i];
653 		INIT_WORK(&pipe->io_complete_work,
654 			  ath6kl_usb_io_comp_work);
655 		skb_queue_head_init(&pipe->io_comp_queue);
656 	}
657 
658 	ar_usb->diag_cmd_buffer = kzalloc(ATH6KL_USB_MAX_DIAG_CMD, GFP_KERNEL);
659 	if (ar_usb->diag_cmd_buffer == NULL) {
660 		status = -ENOMEM;
661 		goto fail_ath6kl_usb_create;
662 	}
663 
664 	ar_usb->diag_resp_buffer = kzalloc(ATH6KL_USB_MAX_DIAG_RESP,
665 					   GFP_KERNEL);
666 	if (ar_usb->diag_resp_buffer == NULL) {
667 		status = -ENOMEM;
668 		goto fail_ath6kl_usb_create;
669 	}
670 
671 	status = ath6kl_usb_setup_pipe_resources(ar_usb);
672 
673 fail_ath6kl_usb_create:
674 	if (status != 0) {
675 		ath6kl_usb_destroy(ar_usb);
676 		ar_usb = NULL;
677 	}
678 	return ar_usb;
679 }
680 
ath6kl_usb_device_detached(struct usb_interface * interface)681 static void ath6kl_usb_device_detached(struct usb_interface *interface)
682 {
683 	struct ath6kl_usb *ar_usb;
684 
685 	ar_usb = usb_get_intfdata(interface);
686 	if (ar_usb == NULL)
687 		return;
688 
689 	ath6kl_stop_txrx(ar_usb->ar);
690 
691 	/* Delay to wait for the target to reboot */
692 	mdelay(20);
693 	ath6kl_core_cleanup(ar_usb->ar);
694 	ath6kl_usb_destroy(ar_usb);
695 }
696 
697 /* exported hif usb APIs for htc pipe */
hif_start(struct ath6kl * ar)698 static void hif_start(struct ath6kl *ar)
699 {
700 	struct ath6kl_usb *device = ath6kl_usb_priv(ar);
701 	int i;
702 
703 	ath6kl_usb_start_recv_pipes(device);
704 
705 	/* set the TX resource avail threshold for each TX pipe */
706 	for (i = ATH6KL_USB_PIPE_TX_CTRL;
707 	     i <= ATH6KL_USB_PIPE_TX_DATA_HP; i++) {
708 		device->pipes[i].urb_cnt_thresh =
709 		    device->pipes[i].urb_alloc / 2;
710 	}
711 }
712 
ath6kl_usb_send(struct ath6kl * ar,u8 PipeID,struct sk_buff * hdr_skb,struct sk_buff * skb)713 static int ath6kl_usb_send(struct ath6kl *ar, u8 PipeID,
714 			   struct sk_buff *hdr_skb, struct sk_buff *skb)
715 {
716 	struct ath6kl_usb *device = ath6kl_usb_priv(ar);
717 	struct ath6kl_usb_pipe *pipe = &device->pipes[PipeID];
718 	struct ath6kl_urb_context *urb_context;
719 	int usb_status, status = 0;
720 	struct urb *urb;
721 	u8 *data;
722 	u32 len;
723 
724 	ath6kl_dbg(ATH6KL_DBG_USB_BULK, "+%s pipe : %d, buf:0x%p\n",
725 		   __func__, PipeID, skb);
726 
727 	urb_context = ath6kl_usb_alloc_urb_from_pipe(pipe);
728 
729 	if (urb_context == NULL) {
730 		/*
731 		 * TODO: it is possible to run out of urbs if
732 		 * 2 endpoints map to the same pipe ID
733 		 */
734 		ath6kl_dbg(ATH6KL_DBG_USB_BULK,
735 			   "%s pipe:%d no urbs left. URB Cnt : %d\n",
736 			   __func__, PipeID, pipe->urb_cnt);
737 		status = -ENOMEM;
738 		goto fail_hif_send;
739 	}
740 
741 	urb_context->skb = skb;
742 
743 	data = skb->data;
744 	len = skb->len;
745 
746 	urb = usb_alloc_urb(0, GFP_ATOMIC);
747 	if (urb == NULL) {
748 		status = -ENOMEM;
749 		ath6kl_usb_free_urb_to_pipe(urb_context->pipe,
750 					    urb_context);
751 		goto fail_hif_send;
752 	}
753 
754 	usb_fill_bulk_urb(urb,
755 			  device->udev,
756 			  pipe->usb_pipe_handle,
757 			  data,
758 			  len,
759 			  ath6kl_usb_usb_transmit_complete, urb_context);
760 
761 	if ((len % pipe->max_packet_size) == 0) {
762 		/* hit a max packet boundary on this pipe */
763 		urb->transfer_flags |= URB_ZERO_PACKET;
764 	}
765 
766 	ath6kl_dbg(ATH6KL_DBG_USB_BULK,
767 		   "athusb bulk send submit:%d, 0x%X (ep:0x%2.2X), %d bytes\n",
768 		   pipe->logical_pipe_num, pipe->usb_pipe_handle,
769 		   pipe->ep_address, len);
770 
771 	usb_anchor_urb(urb, &pipe->urb_submitted);
772 	usb_status = usb_submit_urb(urb, GFP_ATOMIC);
773 
774 	if (usb_status) {
775 		ath6kl_dbg(ATH6KL_DBG_USB_BULK,
776 			   "ath6kl usb : usb bulk transmit failed %d\n",
777 			   usb_status);
778 		usb_unanchor_urb(urb);
779 		ath6kl_usb_free_urb_to_pipe(urb_context->pipe,
780 					    urb_context);
781 		status = -EINVAL;
782 	}
783 	usb_free_urb(urb);
784 
785 fail_hif_send:
786 	return status;
787 }
788 
hif_stop(struct ath6kl * ar)789 static void hif_stop(struct ath6kl *ar)
790 {
791 	struct ath6kl_usb *device = ath6kl_usb_priv(ar);
792 
793 	ath6kl_usb_flush_all(device);
794 }
795 
ath6kl_usb_get_default_pipe(struct ath6kl * ar,u8 * ul_pipe,u8 * dl_pipe)796 static void ath6kl_usb_get_default_pipe(struct ath6kl *ar,
797 					u8 *ul_pipe, u8 *dl_pipe)
798 {
799 	*ul_pipe = ATH6KL_USB_PIPE_TX_CTRL;
800 	*dl_pipe = ATH6KL_USB_PIPE_RX_CTRL;
801 }
802 
ath6kl_usb_map_service_pipe(struct ath6kl * ar,u16 svc_id,u8 * ul_pipe,u8 * dl_pipe)803 static int ath6kl_usb_map_service_pipe(struct ath6kl *ar, u16 svc_id,
804 				       u8 *ul_pipe, u8 *dl_pipe)
805 {
806 	int status = 0;
807 
808 	switch (svc_id) {
809 	case HTC_CTRL_RSVD_SVC:
810 	case WMI_CONTROL_SVC:
811 		*ul_pipe = ATH6KL_USB_PIPE_TX_CTRL;
812 		/* due to large control packets, shift to data pipe */
813 		*dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
814 		break;
815 	case WMI_DATA_BE_SVC:
816 	case WMI_DATA_BK_SVC:
817 		*ul_pipe = ATH6KL_USB_PIPE_TX_DATA_LP;
818 		/*
819 		* Disable rxdata2 directly, it will be enabled
820 		* if FW enable rxdata2
821 		*/
822 		*dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
823 		break;
824 	case WMI_DATA_VI_SVC:
825 
826 		if (test_bit(ATH6KL_FW_CAPABILITY_MAP_LP_ENDPOINT,
827 			     ar->fw_capabilities))
828 			*ul_pipe = ATH6KL_USB_PIPE_TX_DATA_LP;
829 		else
830 			*ul_pipe = ATH6KL_USB_PIPE_TX_DATA_MP;
831 		/*
832 		* Disable rxdata2 directly, it will be enabled
833 		* if FW enable rxdata2
834 		*/
835 		*dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
836 		break;
837 	case WMI_DATA_VO_SVC:
838 
839 		if (test_bit(ATH6KL_FW_CAPABILITY_MAP_LP_ENDPOINT,
840 			     ar->fw_capabilities))
841 			*ul_pipe = ATH6KL_USB_PIPE_TX_DATA_LP;
842 		else
843 			*ul_pipe = ATH6KL_USB_PIPE_TX_DATA_MP;
844 		/*
845 		* Disable rxdata2 directly, it will be enabled
846 		* if FW enable rxdata2
847 		*/
848 		*dl_pipe = ATH6KL_USB_PIPE_RX_DATA;
849 		break;
850 	default:
851 		status = -EPERM;
852 		break;
853 	}
854 
855 	return status;
856 }
857 
ath6kl_usb_get_free_queue_number(struct ath6kl * ar,u8 pipe_id)858 static u16 ath6kl_usb_get_free_queue_number(struct ath6kl *ar, u8 pipe_id)
859 {
860 	struct ath6kl_usb *device = ath6kl_usb_priv(ar);
861 
862 	return device->pipes[pipe_id].urb_cnt;
863 }
864 
hif_detach_htc(struct ath6kl * ar)865 static void hif_detach_htc(struct ath6kl *ar)
866 {
867 	struct ath6kl_usb *device = ath6kl_usb_priv(ar);
868 
869 	ath6kl_usb_flush_all(device);
870 }
871 
ath6kl_usb_submit_ctrl_out(struct ath6kl_usb * ar_usb,u8 req,u16 value,u16 index,void * data,u32 size)872 static int ath6kl_usb_submit_ctrl_out(struct ath6kl_usb *ar_usb,
873 				   u8 req, u16 value, u16 index, void *data,
874 				   u32 size)
875 {
876 	u8 *buf = NULL;
877 	int ret;
878 
879 	if (size > 0) {
880 		buf = kmemdup(data, size, GFP_KERNEL);
881 		if (buf == NULL)
882 			return -ENOMEM;
883 	}
884 
885 	/* note: if successful returns number of bytes transfered */
886 	ret = usb_control_msg(ar_usb->udev,
887 			      usb_sndctrlpipe(ar_usb->udev, 0),
888 			      req,
889 			      USB_DIR_OUT | USB_TYPE_VENDOR |
890 			      USB_RECIP_DEVICE, value, index, buf,
891 			      size, 1000);
892 
893 	if (ret < 0) {
894 		ath6kl_warn("Failed to submit usb control message: %d\n", ret);
895 		kfree(buf);
896 		return ret;
897 	}
898 
899 	kfree(buf);
900 
901 	return 0;
902 }
903 
ath6kl_usb_submit_ctrl_in(struct ath6kl_usb * ar_usb,u8 req,u16 value,u16 index,void * data,u32 size)904 static int ath6kl_usb_submit_ctrl_in(struct ath6kl_usb *ar_usb,
905 				  u8 req, u16 value, u16 index, void *data,
906 				  u32 size)
907 {
908 	u8 *buf = NULL;
909 	int ret;
910 
911 	if (size > 0) {
912 		buf = kmalloc(size, GFP_KERNEL);
913 		if (buf == NULL)
914 			return -ENOMEM;
915 	}
916 
917 	/* note: if successful returns number of bytes transfered */
918 	ret = usb_control_msg(ar_usb->udev,
919 				 usb_rcvctrlpipe(ar_usb->udev, 0),
920 				 req,
921 				 USB_DIR_IN | USB_TYPE_VENDOR |
922 				 USB_RECIP_DEVICE, value, index, buf,
923 				 size, 2000);
924 
925 	if (ret < 0) {
926 		ath6kl_warn("Failed to read usb control message: %d\n", ret);
927 		kfree(buf);
928 		return ret;
929 	}
930 
931 	memcpy((u8 *) data, buf, size);
932 
933 	kfree(buf);
934 
935 	return 0;
936 }
937 
ath6kl_usb_ctrl_msg_exchange(struct ath6kl_usb * ar_usb,u8 req_val,u8 * req_buf,u32 req_len,u8 resp_val,u8 * resp_buf,u32 * resp_len)938 static int ath6kl_usb_ctrl_msg_exchange(struct ath6kl_usb *ar_usb,
939 				     u8 req_val, u8 *req_buf, u32 req_len,
940 				     u8 resp_val, u8 *resp_buf, u32 *resp_len)
941 {
942 	int ret;
943 
944 	/* send command */
945 	ret = ath6kl_usb_submit_ctrl_out(ar_usb, req_val, 0, 0,
946 					 req_buf, req_len);
947 
948 	if (ret != 0)
949 		return ret;
950 
951 	if (resp_buf == NULL) {
952 		/* no expected response */
953 		return ret;
954 	}
955 
956 	/* get response */
957 	ret = ath6kl_usb_submit_ctrl_in(ar_usb, resp_val, 0, 0,
958 					resp_buf, *resp_len);
959 
960 	return ret;
961 }
962 
ath6kl_usb_diag_read32(struct ath6kl * ar,u32 address,u32 * data)963 static int ath6kl_usb_diag_read32(struct ath6kl *ar, u32 address, u32 *data)
964 {
965 	struct ath6kl_usb *ar_usb = ar->hif_priv;
966 	struct ath6kl_usb_ctrl_diag_resp_read *resp;
967 	struct ath6kl_usb_ctrl_diag_cmd_read *cmd;
968 	u32 resp_len;
969 	int ret;
970 
971 	cmd = (struct ath6kl_usb_ctrl_diag_cmd_read *) ar_usb->diag_cmd_buffer;
972 
973 	memset(cmd, 0, sizeof(*cmd));
974 	cmd->cmd = ATH6KL_USB_CTRL_DIAG_CC_READ;
975 	cmd->address = cpu_to_le32(address);
976 	resp_len = sizeof(*resp);
977 
978 	ret = ath6kl_usb_ctrl_msg_exchange(ar_usb,
979 				ATH6KL_USB_CONTROL_REQ_DIAG_CMD,
980 				(u8 *) cmd,
981 				sizeof(struct ath6kl_usb_ctrl_diag_cmd_write),
982 				ATH6KL_USB_CONTROL_REQ_DIAG_RESP,
983 				ar_usb->diag_resp_buffer, &resp_len);
984 
985 	if (ret) {
986 		ath6kl_warn("diag read32 failed: %d\n", ret);
987 		return ret;
988 	}
989 
990 	resp = (struct ath6kl_usb_ctrl_diag_resp_read *)
991 		ar_usb->diag_resp_buffer;
992 
993 	*data = le32_to_cpu(resp->value);
994 
995 	return ret;
996 }
997 
ath6kl_usb_diag_write32(struct ath6kl * ar,u32 address,__le32 data)998 static int ath6kl_usb_diag_write32(struct ath6kl *ar, u32 address, __le32 data)
999 {
1000 	struct ath6kl_usb *ar_usb = ar->hif_priv;
1001 	struct ath6kl_usb_ctrl_diag_cmd_write *cmd;
1002 	int ret;
1003 
1004 	cmd = (struct ath6kl_usb_ctrl_diag_cmd_write *) ar_usb->diag_cmd_buffer;
1005 
1006 	memset(cmd, 0, sizeof(struct ath6kl_usb_ctrl_diag_cmd_write));
1007 	cmd->cmd = cpu_to_le32(ATH6KL_USB_CTRL_DIAG_CC_WRITE);
1008 	cmd->address = cpu_to_le32(address);
1009 	cmd->value = data;
1010 
1011 	ret = ath6kl_usb_ctrl_msg_exchange(ar_usb,
1012 					   ATH6KL_USB_CONTROL_REQ_DIAG_CMD,
1013 					   (u8 *) cmd,
1014 					   sizeof(*cmd),
1015 					   0, NULL, NULL);
1016 	if (ret) {
1017 		ath6kl_warn("diag_write32 failed: %d\n", ret);
1018 		return ret;
1019 	}
1020 
1021 	return 0;
1022 }
1023 
ath6kl_usb_bmi_read(struct ath6kl * ar,u8 * buf,u32 len)1024 static int ath6kl_usb_bmi_read(struct ath6kl *ar, u8 *buf, u32 len)
1025 {
1026 	struct ath6kl_usb *ar_usb = ar->hif_priv;
1027 	int ret;
1028 
1029 	/* get response */
1030 	ret = ath6kl_usb_submit_ctrl_in(ar_usb,
1031 					ATH6KL_USB_CONTROL_REQ_RECV_BMI_RESP,
1032 					0, 0, buf, len);
1033 	if (ret) {
1034 		ath6kl_err("Unable to read the bmi data from the device: %d\n",
1035 			   ret);
1036 		return ret;
1037 	}
1038 
1039 	return 0;
1040 }
1041 
ath6kl_usb_bmi_write(struct ath6kl * ar,u8 * buf,u32 len)1042 static int ath6kl_usb_bmi_write(struct ath6kl *ar, u8 *buf, u32 len)
1043 {
1044 	struct ath6kl_usb *ar_usb = ar->hif_priv;
1045 	int ret;
1046 
1047 	/* send command */
1048 	ret = ath6kl_usb_submit_ctrl_out(ar_usb,
1049 					 ATH6KL_USB_CONTROL_REQ_SEND_BMI_CMD,
1050 					 0, 0, buf, len);
1051 	if (ret) {
1052 		ath6kl_err("unable to send the bmi data to the device: %d\n",
1053 			   ret);
1054 		return ret;
1055 	}
1056 
1057 	return 0;
1058 }
1059 
ath6kl_usb_power_on(struct ath6kl * ar)1060 static int ath6kl_usb_power_on(struct ath6kl *ar)
1061 {
1062 	hif_start(ar);
1063 	return 0;
1064 }
1065 
ath6kl_usb_power_off(struct ath6kl * ar)1066 static int ath6kl_usb_power_off(struct ath6kl *ar)
1067 {
1068 	hif_detach_htc(ar);
1069 	return 0;
1070 }
1071 
ath6kl_usb_stop(struct ath6kl * ar)1072 static void ath6kl_usb_stop(struct ath6kl *ar)
1073 {
1074 	hif_stop(ar);
1075 }
1076 
ath6kl_usb_cleanup_scatter(struct ath6kl * ar)1077 static void ath6kl_usb_cleanup_scatter(struct ath6kl *ar)
1078 {
1079 	/*
1080 	 * USB doesn't support it. Just return.
1081 	 */
1082 	return;
1083 }
1084 
ath6kl_usb_suspend(struct ath6kl * ar,struct cfg80211_wowlan * wow)1085 static int ath6kl_usb_suspend(struct ath6kl *ar, struct cfg80211_wowlan *wow)
1086 {
1087 	/*
1088 	 * cfg80211 suspend/WOW currently not supported for USB.
1089 	 */
1090 	return 0;
1091 }
1092 
ath6kl_usb_resume(struct ath6kl * ar)1093 static int ath6kl_usb_resume(struct ath6kl *ar)
1094 {
1095 	/*
1096 	 * cfg80211 resume currently not supported for USB.
1097 	 */
1098 	return 0;
1099 }
1100 
1101 static const struct ath6kl_hif_ops ath6kl_usb_ops = {
1102 	.diag_read32 = ath6kl_usb_diag_read32,
1103 	.diag_write32 = ath6kl_usb_diag_write32,
1104 	.bmi_read = ath6kl_usb_bmi_read,
1105 	.bmi_write = ath6kl_usb_bmi_write,
1106 	.power_on = ath6kl_usb_power_on,
1107 	.power_off = ath6kl_usb_power_off,
1108 	.stop = ath6kl_usb_stop,
1109 	.pipe_send = ath6kl_usb_send,
1110 	.pipe_get_default = ath6kl_usb_get_default_pipe,
1111 	.pipe_map_service = ath6kl_usb_map_service_pipe,
1112 	.pipe_get_free_queue_number = ath6kl_usb_get_free_queue_number,
1113 	.cleanup_scatter = ath6kl_usb_cleanup_scatter,
1114 	.suspend = ath6kl_usb_suspend,
1115 	.resume = ath6kl_usb_resume,
1116 };
1117 
1118 /* ath6kl usb driver registered functions */
ath6kl_usb_probe(struct usb_interface * interface,const struct usb_device_id * id)1119 static int ath6kl_usb_probe(struct usb_interface *interface,
1120 			    const struct usb_device_id *id)
1121 {
1122 	struct usb_device *dev = interface_to_usbdev(interface);
1123 	struct ath6kl *ar;
1124 	struct ath6kl_usb *ar_usb = NULL;
1125 	int vendor_id, product_id;
1126 	int ret = 0;
1127 
1128 	usb_get_dev(dev);
1129 
1130 	vendor_id = le16_to_cpu(dev->descriptor.idVendor);
1131 	product_id = le16_to_cpu(dev->descriptor.idProduct);
1132 
1133 	ath6kl_dbg(ATH6KL_DBG_USB, "vendor_id = %04x\n", vendor_id);
1134 	ath6kl_dbg(ATH6KL_DBG_USB, "product_id = %04x\n", product_id);
1135 
1136 	if (interface->cur_altsetting)
1137 		ath6kl_dbg(ATH6KL_DBG_USB, "USB Interface %d\n",
1138 			   interface->cur_altsetting->desc.bInterfaceNumber);
1139 
1140 
1141 	if (dev->speed == USB_SPEED_HIGH)
1142 		ath6kl_dbg(ATH6KL_DBG_USB, "USB 2.0 Host\n");
1143 	else
1144 		ath6kl_dbg(ATH6KL_DBG_USB, "USB 1.1 Host\n");
1145 
1146 	ar_usb = ath6kl_usb_create(interface);
1147 
1148 	if (ar_usb == NULL) {
1149 		ret = -ENOMEM;
1150 		goto err_usb_put;
1151 	}
1152 
1153 	ar = ath6kl_core_create(&ar_usb->udev->dev);
1154 	if (ar == NULL) {
1155 		ath6kl_err("Failed to alloc ath6kl core\n");
1156 		ret = -ENOMEM;
1157 		goto err_usb_destroy;
1158 	}
1159 
1160 	ar->hif_priv = ar_usb;
1161 	ar->hif_type = ATH6KL_HIF_TYPE_USB;
1162 	ar->hif_ops = &ath6kl_usb_ops;
1163 	ar->mbox_info.block_size = 16;
1164 	ar->bmi.max_data_size = 252;
1165 
1166 	ar_usb->ar = ar;
1167 
1168 	ret = ath6kl_core_init(ar, ATH6KL_HTC_TYPE_PIPE);
1169 	if (ret) {
1170 		ath6kl_err("Failed to init ath6kl core: %d\n", ret);
1171 		goto err_core_free;
1172 	}
1173 
1174 	return ret;
1175 
1176 err_core_free:
1177 	ath6kl_core_destroy(ar);
1178 err_usb_destroy:
1179 	ath6kl_usb_destroy(ar_usb);
1180 err_usb_put:
1181 	usb_put_dev(dev);
1182 
1183 	return ret;
1184 }
1185 
ath6kl_usb_remove(struct usb_interface * interface)1186 static void ath6kl_usb_remove(struct usb_interface *interface)
1187 {
1188 	usb_put_dev(interface_to_usbdev(interface));
1189 	ath6kl_usb_device_detached(interface);
1190 }
1191 
1192 #ifdef CONFIG_PM
1193 
ath6kl_usb_pm_suspend(struct usb_interface * interface,pm_message_t message)1194 static int ath6kl_usb_pm_suspend(struct usb_interface *interface,
1195 			      pm_message_t message)
1196 {
1197 	struct ath6kl_usb *device;
1198 	device = usb_get_intfdata(interface);
1199 
1200 	ath6kl_usb_flush_all(device);
1201 	return 0;
1202 }
1203 
ath6kl_usb_pm_resume(struct usb_interface * interface)1204 static int ath6kl_usb_pm_resume(struct usb_interface *interface)
1205 {
1206 	struct ath6kl_usb *device;
1207 	device = usb_get_intfdata(interface);
1208 
1209 	ath6kl_usb_post_recv_transfers(&device->pipes[ATH6KL_USB_PIPE_RX_DATA],
1210 				       ATH6KL_USB_RX_BUFFER_SIZE);
1211 	ath6kl_usb_post_recv_transfers(&device->pipes[ATH6KL_USB_PIPE_RX_DATA2],
1212 				       ATH6KL_USB_RX_BUFFER_SIZE);
1213 
1214 	return 0;
1215 }
1216 
1217 #else
1218 
1219 #define ath6kl_usb_pm_suspend NULL
1220 #define ath6kl_usb_pm_resume NULL
1221 
1222 #endif
1223 
1224 /* table of devices that work with this driver */
1225 static const struct usb_device_id ath6kl_usb_ids[] = {
1226 	{USB_DEVICE(0x0cf3, 0x9375)},
1227 	{USB_DEVICE(0x0cf3, 0x9374)},
1228 	{USB_DEVICE(0x04da, 0x390d)},
1229 	{ /* Terminating entry */ },
1230 };
1231 
1232 MODULE_DEVICE_TABLE(usb, ath6kl_usb_ids);
1233 
1234 static struct usb_driver ath6kl_usb_driver = {
1235 	.name = "ath6kl_usb",
1236 	.probe = ath6kl_usb_probe,
1237 	.suspend = ath6kl_usb_pm_suspend,
1238 	.resume = ath6kl_usb_pm_resume,
1239 	.disconnect = ath6kl_usb_remove,
1240 	.id_table = ath6kl_usb_ids,
1241 	.supports_autosuspend = true,
1242 	.disable_hub_initiated_lpm = 1,
1243 };
1244 
1245 module_usb_driver(ath6kl_usb_driver);
1246 
1247 MODULE_AUTHOR("Atheros Communications, Inc.");
1248 MODULE_DESCRIPTION("Driver support for Atheros AR600x USB devices");
1249 MODULE_LICENSE("Dual BSD/GPL");
1250 MODULE_FIRMWARE(AR6004_HW_1_0_FIRMWARE_FILE);
1251 MODULE_FIRMWARE(AR6004_HW_1_0_BOARD_DATA_FILE);
1252 MODULE_FIRMWARE(AR6004_HW_1_0_DEFAULT_BOARD_DATA_FILE);
1253 MODULE_FIRMWARE(AR6004_HW_1_1_FIRMWARE_FILE);
1254 MODULE_FIRMWARE(AR6004_HW_1_1_BOARD_DATA_FILE);
1255 MODULE_FIRMWARE(AR6004_HW_1_1_DEFAULT_BOARD_DATA_FILE);
1256 MODULE_FIRMWARE(AR6004_HW_1_2_FIRMWARE_FILE);
1257 MODULE_FIRMWARE(AR6004_HW_1_2_BOARD_DATA_FILE);
1258 MODULE_FIRMWARE(AR6004_HW_1_2_DEFAULT_BOARD_DATA_FILE);
1259 MODULE_FIRMWARE(AR6004_HW_1_3_FW_DIR "/" AR6004_HW_1_3_FIRMWARE_FILE);
1260 MODULE_FIRMWARE(AR6004_HW_1_3_BOARD_DATA_FILE);
1261 MODULE_FIRMWARE(AR6004_HW_1_3_DEFAULT_BOARD_DATA_FILE);
1262