xref: /openbmc/linux/drivers/net/wireless/ath/ath10k/usb.c (revision 791d3ef2)
1 /*
2  * Copyright (c) 2007-2011 Atheros Communications Inc.
3  * Copyright (c) 2011-2012,2017 Qualcomm Atheros, Inc.
4  * Copyright (c) 2016-2017 Erik Stromdahl <erik.stromdahl@gmail.com>
5  *
6  * Permission to use, copy, modify, and/or distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 
19 #include <linux/module.h>
20 #include <linux/usb.h>
21 
22 #include "debug.h"
23 #include "core.h"
24 #include "bmi.h"
25 #include "hif.h"
26 #include "htc.h"
27 #include "usb.h"
28 
29 static void ath10k_usb_post_recv_transfers(struct ath10k *ar,
30 					   struct ath10k_usb_pipe *recv_pipe);
31 
32 /* inlined helper functions */
33 
34 static inline enum ath10k_htc_ep_id
35 eid_from_htc_hdr(struct ath10k_htc_hdr *htc_hdr)
36 {
37 	return (enum ath10k_htc_ep_id)htc_hdr->eid;
38 }
39 
40 static inline bool is_trailer_only_msg(struct ath10k_htc_hdr *htc_hdr)
41 {
42 	return __le16_to_cpu(htc_hdr->len) == htc_hdr->trailer_len;
43 }
44 
45 /* pipe/urb operations */
46 static struct ath10k_urb_context *
47 ath10k_usb_alloc_urb_from_pipe(struct ath10k_usb_pipe *pipe)
48 {
49 	struct ath10k_urb_context *urb_context = NULL;
50 	unsigned long flags;
51 
52 	spin_lock_irqsave(&pipe->ar_usb->cs_lock, flags);
53 	if (!list_empty(&pipe->urb_list_head)) {
54 		urb_context = list_first_entry(&pipe->urb_list_head,
55 					       struct ath10k_urb_context, link);
56 		list_del(&urb_context->link);
57 		pipe->urb_cnt--;
58 	}
59 	spin_unlock_irqrestore(&pipe->ar_usb->cs_lock, flags);
60 
61 	return urb_context;
62 }
63 
64 static void ath10k_usb_free_urb_to_pipe(struct ath10k_usb_pipe *pipe,
65 					struct ath10k_urb_context *urb_context)
66 {
67 	unsigned long flags;
68 
69 	spin_lock_irqsave(&pipe->ar_usb->cs_lock, flags);
70 
71 	pipe->urb_cnt++;
72 	list_add(&urb_context->link, &pipe->urb_list_head);
73 
74 	spin_unlock_irqrestore(&pipe->ar_usb->cs_lock, flags);
75 }
76 
77 static void ath10k_usb_cleanup_recv_urb(struct ath10k_urb_context *urb_context)
78 {
79 	dev_kfree_skb(urb_context->skb);
80 	urb_context->skb = NULL;
81 
82 	ath10k_usb_free_urb_to_pipe(urb_context->pipe, urb_context);
83 }
84 
85 static void ath10k_usb_free_pipe_resources(struct ath10k *ar,
86 					   struct ath10k_usb_pipe *pipe)
87 {
88 	struct ath10k_urb_context *urb_context;
89 
90 	if (!pipe->ar_usb) {
91 		/* nothing allocated for this pipe */
92 		return;
93 	}
94 
95 	ath10k_dbg(ar, ATH10K_DBG_USB,
96 		   "usb free resources lpipe %d hpipe 0x%x urbs %d avail %d\n",
97 		   pipe->logical_pipe_num, pipe->usb_pipe_handle,
98 		   pipe->urb_alloc, pipe->urb_cnt);
99 
100 	if (pipe->urb_alloc != pipe->urb_cnt) {
101 		ath10k_dbg(ar, ATH10K_DBG_USB,
102 			   "usb urb leak lpipe %d hpipe 0x%x urbs %d avail %d\n",
103 			   pipe->logical_pipe_num, pipe->usb_pipe_handle,
104 			   pipe->urb_alloc, pipe->urb_cnt);
105 	}
106 
107 	for (;;) {
108 		urb_context = ath10k_usb_alloc_urb_from_pipe(pipe);
109 
110 		if (!urb_context)
111 			break;
112 
113 		kfree(urb_context);
114 	}
115 }
116 
117 static void ath10k_usb_cleanup_pipe_resources(struct ath10k *ar)
118 {
119 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
120 	int i;
121 
122 	for (i = 0; i < ATH10K_USB_PIPE_MAX; i++)
123 		ath10k_usb_free_pipe_resources(ar, &ar_usb->pipes[i]);
124 }
125 
126 /* hif usb rx/tx completion functions */
127 
128 static void ath10k_usb_recv_complete(struct urb *urb)
129 {
130 	struct ath10k_urb_context *urb_context = urb->context;
131 	struct ath10k_usb_pipe *pipe = urb_context->pipe;
132 	struct ath10k *ar = pipe->ar_usb->ar;
133 	struct sk_buff *skb;
134 	int status = 0;
135 
136 	ath10k_dbg(ar, ATH10K_DBG_USB_BULK,
137 		   "usb recv pipe %d stat %d len %d urb 0x%pK\n",
138 		   pipe->logical_pipe_num, urb->status, urb->actual_length,
139 		   urb);
140 
141 	if (urb->status != 0) {
142 		status = -EIO;
143 		switch (urb->status) {
144 		case -ECONNRESET:
145 		case -ENOENT:
146 		case -ESHUTDOWN:
147 			/* no need to spew these errors when device
148 			 * removed or urb killed due to driver shutdown
149 			 */
150 			status = -ECANCELED;
151 			break;
152 		default:
153 			ath10k_dbg(ar, ATH10K_DBG_USB_BULK,
154 				   "usb recv pipe %d ep 0x%2.2x failed: %d\n",
155 				   pipe->logical_pipe_num,
156 				   pipe->ep_address, urb->status);
157 			break;
158 		}
159 		goto cleanup_recv_urb;
160 	}
161 
162 	if (urb->actual_length == 0)
163 		goto cleanup_recv_urb;
164 
165 	skb = urb_context->skb;
166 
167 	/* we are going to pass it up */
168 	urb_context->skb = NULL;
169 	skb_put(skb, urb->actual_length);
170 
171 	/* note: queue implements a lock */
172 	skb_queue_tail(&pipe->io_comp_queue, skb);
173 	schedule_work(&pipe->io_complete_work);
174 
175 cleanup_recv_urb:
176 	ath10k_usb_cleanup_recv_urb(urb_context);
177 
178 	if (status == 0 &&
179 	    pipe->urb_cnt >= pipe->urb_cnt_thresh) {
180 		/* our free urbs are piling up, post more transfers */
181 		ath10k_usb_post_recv_transfers(ar, pipe);
182 	}
183 }
184 
185 static void ath10k_usb_transmit_complete(struct urb *urb)
186 {
187 	struct ath10k_urb_context *urb_context = urb->context;
188 	struct ath10k_usb_pipe *pipe = urb_context->pipe;
189 	struct ath10k *ar = pipe->ar_usb->ar;
190 	struct sk_buff *skb;
191 
192 	if (urb->status != 0) {
193 		ath10k_dbg(ar, ATH10K_DBG_USB_BULK,
194 			   "pipe: %d, failed:%d\n",
195 			   pipe->logical_pipe_num, urb->status);
196 	}
197 
198 	skb = urb_context->skb;
199 	urb_context->skb = NULL;
200 	ath10k_usb_free_urb_to_pipe(urb_context->pipe, urb_context);
201 
202 	/* note: queue implements a lock */
203 	skb_queue_tail(&pipe->io_comp_queue, skb);
204 	schedule_work(&pipe->io_complete_work);
205 }
206 
207 /* pipe operations */
208 static void ath10k_usb_post_recv_transfers(struct ath10k *ar,
209 					   struct ath10k_usb_pipe *recv_pipe)
210 {
211 	struct ath10k_urb_context *urb_context;
212 	struct urb *urb;
213 	int usb_status;
214 
215 	for (;;) {
216 		urb_context = ath10k_usb_alloc_urb_from_pipe(recv_pipe);
217 		if (!urb_context)
218 			break;
219 
220 		urb_context->skb = dev_alloc_skb(ATH10K_USB_RX_BUFFER_SIZE);
221 		if (!urb_context->skb)
222 			goto err;
223 
224 		urb = usb_alloc_urb(0, GFP_ATOMIC);
225 		if (!urb)
226 			goto err;
227 
228 		usb_fill_bulk_urb(urb,
229 				  recv_pipe->ar_usb->udev,
230 				  recv_pipe->usb_pipe_handle,
231 				  urb_context->skb->data,
232 				  ATH10K_USB_RX_BUFFER_SIZE,
233 				  ath10k_usb_recv_complete, urb_context);
234 
235 		ath10k_dbg(ar, ATH10K_DBG_USB_BULK,
236 			   "usb bulk recv submit %d 0x%x ep 0x%2.2x len %d buf 0x%pK\n",
237 			   recv_pipe->logical_pipe_num,
238 			   recv_pipe->usb_pipe_handle, recv_pipe->ep_address,
239 			   ATH10K_USB_RX_BUFFER_SIZE, urb_context->skb);
240 
241 		usb_anchor_urb(urb, &recv_pipe->urb_submitted);
242 		usb_status = usb_submit_urb(urb, GFP_ATOMIC);
243 
244 		if (usb_status) {
245 			ath10k_dbg(ar, ATH10K_DBG_USB_BULK,
246 				   "usb bulk recv failed: %d\n",
247 				   usb_status);
248 			usb_unanchor_urb(urb);
249 			usb_free_urb(urb);
250 			goto err;
251 		}
252 		usb_free_urb(urb);
253 	}
254 
255 	return;
256 
257 err:
258 	ath10k_usb_cleanup_recv_urb(urb_context);
259 }
260 
261 static void ath10k_usb_flush_all(struct ath10k *ar)
262 {
263 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
264 	int i;
265 
266 	for (i = 0; i < ATH10K_USB_PIPE_MAX; i++) {
267 		if (ar_usb->pipes[i].ar_usb) {
268 			usb_kill_anchored_urbs(&ar_usb->pipes[i].urb_submitted);
269 			cancel_work_sync(&ar_usb->pipes[i].io_complete_work);
270 		}
271 	}
272 }
273 
274 static void ath10k_usb_start_recv_pipes(struct ath10k *ar)
275 {
276 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
277 
278 	ar_usb->pipes[ATH10K_USB_PIPE_RX_DATA].urb_cnt_thresh = 1;
279 
280 	ath10k_usb_post_recv_transfers(ar,
281 				       &ar_usb->pipes[ATH10K_USB_PIPE_RX_DATA]);
282 }
283 
284 static void ath10k_usb_tx_complete(struct ath10k *ar, struct sk_buff *skb)
285 {
286 	struct ath10k_htc_hdr *htc_hdr;
287 	struct ath10k_htc_ep *ep;
288 
289 	htc_hdr = (struct ath10k_htc_hdr *)skb->data;
290 	ep = &ar->htc.endpoint[htc_hdr->eid];
291 	ath10k_htc_notify_tx_completion(ep, skb);
292 	/* The TX complete handler now owns the skb... */
293 }
294 
295 static void ath10k_usb_rx_complete(struct ath10k *ar, struct sk_buff *skb)
296 {
297 	struct ath10k_htc *htc = &ar->htc;
298 	struct ath10k_htc_hdr *htc_hdr;
299 	enum ath10k_htc_ep_id eid;
300 	struct ath10k_htc_ep *ep;
301 	u16 payload_len;
302 	u8 *trailer;
303 	int ret;
304 
305 	htc_hdr = (struct ath10k_htc_hdr *)skb->data;
306 	eid = eid_from_htc_hdr(htc_hdr);
307 	ep = &ar->htc.endpoint[eid];
308 
309 	if (ep->service_id == 0) {
310 		ath10k_warn(ar, "ep %d is not connected\n", eid);
311 		goto out_free_skb;
312 	}
313 
314 	payload_len = le16_to_cpu(htc_hdr->len);
315 	if (!payload_len) {
316 		ath10k_warn(ar, "zero length frame received, firmware crashed?\n");
317 		goto out_free_skb;
318 	}
319 
320 	if (payload_len < htc_hdr->trailer_len) {
321 		ath10k_warn(ar, "malformed frame received, firmware crashed?\n");
322 		goto out_free_skb;
323 	}
324 
325 	if (htc_hdr->flags & ATH10K_HTC_FLAG_TRAILER_PRESENT) {
326 		trailer = skb->data + sizeof(*htc_hdr) + payload_len -
327 			  htc_hdr->trailer_len;
328 
329 		ret = ath10k_htc_process_trailer(htc,
330 						 trailer,
331 						 htc_hdr->trailer_len,
332 						 eid,
333 						 NULL,
334 						 NULL);
335 		if (ret)
336 			goto out_free_skb;
337 
338 		if (is_trailer_only_msg(htc_hdr))
339 			goto out_free_skb;
340 
341 		/* strip off the trailer from the skb since it should not
342 		 * be passed on to upper layers
343 		 */
344 		skb_trim(skb, skb->len - htc_hdr->trailer_len);
345 	}
346 
347 	skb_pull(skb, sizeof(*htc_hdr));
348 	ep->ep_ops.ep_rx_complete(ar, skb);
349 	/* The RX complete handler now owns the skb... */
350 
351 	return;
352 
353 out_free_skb:
354 	dev_kfree_skb(skb);
355 }
356 
357 static void ath10k_usb_io_comp_work(struct work_struct *work)
358 {
359 	struct ath10k_usb_pipe *pipe = container_of(work,
360 						    struct ath10k_usb_pipe,
361 						    io_complete_work);
362 	struct ath10k *ar = pipe->ar_usb->ar;
363 	struct sk_buff *skb;
364 
365 	while ((skb = skb_dequeue(&pipe->io_comp_queue))) {
366 		if (pipe->flags & ATH10K_USB_PIPE_FLAG_TX)
367 			ath10k_usb_tx_complete(ar, skb);
368 		else
369 			ath10k_usb_rx_complete(ar, skb);
370 	}
371 }
372 
373 #define ATH10K_USB_MAX_DIAG_CMD (sizeof(struct ath10k_usb_ctrl_diag_cmd_write))
374 #define ATH10K_USB_MAX_DIAG_RESP (sizeof(struct ath10k_usb_ctrl_diag_resp_read))
375 
376 static void ath10k_usb_destroy(struct ath10k *ar)
377 {
378 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
379 
380 	ath10k_usb_flush_all(ar);
381 	ath10k_usb_cleanup_pipe_resources(ar);
382 	usb_set_intfdata(ar_usb->interface, NULL);
383 
384 	kfree(ar_usb->diag_cmd_buffer);
385 	kfree(ar_usb->diag_resp_buffer);
386 }
387 
388 static int ath10k_usb_hif_start(struct ath10k *ar)
389 {
390 	int i;
391 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
392 
393 	ath10k_usb_start_recv_pipes(ar);
394 
395 	/* set the TX resource avail threshold for each TX pipe */
396 	for (i = ATH10K_USB_PIPE_TX_CTRL;
397 	     i <= ATH10K_USB_PIPE_TX_DATA_HP; i++) {
398 		ar_usb->pipes[i].urb_cnt_thresh =
399 		    ar_usb->pipes[i].urb_alloc / 2;
400 	}
401 
402 	return 0;
403 }
404 
405 static int ath10k_usb_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
406 				struct ath10k_hif_sg_item *items, int n_items)
407 {
408 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
409 	struct ath10k_usb_pipe *pipe = &ar_usb->pipes[pipe_id];
410 	struct ath10k_urb_context *urb_context;
411 	struct sk_buff *skb;
412 	struct urb *urb;
413 	int ret, i;
414 
415 	for (i = 0; i < n_items; i++) {
416 		urb_context = ath10k_usb_alloc_urb_from_pipe(pipe);
417 		if (!urb_context) {
418 			ret = -ENOMEM;
419 			goto err;
420 		}
421 
422 		skb = items[i].transfer_context;
423 		urb_context->skb = skb;
424 
425 		urb = usb_alloc_urb(0, GFP_ATOMIC);
426 		if (!urb) {
427 			ret = -ENOMEM;
428 			goto err_free_urb_to_pipe;
429 		}
430 
431 		usb_fill_bulk_urb(urb,
432 				  ar_usb->udev,
433 				  pipe->usb_pipe_handle,
434 				  skb->data,
435 				  skb->len,
436 				  ath10k_usb_transmit_complete, urb_context);
437 
438 		if (!(skb->len % pipe->max_packet_size)) {
439 			/* hit a max packet boundary on this pipe */
440 			urb->transfer_flags |= URB_ZERO_PACKET;
441 		}
442 
443 		usb_anchor_urb(urb, &pipe->urb_submitted);
444 		ret = usb_submit_urb(urb, GFP_ATOMIC);
445 		if (ret) {
446 			ath10k_dbg(ar, ATH10K_DBG_USB_BULK,
447 				   "usb bulk transmit failed: %d\n", ret);
448 			usb_unanchor_urb(urb);
449 			ret = -EINVAL;
450 			goto err_free_urb_to_pipe;
451 		}
452 
453 		usb_free_urb(urb);
454 	}
455 
456 	return 0;
457 
458 err_free_urb_to_pipe:
459 	ath10k_usb_free_urb_to_pipe(urb_context->pipe, urb_context);
460 err:
461 	return ret;
462 }
463 
464 static void ath10k_usb_hif_stop(struct ath10k *ar)
465 {
466 	ath10k_usb_flush_all(ar);
467 }
468 
469 static u16 ath10k_usb_hif_get_free_queue_number(struct ath10k *ar, u8 pipe_id)
470 {
471 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
472 
473 	return ar_usb->pipes[pipe_id].urb_cnt;
474 }
475 
476 static int ath10k_usb_submit_ctrl_out(struct ath10k *ar,
477 				      u8 req, u16 value, u16 index, void *data,
478 				      u32 size)
479 {
480 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
481 	u8 *buf = NULL;
482 	int ret;
483 
484 	if (size > 0) {
485 		buf = kmemdup(data, size, GFP_KERNEL);
486 		if (!buf)
487 			return -ENOMEM;
488 	}
489 
490 	/* note: if successful returns number of bytes transferred */
491 	ret = usb_control_msg(ar_usb->udev,
492 			      usb_sndctrlpipe(ar_usb->udev, 0),
493 			      req,
494 			      USB_DIR_OUT | USB_TYPE_VENDOR |
495 			      USB_RECIP_DEVICE, value, index, buf,
496 			      size, 1000);
497 
498 	if (ret < 0) {
499 		ath10k_warn(ar, "Failed to submit usb control message: %d\n",
500 			    ret);
501 		kfree(buf);
502 		return ret;
503 	}
504 
505 	kfree(buf);
506 
507 	return 0;
508 }
509 
510 static int ath10k_usb_submit_ctrl_in(struct ath10k *ar,
511 				     u8 req, u16 value, u16 index, void *data,
512 				     u32 size)
513 {
514 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
515 	u8 *buf = NULL;
516 	int ret;
517 
518 	if (size > 0) {
519 		buf = kmalloc(size, GFP_KERNEL);
520 		if (!buf)
521 			return -ENOMEM;
522 	}
523 
524 	/* note: if successful returns number of bytes transferred */
525 	ret = usb_control_msg(ar_usb->udev,
526 			      usb_rcvctrlpipe(ar_usb->udev, 0),
527 			      req,
528 			      USB_DIR_IN | USB_TYPE_VENDOR |
529 			      USB_RECIP_DEVICE, value, index, buf,
530 			      size, 2 * HZ);
531 
532 	if (ret < 0) {
533 		ath10k_warn(ar, "Failed to read usb control message: %d\n",
534 			    ret);
535 		kfree(buf);
536 		return ret;
537 	}
538 
539 	memcpy((u8 *)data, buf, size);
540 
541 	kfree(buf);
542 
543 	return 0;
544 }
545 
546 static int ath10k_usb_ctrl_msg_exchange(struct ath10k *ar,
547 					u8 req_val, u8 *req_buf, u32 req_len,
548 					u8 resp_val, u8 *resp_buf,
549 					u32 *resp_len)
550 {
551 	int ret;
552 
553 	/* send command */
554 	ret = ath10k_usb_submit_ctrl_out(ar, req_val, 0, 0,
555 					 req_buf, req_len);
556 	if (ret)
557 		goto err;
558 
559 	/* get response */
560 	if (resp_buf) {
561 		ret = ath10k_usb_submit_ctrl_in(ar, resp_val, 0, 0,
562 						resp_buf, *resp_len);
563 		if (ret)
564 			goto err;
565 	}
566 
567 	return 0;
568 err:
569 	return ret;
570 }
571 
572 static int ath10k_usb_hif_diag_read(struct ath10k *ar, u32 address, void *buf,
573 				    size_t buf_len)
574 {
575 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
576 	struct ath10k_usb_ctrl_diag_cmd_read *cmd;
577 	u32 resp_len;
578 	int ret;
579 
580 	if (buf_len < sizeof(struct ath10k_usb_ctrl_diag_resp_read))
581 		return -EINVAL;
582 
583 	cmd = (struct ath10k_usb_ctrl_diag_cmd_read *)ar_usb->diag_cmd_buffer;
584 	memset(cmd, 0, sizeof(*cmd));
585 	cmd->cmd = ATH10K_USB_CTRL_DIAG_CC_READ;
586 	cmd->address = cpu_to_le32(address);
587 	resp_len = sizeof(struct ath10k_usb_ctrl_diag_resp_read);
588 
589 	ret = ath10k_usb_ctrl_msg_exchange(ar,
590 					   ATH10K_USB_CONTROL_REQ_DIAG_CMD,
591 					   (u8 *)cmd,
592 					   sizeof(*cmd),
593 					   ATH10K_USB_CONTROL_REQ_DIAG_RESP,
594 					   ar_usb->diag_resp_buffer, &resp_len);
595 	if (ret)
596 		return ret;
597 
598 	if (resp_len != sizeof(struct ath10k_usb_ctrl_diag_resp_read))
599 		return -EMSGSIZE;
600 
601 	memcpy(buf, ar_usb->diag_resp_buffer,
602 	       sizeof(struct ath10k_usb_ctrl_diag_resp_read));
603 
604 	return 0;
605 }
606 
607 static int ath10k_usb_hif_diag_write(struct ath10k *ar, u32 address,
608 				     const void *data, int nbytes)
609 {
610 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
611 	struct ath10k_usb_ctrl_diag_cmd_write *cmd;
612 	int ret;
613 
614 	if (nbytes != sizeof(cmd->value))
615 		return -EINVAL;
616 
617 	cmd = (struct ath10k_usb_ctrl_diag_cmd_write *)ar_usb->diag_cmd_buffer;
618 	memset(cmd, 0, sizeof(*cmd));
619 	cmd->cmd = cpu_to_le32(ATH10K_USB_CTRL_DIAG_CC_WRITE);
620 	cmd->address = cpu_to_le32(address);
621 	memcpy(&cmd->value, data, nbytes);
622 
623 	ret = ath10k_usb_ctrl_msg_exchange(ar,
624 					   ATH10K_USB_CONTROL_REQ_DIAG_CMD,
625 					   (u8 *)cmd,
626 					   sizeof(*cmd),
627 					   0, NULL, NULL);
628 	if (ret)
629 		return ret;
630 
631 	return 0;
632 }
633 
634 static int ath10k_usb_bmi_exchange_msg(struct ath10k *ar,
635 				       void *req, u32 req_len,
636 				       void *resp, u32 *resp_len)
637 {
638 	int ret;
639 
640 	if (req) {
641 		ret = ath10k_usb_submit_ctrl_out(ar,
642 						 ATH10K_USB_CONTROL_REQ_SEND_BMI_CMD,
643 						 0, 0, req, req_len);
644 		if (ret) {
645 			ath10k_warn(ar,
646 				    "unable to send the bmi data to the device: %d\n",
647 				    ret);
648 			return ret;
649 		}
650 	}
651 
652 	if (resp) {
653 		ret = ath10k_usb_submit_ctrl_in(ar,
654 						ATH10K_USB_CONTROL_REQ_RECV_BMI_RESP,
655 						0, 0, resp, *resp_len);
656 		if (ret) {
657 			ath10k_warn(ar,
658 				    "Unable to read the bmi data from the device: %d\n",
659 				    ret);
660 			return ret;
661 		}
662 	}
663 
664 	return 0;
665 }
666 
667 static void ath10k_usb_hif_get_default_pipe(struct ath10k *ar,
668 					    u8 *ul_pipe, u8 *dl_pipe)
669 {
670 	*ul_pipe = ATH10K_USB_PIPE_TX_CTRL;
671 	*dl_pipe = ATH10K_USB_PIPE_RX_CTRL;
672 }
673 
674 static int ath10k_usb_hif_map_service_to_pipe(struct ath10k *ar, u16 svc_id,
675 					      u8 *ul_pipe, u8 *dl_pipe)
676 {
677 	switch (svc_id) {
678 	case ATH10K_HTC_SVC_ID_RSVD_CTRL:
679 	case ATH10K_HTC_SVC_ID_WMI_CONTROL:
680 		*ul_pipe = ATH10K_USB_PIPE_TX_CTRL;
681 		/* due to large control packets, shift to data pipe */
682 		*dl_pipe = ATH10K_USB_PIPE_RX_DATA;
683 		break;
684 	case ATH10K_HTC_SVC_ID_HTT_DATA_MSG:
685 		*ul_pipe = ATH10K_USB_PIPE_TX_DATA_LP;
686 		/* Disable rxdata2 directly, it will be enabled
687 		 * if FW enable rxdata2
688 		 */
689 		*dl_pipe = ATH10K_USB_PIPE_RX_DATA;
690 		break;
691 	default:
692 		return -EPERM;
693 	}
694 
695 	return 0;
696 }
697 
698 /* This op is currently only used by htc_wait_target if the HTC ready
699  * message times out. It is not applicable for USB since there is nothing
700  * we can do if the HTC ready message does not arrive in time.
701  * TODO: Make this op non mandatory by introducing a NULL check in the
702  * hif op wrapper.
703  */
704 static void ath10k_usb_hif_send_complete_check(struct ath10k *ar,
705 					       u8 pipe, int force)
706 {
707 }
708 
709 static int ath10k_usb_hif_power_up(struct ath10k *ar)
710 {
711 	return 0;
712 }
713 
714 static void ath10k_usb_hif_power_down(struct ath10k *ar)
715 {
716 	ath10k_usb_flush_all(ar);
717 }
718 
719 #ifdef CONFIG_PM
720 
721 static int ath10k_usb_hif_suspend(struct ath10k *ar)
722 {
723 	return -EOPNOTSUPP;
724 }
725 
726 static int ath10k_usb_hif_resume(struct ath10k *ar)
727 {
728 	return -EOPNOTSUPP;
729 }
730 #endif
731 
732 static const struct ath10k_hif_ops ath10k_usb_hif_ops = {
733 	.tx_sg			= ath10k_usb_hif_tx_sg,
734 	.diag_read		= ath10k_usb_hif_diag_read,
735 	.diag_write		= ath10k_usb_hif_diag_write,
736 	.exchange_bmi_msg	= ath10k_usb_bmi_exchange_msg,
737 	.start			= ath10k_usb_hif_start,
738 	.stop			= ath10k_usb_hif_stop,
739 	.map_service_to_pipe	= ath10k_usb_hif_map_service_to_pipe,
740 	.get_default_pipe	= ath10k_usb_hif_get_default_pipe,
741 	.send_complete_check	= ath10k_usb_hif_send_complete_check,
742 	.get_free_queue_number	= ath10k_usb_hif_get_free_queue_number,
743 	.power_up		= ath10k_usb_hif_power_up,
744 	.power_down		= ath10k_usb_hif_power_down,
745 #ifdef CONFIG_PM
746 	.suspend		= ath10k_usb_hif_suspend,
747 	.resume			= ath10k_usb_hif_resume,
748 #endif
749 };
750 
751 static u8 ath10k_usb_get_logical_pipe_num(u8 ep_address, int *urb_count)
752 {
753 	u8 pipe_num = ATH10K_USB_PIPE_INVALID;
754 
755 	switch (ep_address) {
756 	case ATH10K_USB_EP_ADDR_APP_CTRL_IN:
757 		pipe_num = ATH10K_USB_PIPE_RX_CTRL;
758 		*urb_count = RX_URB_COUNT;
759 		break;
760 	case ATH10K_USB_EP_ADDR_APP_DATA_IN:
761 		pipe_num = ATH10K_USB_PIPE_RX_DATA;
762 		*urb_count = RX_URB_COUNT;
763 		break;
764 	case ATH10K_USB_EP_ADDR_APP_INT_IN:
765 		pipe_num = ATH10K_USB_PIPE_RX_INT;
766 		*urb_count = RX_URB_COUNT;
767 		break;
768 	case ATH10K_USB_EP_ADDR_APP_DATA2_IN:
769 		pipe_num = ATH10K_USB_PIPE_RX_DATA2;
770 		*urb_count = RX_URB_COUNT;
771 		break;
772 	case ATH10K_USB_EP_ADDR_APP_CTRL_OUT:
773 		pipe_num = ATH10K_USB_PIPE_TX_CTRL;
774 		*urb_count = TX_URB_COUNT;
775 		break;
776 	case ATH10K_USB_EP_ADDR_APP_DATA_LP_OUT:
777 		pipe_num = ATH10K_USB_PIPE_TX_DATA_LP;
778 		*urb_count = TX_URB_COUNT;
779 		break;
780 	case ATH10K_USB_EP_ADDR_APP_DATA_MP_OUT:
781 		pipe_num = ATH10K_USB_PIPE_TX_DATA_MP;
782 		*urb_count = TX_URB_COUNT;
783 		break;
784 	case ATH10K_USB_EP_ADDR_APP_DATA_HP_OUT:
785 		pipe_num = ATH10K_USB_PIPE_TX_DATA_HP;
786 		*urb_count = TX_URB_COUNT;
787 		break;
788 	default:
789 		/* note: there may be endpoints not currently used */
790 		break;
791 	}
792 
793 	return pipe_num;
794 }
795 
796 static int ath10k_usb_alloc_pipe_resources(struct ath10k *ar,
797 					   struct ath10k_usb_pipe *pipe,
798 					   int urb_cnt)
799 {
800 	struct ath10k_urb_context *urb_context;
801 	int i;
802 
803 	INIT_LIST_HEAD(&pipe->urb_list_head);
804 	init_usb_anchor(&pipe->urb_submitted);
805 
806 	for (i = 0; i < urb_cnt; i++) {
807 		urb_context = kzalloc(sizeof(*urb_context), GFP_KERNEL);
808 		if (!urb_context)
809 			return -ENOMEM;
810 
811 		urb_context->pipe = pipe;
812 
813 		/* we are only allocate the urb contexts here, the actual URB
814 		 * is allocated from the kernel as needed to do a transaction
815 		 */
816 		pipe->urb_alloc++;
817 		ath10k_usb_free_urb_to_pipe(pipe, urb_context);
818 	}
819 
820 	ath10k_dbg(ar, ATH10K_DBG_USB,
821 		   "usb alloc resources lpipe %d hpipe 0x%x urbs %d\n",
822 		   pipe->logical_pipe_num, pipe->usb_pipe_handle,
823 		   pipe->urb_alloc);
824 
825 	return 0;
826 }
827 
828 static int ath10k_usb_setup_pipe_resources(struct ath10k *ar,
829 					   struct usb_interface *interface)
830 {
831 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
832 	struct usb_host_interface *iface_desc = interface->cur_altsetting;
833 	struct usb_endpoint_descriptor *endpoint;
834 	struct ath10k_usb_pipe *pipe;
835 	int ret, i, urbcount;
836 	u8 pipe_num;
837 
838 	ath10k_dbg(ar, ATH10K_DBG_USB, "usb setting up pipes using interface\n");
839 
840 	/* walk decriptors and setup pipes */
841 	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
842 		endpoint = &iface_desc->endpoint[i].desc;
843 
844 		if (ATH10K_USB_IS_BULK_EP(endpoint->bmAttributes)) {
845 			ath10k_dbg(ar, ATH10K_DBG_USB,
846 				   "usb %s bulk ep 0x%2.2x maxpktsz %d\n",
847 				   ATH10K_USB_IS_DIR_IN
848 				   (endpoint->bEndpointAddress) ?
849 				   "rx" : "tx", endpoint->bEndpointAddress,
850 				   le16_to_cpu(endpoint->wMaxPacketSize));
851 		} else if (ATH10K_USB_IS_INT_EP(endpoint->bmAttributes)) {
852 			ath10k_dbg(ar, ATH10K_DBG_USB,
853 				   "usb %s int ep 0x%2.2x maxpktsz %d interval %d\n",
854 				   ATH10K_USB_IS_DIR_IN
855 				   (endpoint->bEndpointAddress) ?
856 				   "rx" : "tx", endpoint->bEndpointAddress,
857 				   le16_to_cpu(endpoint->wMaxPacketSize),
858 				   endpoint->bInterval);
859 		} else if (ATH10K_USB_IS_ISOC_EP(endpoint->bmAttributes)) {
860 			/* TODO for ISO */
861 			ath10k_dbg(ar, ATH10K_DBG_USB,
862 				   "usb %s isoc ep 0x%2.2x maxpktsz %d interval %d\n",
863 				   ATH10K_USB_IS_DIR_IN
864 				   (endpoint->bEndpointAddress) ?
865 				   "rx" : "tx", endpoint->bEndpointAddress,
866 				   le16_to_cpu(endpoint->wMaxPacketSize),
867 				   endpoint->bInterval);
868 		}
869 		urbcount = 0;
870 
871 		pipe_num =
872 		    ath10k_usb_get_logical_pipe_num(endpoint->bEndpointAddress,
873 						    &urbcount);
874 		if (pipe_num == ATH10K_USB_PIPE_INVALID)
875 			continue;
876 
877 		pipe = &ar_usb->pipes[pipe_num];
878 		if (pipe->ar_usb)
879 			/* hmmm..pipe was already setup */
880 			continue;
881 
882 		pipe->ar_usb = ar_usb;
883 		pipe->logical_pipe_num = pipe_num;
884 		pipe->ep_address = endpoint->bEndpointAddress;
885 		pipe->max_packet_size = le16_to_cpu(endpoint->wMaxPacketSize);
886 
887 		if (ATH10K_USB_IS_BULK_EP(endpoint->bmAttributes)) {
888 			if (ATH10K_USB_IS_DIR_IN(pipe->ep_address)) {
889 				pipe->usb_pipe_handle =
890 				    usb_rcvbulkpipe(ar_usb->udev,
891 						    pipe->ep_address);
892 			} else {
893 				pipe->usb_pipe_handle =
894 				    usb_sndbulkpipe(ar_usb->udev,
895 						    pipe->ep_address);
896 			}
897 		} else if (ATH10K_USB_IS_INT_EP(endpoint->bmAttributes)) {
898 			if (ATH10K_USB_IS_DIR_IN(pipe->ep_address)) {
899 				pipe->usb_pipe_handle =
900 				    usb_rcvintpipe(ar_usb->udev,
901 						   pipe->ep_address);
902 			} else {
903 				pipe->usb_pipe_handle =
904 				    usb_sndintpipe(ar_usb->udev,
905 						   pipe->ep_address);
906 			}
907 		} else if (ATH10K_USB_IS_ISOC_EP(endpoint->bmAttributes)) {
908 			/* TODO for ISO */
909 			if (ATH10K_USB_IS_DIR_IN(pipe->ep_address)) {
910 				pipe->usb_pipe_handle =
911 				    usb_rcvisocpipe(ar_usb->udev,
912 						    pipe->ep_address);
913 			} else {
914 				pipe->usb_pipe_handle =
915 				    usb_sndisocpipe(ar_usb->udev,
916 						    pipe->ep_address);
917 			}
918 		}
919 
920 		pipe->ep_desc = endpoint;
921 
922 		if (!ATH10K_USB_IS_DIR_IN(pipe->ep_address))
923 			pipe->flags |= ATH10K_USB_PIPE_FLAG_TX;
924 
925 		ret = ath10k_usb_alloc_pipe_resources(ar, pipe, urbcount);
926 		if (ret)
927 			return ret;
928 	}
929 
930 	return 0;
931 }
932 
933 static int ath10k_usb_create(struct ath10k *ar,
934 			     struct usb_interface *interface)
935 {
936 	struct ath10k_usb *ar_usb = ath10k_usb_priv(ar);
937 	struct usb_device *dev = interface_to_usbdev(interface);
938 	struct ath10k_usb_pipe *pipe;
939 	int ret, i;
940 
941 	usb_set_intfdata(interface, ar_usb);
942 	spin_lock_init(&ar_usb->cs_lock);
943 	ar_usb->udev = dev;
944 	ar_usb->interface = interface;
945 
946 	for (i = 0; i < ATH10K_USB_PIPE_MAX; i++) {
947 		pipe = &ar_usb->pipes[i];
948 		INIT_WORK(&pipe->io_complete_work,
949 			  ath10k_usb_io_comp_work);
950 		skb_queue_head_init(&pipe->io_comp_queue);
951 	}
952 
953 	ar_usb->diag_cmd_buffer = kzalloc(ATH10K_USB_MAX_DIAG_CMD, GFP_KERNEL);
954 	if (!ar_usb->diag_cmd_buffer) {
955 		ret = -ENOMEM;
956 		goto err;
957 	}
958 
959 	ar_usb->diag_resp_buffer = kzalloc(ATH10K_USB_MAX_DIAG_RESP,
960 					   GFP_KERNEL);
961 	if (!ar_usb->diag_resp_buffer) {
962 		ret = -ENOMEM;
963 		goto err;
964 	}
965 
966 	ret = ath10k_usb_setup_pipe_resources(ar, interface);
967 	if (ret)
968 		goto err;
969 
970 	return 0;
971 
972 err:
973 	ath10k_usb_destroy(ar);
974 	return ret;
975 }
976 
977 /* ath10k usb driver registered functions */
978 static int ath10k_usb_probe(struct usb_interface *interface,
979 			    const struct usb_device_id *id)
980 {
981 	struct ath10k *ar;
982 	struct ath10k_usb *ar_usb;
983 	struct usb_device *dev = interface_to_usbdev(interface);
984 	int ret, vendor_id, product_id;
985 	enum ath10k_hw_rev hw_rev;
986 	u32 chip_id;
987 
988 	/* Assumption: All USB based chipsets (so far) are QCA9377 based.
989 	 * If there will be newer chipsets that does not use the hw reg
990 	 * setup as defined in qca6174_regs and qca6174_values, this
991 	 * assumption is no longer valid and hw_rev must be setup differently
992 	 * depending on chipset.
993 	 */
994 	hw_rev = ATH10K_HW_QCA9377;
995 
996 	ar = ath10k_core_create(sizeof(*ar_usb), &dev->dev, ATH10K_BUS_USB,
997 				hw_rev, &ath10k_usb_hif_ops);
998 	if (!ar) {
999 		dev_err(&dev->dev, "failed to allocate core\n");
1000 		return -ENOMEM;
1001 	}
1002 
1003 	usb_get_dev(dev);
1004 	vendor_id = le16_to_cpu(dev->descriptor.idVendor);
1005 	product_id = le16_to_cpu(dev->descriptor.idProduct);
1006 
1007 	ath10k_dbg(ar, ATH10K_DBG_BOOT,
1008 		   "usb new func vendor 0x%04x product 0x%04x\n",
1009 		   vendor_id, product_id);
1010 
1011 	ar_usb = ath10k_usb_priv(ar);
1012 	ret = ath10k_usb_create(ar, interface);
1013 	ar_usb->ar = ar;
1014 
1015 	ar->dev_id = product_id;
1016 	ar->id.vendor = vendor_id;
1017 	ar->id.device = product_id;
1018 
1019 	/* TODO: don't know yet how to get chip_id with USB */
1020 	chip_id = 0;
1021 	ret = ath10k_core_register(ar, chip_id);
1022 	if (ret) {
1023 		ath10k_warn(ar, "failed to register driver core: %d\n", ret);
1024 		goto err;
1025 	}
1026 
1027 	/* TODO: remove this once USB support is fully implemented */
1028 	ath10k_warn(ar, "WARNING: ath10k USB support is incomplete, don't expect anything to work!\n");
1029 
1030 	return 0;
1031 
1032 err:
1033 	ath10k_core_destroy(ar);
1034 
1035 	usb_put_dev(dev);
1036 
1037 	return ret;
1038 }
1039 
1040 static void ath10k_usb_remove(struct usb_interface *interface)
1041 {
1042 	struct ath10k_usb *ar_usb;
1043 
1044 	ar_usb = usb_get_intfdata(interface);
1045 	if (!ar_usb)
1046 		return;
1047 
1048 	ath10k_core_unregister(ar_usb->ar);
1049 	ath10k_usb_destroy(ar_usb->ar);
1050 	usb_put_dev(interface_to_usbdev(interface));
1051 	ath10k_core_destroy(ar_usb->ar);
1052 }
1053 
1054 #ifdef CONFIG_PM
1055 
1056 static int ath10k_usb_pm_suspend(struct usb_interface *interface,
1057 				 pm_message_t message)
1058 {
1059 	struct ath10k_usb *ar_usb = usb_get_intfdata(interface);
1060 
1061 	ath10k_usb_flush_all(ar_usb->ar);
1062 	return 0;
1063 }
1064 
1065 static int ath10k_usb_pm_resume(struct usb_interface *interface)
1066 {
1067 	struct ath10k_usb *ar_usb = usb_get_intfdata(interface);
1068 	struct ath10k *ar = ar_usb->ar;
1069 
1070 	ath10k_usb_post_recv_transfers(ar,
1071 				       &ar_usb->pipes[ATH10K_USB_PIPE_RX_DATA]);
1072 
1073 	return 0;
1074 }
1075 
1076 #else
1077 
1078 #define ath10k_usb_pm_suspend NULL
1079 #define ath10k_usb_pm_resume NULL
1080 
1081 #endif
1082 
1083 /* table of devices that work with this driver */
1084 static struct usb_device_id ath10k_usb_ids[] = {
1085 	{USB_DEVICE(0x13b1, 0x0042)}, /* Linksys WUSB6100M */
1086 	{ /* Terminating entry */ },
1087 };
1088 
1089 MODULE_DEVICE_TABLE(usb, ath10k_usb_ids);
1090 
1091 static struct usb_driver ath10k_usb_driver = {
1092 	.name = "ath10k_usb",
1093 	.probe = ath10k_usb_probe,
1094 	.suspend = ath10k_usb_pm_suspend,
1095 	.resume = ath10k_usb_pm_resume,
1096 	.disconnect = ath10k_usb_remove,
1097 	.id_table = ath10k_usb_ids,
1098 	.supports_autosuspend = true,
1099 	.disable_hub_initiated_lpm = 1,
1100 };
1101 
1102 module_usb_driver(ath10k_usb_driver);
1103 
1104 MODULE_AUTHOR("Atheros Communications, Inc.");
1105 MODULE_DESCRIPTION("Driver support for Qualcomm Atheros 802.11ac WLAN USB devices");
1106 MODULE_LICENSE("Dual BSD/GPL");
1107