1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
4 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
5 <http://rt2x00.serialmonkey.com>
6
7 */
8
9 /*
10 Module: rt2x00usb
11 Abstract: rt2x00 generic usb device routines.
12 */
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/usb.h>
18 #include <linux/bug.h>
19
20 #include "rt2x00.h"
21 #include "rt2x00usb.h"
22
rt2x00usb_check_usb_error(struct rt2x00_dev * rt2x00dev,int status)23 static bool rt2x00usb_check_usb_error(struct rt2x00_dev *rt2x00dev, int status)
24 {
25 if (status == -ENODEV || status == -ENOENT)
26 return true;
27
28 if (!test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
29 return false;
30
31 if (status == -EPROTO || status == -ETIMEDOUT)
32 rt2x00dev->num_proto_errs++;
33 else
34 rt2x00dev->num_proto_errs = 0;
35
36 if (rt2x00dev->num_proto_errs > 3)
37 return true;
38
39 return false;
40 }
41
42 /*
43 * Interfacing with the HW.
44 */
rt2x00usb_vendor_request(struct rt2x00_dev * rt2x00dev,const u8 request,const u8 requesttype,const u16 offset,const u16 value,void * buffer,const u16 buffer_length,const int timeout)45 int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev,
46 const u8 request, const u8 requesttype,
47 const u16 offset, const u16 value,
48 void *buffer, const u16 buffer_length,
49 const int timeout)
50 {
51 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
52 int status;
53 unsigned int pipe =
54 (requesttype == USB_VENDOR_REQUEST_IN) ?
55 usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0);
56 unsigned long expire = jiffies + msecs_to_jiffies(timeout);
57
58 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
59 return -ENODEV;
60
61 do {
62 status = usb_control_msg(usb_dev, pipe, request, requesttype,
63 value, offset, buffer, buffer_length,
64 timeout / 2);
65 if (status >= 0)
66 return 0;
67
68 if (rt2x00usb_check_usb_error(rt2x00dev, status)) {
69 /* Device has disappeared. */
70 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
71 break;
72 }
73 } while (time_before(jiffies, expire));
74
75 rt2x00_err(rt2x00dev,
76 "Vendor Request 0x%02x failed for offset 0x%04x with error %d\n",
77 request, offset, status);
78
79 return status;
80 }
81 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request);
82
rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev * rt2x00dev,const u8 request,const u8 requesttype,const u16 offset,void * buffer,const u16 buffer_length,const int timeout)83 int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev,
84 const u8 request, const u8 requesttype,
85 const u16 offset, void *buffer,
86 const u16 buffer_length, const int timeout)
87 {
88 int status;
89
90 BUG_ON(!mutex_is_locked(&rt2x00dev->csr_mutex));
91
92 /*
93 * Check for Cache availability.
94 */
95 if (unlikely(!rt2x00dev->csr.cache || buffer_length > CSR_CACHE_SIZE)) {
96 rt2x00_err(rt2x00dev, "CSR cache not available\n");
97 return -ENOMEM;
98 }
99
100 if (requesttype == USB_VENDOR_REQUEST_OUT)
101 memcpy(rt2x00dev->csr.cache, buffer, buffer_length);
102
103 status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype,
104 offset, 0, rt2x00dev->csr.cache,
105 buffer_length, timeout);
106
107 if (!status && requesttype == USB_VENDOR_REQUEST_IN)
108 memcpy(buffer, rt2x00dev->csr.cache, buffer_length);
109
110 return status;
111 }
112 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock);
113
rt2x00usb_vendor_request_buff(struct rt2x00_dev * rt2x00dev,const u8 request,const u8 requesttype,const u16 offset,void * buffer,const u16 buffer_length)114 int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev,
115 const u8 request, const u8 requesttype,
116 const u16 offset, void *buffer,
117 const u16 buffer_length)
118 {
119 int status = 0;
120 u8 *tb;
121 u16 off, len, bsize;
122
123 mutex_lock(&rt2x00dev->csr_mutex);
124
125 tb = (u8 *)buffer;
126 off = offset;
127 len = buffer_length;
128 while (len && !status) {
129 bsize = min_t(u16, CSR_CACHE_SIZE, len);
130 status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
131 requesttype, off, tb,
132 bsize, REGISTER_TIMEOUT);
133
134 tb += bsize;
135 len -= bsize;
136 off += bsize;
137 }
138
139 mutex_unlock(&rt2x00dev->csr_mutex);
140
141 return status;
142 }
143 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
144
rt2x00usb_regbusy_read(struct rt2x00_dev * rt2x00dev,const unsigned int offset,const struct rt2x00_field32 field,u32 * reg)145 int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
146 const unsigned int offset,
147 const struct rt2x00_field32 field,
148 u32 *reg)
149 {
150 unsigned int i;
151
152 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
153 return -ENODEV;
154
155 for (i = 0; i < REGISTER_USB_BUSY_COUNT; i++) {
156 *reg = rt2x00usb_register_read_lock(rt2x00dev, offset);
157 if (!rt2x00_get_field32(*reg, field))
158 return 1;
159 udelay(REGISTER_BUSY_DELAY);
160 }
161
162 rt2x00_err(rt2x00dev, "Indirect register access failed: offset=0x%.08x, value=0x%.08x\n",
163 offset, *reg);
164 *reg = ~0;
165
166 return 0;
167 }
168 EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read);
169
170
171 struct rt2x00_async_read_data {
172 __le32 reg;
173 struct usb_ctrlrequest cr;
174 struct rt2x00_dev *rt2x00dev;
175 bool (*callback)(struct rt2x00_dev *, int, u32);
176 };
177
rt2x00usb_register_read_async_cb(struct urb * urb)178 static void rt2x00usb_register_read_async_cb(struct urb *urb)
179 {
180 struct rt2x00_async_read_data *rd = urb->context;
181 if (rd->callback(rd->rt2x00dev, urb->status, le32_to_cpu(rd->reg))) {
182 usb_anchor_urb(urb, rd->rt2x00dev->anchor);
183 if (usb_submit_urb(urb, GFP_ATOMIC) < 0) {
184 usb_unanchor_urb(urb);
185 kfree(rd);
186 }
187 } else
188 kfree(rd);
189 }
190
rt2x00usb_register_read_async(struct rt2x00_dev * rt2x00dev,const unsigned int offset,bool (* callback)(struct rt2x00_dev *,int,u32))191 void rt2x00usb_register_read_async(struct rt2x00_dev *rt2x00dev,
192 const unsigned int offset,
193 bool (*callback)(struct rt2x00_dev*, int, u32))
194 {
195 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
196 struct urb *urb;
197 struct rt2x00_async_read_data *rd;
198
199 rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
200 if (!rd)
201 return;
202
203 urb = usb_alloc_urb(0, GFP_ATOMIC);
204 if (!urb) {
205 kfree(rd);
206 return;
207 }
208
209 rd->rt2x00dev = rt2x00dev;
210 rd->callback = callback;
211 rd->cr.bRequestType = USB_VENDOR_REQUEST_IN;
212 rd->cr.bRequest = USB_MULTI_READ;
213 rd->cr.wValue = 0;
214 rd->cr.wIndex = cpu_to_le16(offset);
215 rd->cr.wLength = cpu_to_le16(sizeof(u32));
216
217 usb_fill_control_urb(urb, usb_dev, usb_rcvctrlpipe(usb_dev, 0),
218 (u8 *)(&rd->cr), &rd->reg, sizeof(rd->reg),
219 rt2x00usb_register_read_async_cb, rd);
220 usb_anchor_urb(urb, rt2x00dev->anchor);
221 if (usb_submit_urb(urb, GFP_ATOMIC) < 0) {
222 usb_unanchor_urb(urb);
223 kfree(rd);
224 }
225 usb_free_urb(urb);
226 }
227 EXPORT_SYMBOL_GPL(rt2x00usb_register_read_async);
228
229 /*
230 * TX data handlers.
231 */
rt2x00usb_work_txdone_entry(struct queue_entry * entry)232 static void rt2x00usb_work_txdone_entry(struct queue_entry *entry)
233 {
234 /*
235 * If the transfer to hardware succeeded, it does not mean the
236 * frame was send out correctly. It only means the frame
237 * was successfully pushed to the hardware, we have no
238 * way to determine the transmission status right now.
239 * (Only indirectly by looking at the failed TX counters
240 * in the register).
241 */
242 if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
243 rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE);
244 else
245 rt2x00lib_txdone_noinfo(entry, TXDONE_UNKNOWN);
246 }
247
rt2x00usb_work_txdone(struct work_struct * work)248 static void rt2x00usb_work_txdone(struct work_struct *work)
249 {
250 struct rt2x00_dev *rt2x00dev =
251 container_of(work, struct rt2x00_dev, txdone_work);
252 struct data_queue *queue;
253 struct queue_entry *entry;
254
255 tx_queue_for_each(rt2x00dev, queue) {
256 while (!rt2x00queue_empty(queue)) {
257 entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
258
259 if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
260 !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
261 break;
262
263 rt2x00usb_work_txdone_entry(entry);
264 }
265 }
266 }
267
rt2x00usb_interrupt_txdone(struct urb * urb)268 static void rt2x00usb_interrupt_txdone(struct urb *urb)
269 {
270 struct queue_entry *entry = (struct queue_entry *)urb->context;
271 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
272
273 if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
274 return;
275 /*
276 * Check if the frame was correctly uploaded
277 */
278 if (urb->status)
279 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
280 /*
281 * Report the frame as DMA done
282 */
283 rt2x00lib_dmadone(entry);
284
285 if (rt2x00dev->ops->lib->tx_dma_done)
286 rt2x00dev->ops->lib->tx_dma_done(entry);
287 /*
288 * Schedule the delayed work for reading the TX status
289 * from the device.
290 */
291 if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TXSTATUS_FIFO) ||
292 !kfifo_is_empty(&rt2x00dev->txstatus_fifo))
293 queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work);
294 }
295
rt2x00usb_kick_tx_entry(struct queue_entry * entry,void * data)296 static bool rt2x00usb_kick_tx_entry(struct queue_entry *entry, void *data)
297 {
298 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
299 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
300 struct queue_entry_priv_usb *entry_priv = entry->priv_data;
301 u32 length;
302 int status;
303
304 if (!test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags) ||
305 test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
306 return false;
307
308 /*
309 * USB devices require certain padding at the end of each frame
310 * and urb. Those paddings are not included in skbs. Pass entry
311 * to the driver to determine what the overall length should be.
312 */
313 length = rt2x00dev->ops->lib->get_tx_data_len(entry);
314
315 status = skb_padto(entry->skb, length);
316 if (unlikely(status)) {
317 /* TODO: report something more appropriate than IO_FAILED. */
318 rt2x00_warn(rt2x00dev, "TX SKB padding error, out of memory\n");
319 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
320 rt2x00lib_dmadone(entry);
321
322 return false;
323 }
324
325 usb_fill_bulk_urb(entry_priv->urb, usb_dev,
326 usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint),
327 entry->skb->data, length,
328 rt2x00usb_interrupt_txdone, entry);
329
330 status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
331 if (status) {
332 if (rt2x00usb_check_usb_error(rt2x00dev, status))
333 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
334 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
335 rt2x00lib_dmadone(entry);
336 }
337
338 return false;
339 }
340
341 /*
342 * RX data handlers.
343 */
rt2x00usb_work_rxdone(struct work_struct * work)344 static void rt2x00usb_work_rxdone(struct work_struct *work)
345 {
346 struct rt2x00_dev *rt2x00dev =
347 container_of(work, struct rt2x00_dev, rxdone_work);
348 struct queue_entry *entry;
349 struct skb_frame_desc *skbdesc;
350 u8 rxd[32];
351
352 while (!rt2x00queue_empty(rt2x00dev->rx)) {
353 entry = rt2x00queue_get_entry(rt2x00dev->rx, Q_INDEX_DONE);
354
355 if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
356 break;
357
358 /*
359 * Fill in desc fields of the skb descriptor
360 */
361 skbdesc = get_skb_frame_desc(entry->skb);
362 skbdesc->desc = rxd;
363 skbdesc->desc_len = entry->queue->desc_size;
364
365 /*
366 * Send the frame to rt2x00lib for further processing.
367 */
368 rt2x00lib_rxdone(entry, GFP_KERNEL);
369 }
370 }
371
rt2x00usb_interrupt_rxdone(struct urb * urb)372 static void rt2x00usb_interrupt_rxdone(struct urb *urb)
373 {
374 struct queue_entry *entry = (struct queue_entry *)urb->context;
375 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
376
377 if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
378 return;
379
380 /*
381 * Check if the received data is simply too small
382 * to be actually valid, or if the urb is signaling
383 * a problem.
384 */
385 if (urb->actual_length < entry->queue->desc_size || urb->status)
386 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
387
388 /*
389 * Report the frame as DMA done
390 */
391 rt2x00lib_dmadone(entry);
392
393 /*
394 * Schedule the delayed work for processing RX data
395 */
396 queue_work(rt2x00dev->workqueue, &rt2x00dev->rxdone_work);
397 }
398
rt2x00usb_kick_rx_entry(struct queue_entry * entry,void * data)399 static bool rt2x00usb_kick_rx_entry(struct queue_entry *entry, void *data)
400 {
401 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
402 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
403 struct queue_entry_priv_usb *entry_priv = entry->priv_data;
404 int status;
405
406 if (test_and_set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
407 return false;
408
409 rt2x00lib_dmastart(entry);
410
411 usb_fill_bulk_urb(entry_priv->urb, usb_dev,
412 usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint),
413 entry->skb->data, entry->skb->len,
414 rt2x00usb_interrupt_rxdone, entry);
415
416 status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
417 if (status) {
418 if (rt2x00usb_check_usb_error(rt2x00dev, status))
419 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
420 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
421 rt2x00lib_dmadone(entry);
422 }
423
424 return false;
425 }
426
rt2x00usb_kick_queue(struct data_queue * queue)427 void rt2x00usb_kick_queue(struct data_queue *queue)
428 {
429 switch (queue->qid) {
430 case QID_AC_VO:
431 case QID_AC_VI:
432 case QID_AC_BE:
433 case QID_AC_BK:
434 if (!rt2x00queue_empty(queue))
435 rt2x00queue_for_each_entry(queue,
436 Q_INDEX_DONE,
437 Q_INDEX,
438 NULL,
439 rt2x00usb_kick_tx_entry);
440 break;
441 case QID_RX:
442 if (!rt2x00queue_full(queue))
443 rt2x00queue_for_each_entry(queue,
444 Q_INDEX,
445 Q_INDEX_DONE,
446 NULL,
447 rt2x00usb_kick_rx_entry);
448 break;
449 default:
450 break;
451 }
452 }
453 EXPORT_SYMBOL_GPL(rt2x00usb_kick_queue);
454
rt2x00usb_flush_entry(struct queue_entry * entry,void * data)455 static bool rt2x00usb_flush_entry(struct queue_entry *entry, void *data)
456 {
457 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
458 struct queue_entry_priv_usb *entry_priv = entry->priv_data;
459 struct queue_entry_priv_usb_bcn *bcn_priv = entry->priv_data;
460
461 if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
462 return false;
463
464 usb_kill_urb(entry_priv->urb);
465
466 /*
467 * Kill guardian urb (if required by driver).
468 */
469 if ((entry->queue->qid == QID_BEACON) &&
470 (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_BEACON_GUARD)))
471 usb_kill_urb(bcn_priv->guardian_urb);
472
473 return false;
474 }
475
rt2x00usb_flush_queue(struct data_queue * queue,bool drop)476 void rt2x00usb_flush_queue(struct data_queue *queue, bool drop)
477 {
478 struct work_struct *completion;
479 unsigned int i;
480
481 if (drop)
482 rt2x00queue_for_each_entry(queue, Q_INDEX_DONE, Q_INDEX, NULL,
483 rt2x00usb_flush_entry);
484
485 /*
486 * Obtain the queue completion handler
487 */
488 switch (queue->qid) {
489 case QID_AC_VO:
490 case QID_AC_VI:
491 case QID_AC_BE:
492 case QID_AC_BK:
493 completion = &queue->rt2x00dev->txdone_work;
494 break;
495 case QID_RX:
496 completion = &queue->rt2x00dev->rxdone_work;
497 break;
498 default:
499 return;
500 }
501
502 for (i = 0; i < 10; i++) {
503 /*
504 * Check if the driver is already done, otherwise we
505 * have to sleep a little while to give the driver/hw
506 * the oppurtunity to complete interrupt process itself.
507 */
508 if (rt2x00queue_empty(queue))
509 break;
510
511 /*
512 * Schedule the completion handler manually, when this
513 * worker function runs, it should cleanup the queue.
514 */
515 queue_work(queue->rt2x00dev->workqueue, completion);
516
517 /*
518 * Wait for a little while to give the driver
519 * the oppurtunity to recover itself.
520 */
521 msleep(50);
522 }
523 }
524 EXPORT_SYMBOL_GPL(rt2x00usb_flush_queue);
525
rt2x00usb_watchdog_tx_dma(struct data_queue * queue)526 static void rt2x00usb_watchdog_tx_dma(struct data_queue *queue)
527 {
528 rt2x00_warn(queue->rt2x00dev, "TX queue %d DMA timed out, invoke forced reset\n",
529 queue->qid);
530
531 rt2x00queue_stop_queue(queue);
532 rt2x00queue_flush_queue(queue, true);
533 rt2x00queue_start_queue(queue);
534 }
535
rt2x00usb_dma_timeout(struct data_queue * queue)536 static int rt2x00usb_dma_timeout(struct data_queue *queue)
537 {
538 struct queue_entry *entry;
539
540 entry = rt2x00queue_get_entry(queue, Q_INDEX_DMA_DONE);
541 return rt2x00queue_dma_timeout(entry);
542 }
543
rt2x00usb_watchdog(struct rt2x00_dev * rt2x00dev)544 void rt2x00usb_watchdog(struct rt2x00_dev *rt2x00dev)
545 {
546 struct data_queue *queue;
547
548 tx_queue_for_each(rt2x00dev, queue) {
549 if (!rt2x00queue_empty(queue)) {
550 if (rt2x00usb_dma_timeout(queue))
551 rt2x00usb_watchdog_tx_dma(queue);
552 }
553 }
554 }
555 EXPORT_SYMBOL_GPL(rt2x00usb_watchdog);
556
557 /*
558 * Radio handlers
559 */
rt2x00usb_disable_radio(struct rt2x00_dev * rt2x00dev)560 void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
561 {
562 rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
563 REGISTER_TIMEOUT);
564 }
565 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
566
567 /*
568 * Device initialization handlers.
569 */
rt2x00usb_clear_entry(struct queue_entry * entry)570 void rt2x00usb_clear_entry(struct queue_entry *entry)
571 {
572 entry->flags = 0;
573
574 if (entry->queue->qid == QID_RX)
575 rt2x00usb_kick_rx_entry(entry, NULL);
576 }
577 EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry);
578
rt2x00usb_assign_endpoint(struct data_queue * queue,struct usb_endpoint_descriptor * ep_desc)579 static void rt2x00usb_assign_endpoint(struct data_queue *queue,
580 struct usb_endpoint_descriptor *ep_desc)
581 {
582 struct usb_device *usb_dev = to_usb_device_intf(queue->rt2x00dev->dev);
583 int pipe;
584
585 queue->usb_endpoint = usb_endpoint_num(ep_desc);
586
587 if (queue->qid == QID_RX) {
588 pipe = usb_rcvbulkpipe(usb_dev, queue->usb_endpoint);
589 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe);
590 } else {
591 pipe = usb_sndbulkpipe(usb_dev, queue->usb_endpoint);
592 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe);
593 }
594
595 if (!queue->usb_maxpacket)
596 queue->usb_maxpacket = 1;
597 }
598
rt2x00usb_find_endpoints(struct rt2x00_dev * rt2x00dev)599 static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
600 {
601 struct usb_interface *intf = to_usb_interface(rt2x00dev->dev);
602 struct usb_host_interface *intf_desc = intf->cur_altsetting;
603 struct usb_endpoint_descriptor *ep_desc;
604 struct data_queue *queue = rt2x00dev->tx;
605 struct usb_endpoint_descriptor *tx_ep_desc = NULL;
606 unsigned int i;
607
608 /*
609 * Walk through all available endpoints to search for "bulk in"
610 * and "bulk out" endpoints. When we find such endpoints collect
611 * the information we need from the descriptor and assign it
612 * to the queue.
613 */
614 for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
615 ep_desc = &intf_desc->endpoint[i].desc;
616
617 if (usb_endpoint_is_bulk_in(ep_desc)) {
618 rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc);
619 } else if (usb_endpoint_is_bulk_out(ep_desc) &&
620 (queue != queue_end(rt2x00dev))) {
621 rt2x00usb_assign_endpoint(queue, ep_desc);
622 queue = queue_next(queue);
623
624 tx_ep_desc = ep_desc;
625 }
626 }
627
628 /*
629 * At least 1 endpoint for RX and 1 endpoint for TX must be available.
630 */
631 if (!rt2x00dev->rx->usb_endpoint || !rt2x00dev->tx->usb_endpoint) {
632 rt2x00_err(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n");
633 return -EPIPE;
634 }
635
636 /*
637 * It might be possible not all queues have a dedicated endpoint.
638 * Loop through all TX queues and copy the endpoint information
639 * which we have gathered from already assigned endpoints.
640 */
641 txall_queue_for_each(rt2x00dev, queue) {
642 if (!queue->usb_endpoint)
643 rt2x00usb_assign_endpoint(queue, tx_ep_desc);
644 }
645
646 return 0;
647 }
648
rt2x00usb_alloc_entries(struct data_queue * queue)649 static int rt2x00usb_alloc_entries(struct data_queue *queue)
650 {
651 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
652 struct queue_entry_priv_usb *entry_priv;
653 struct queue_entry_priv_usb_bcn *bcn_priv;
654 unsigned int i;
655
656 for (i = 0; i < queue->limit; i++) {
657 entry_priv = queue->entries[i].priv_data;
658 entry_priv->urb = usb_alloc_urb(0, GFP_KERNEL);
659 if (!entry_priv->urb)
660 return -ENOMEM;
661 }
662
663 /*
664 * If this is not the beacon queue or
665 * no guardian byte was required for the beacon,
666 * then we are done.
667 */
668 if (queue->qid != QID_BEACON ||
669 !rt2x00_has_cap_flag(rt2x00dev, REQUIRE_BEACON_GUARD))
670 return 0;
671
672 for (i = 0; i < queue->limit; i++) {
673 bcn_priv = queue->entries[i].priv_data;
674 bcn_priv->guardian_urb = usb_alloc_urb(0, GFP_KERNEL);
675 if (!bcn_priv->guardian_urb)
676 return -ENOMEM;
677 }
678
679 return 0;
680 }
681
rt2x00usb_free_entries(struct data_queue * queue)682 static void rt2x00usb_free_entries(struct data_queue *queue)
683 {
684 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
685 struct queue_entry_priv_usb *entry_priv;
686 struct queue_entry_priv_usb_bcn *bcn_priv;
687 unsigned int i;
688
689 if (!queue->entries)
690 return;
691
692 for (i = 0; i < queue->limit; i++) {
693 entry_priv = queue->entries[i].priv_data;
694 usb_kill_urb(entry_priv->urb);
695 usb_free_urb(entry_priv->urb);
696 }
697
698 /*
699 * If this is not the beacon queue or
700 * no guardian byte was required for the beacon,
701 * then we are done.
702 */
703 if (queue->qid != QID_BEACON ||
704 !rt2x00_has_cap_flag(rt2x00dev, REQUIRE_BEACON_GUARD))
705 return;
706
707 for (i = 0; i < queue->limit; i++) {
708 bcn_priv = queue->entries[i].priv_data;
709 usb_kill_urb(bcn_priv->guardian_urb);
710 usb_free_urb(bcn_priv->guardian_urb);
711 }
712 }
713
rt2x00usb_initialize(struct rt2x00_dev * rt2x00dev)714 int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
715 {
716 struct data_queue *queue;
717 int status;
718
719 /*
720 * Find endpoints for each queue
721 */
722 status = rt2x00usb_find_endpoints(rt2x00dev);
723 if (status)
724 goto exit;
725
726 /*
727 * Allocate DMA
728 */
729 queue_for_each(rt2x00dev, queue) {
730 status = rt2x00usb_alloc_entries(queue);
731 if (status)
732 goto exit;
733 }
734
735 return 0;
736
737 exit:
738 rt2x00usb_uninitialize(rt2x00dev);
739
740 return status;
741 }
742 EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
743
rt2x00usb_uninitialize(struct rt2x00_dev * rt2x00dev)744 void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
745 {
746 struct data_queue *queue;
747
748 usb_kill_anchored_urbs(rt2x00dev->anchor);
749 hrtimer_cancel(&rt2x00dev->txstatus_timer);
750 cancel_work_sync(&rt2x00dev->rxdone_work);
751 cancel_work_sync(&rt2x00dev->txdone_work);
752
753 queue_for_each(rt2x00dev, queue)
754 rt2x00usb_free_entries(queue);
755 }
756 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
757
758 /*
759 * USB driver handlers.
760 */
rt2x00usb_free_reg(struct rt2x00_dev * rt2x00dev)761 static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev)
762 {
763 kfree(rt2x00dev->rf);
764 rt2x00dev->rf = NULL;
765
766 kfree(rt2x00dev->eeprom);
767 rt2x00dev->eeprom = NULL;
768
769 kfree(rt2x00dev->csr.cache);
770 rt2x00dev->csr.cache = NULL;
771 }
772
rt2x00usb_alloc_reg(struct rt2x00_dev * rt2x00dev)773 static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
774 {
775 rt2x00dev->csr.cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL);
776 if (!rt2x00dev->csr.cache)
777 goto exit;
778
779 rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
780 if (!rt2x00dev->eeprom)
781 goto exit;
782
783 rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
784 if (!rt2x00dev->rf)
785 goto exit;
786
787 return 0;
788
789 exit:
790 rt2x00_probe_err("Failed to allocate registers\n");
791
792 rt2x00usb_free_reg(rt2x00dev);
793
794 return -ENOMEM;
795 }
796
rt2x00usb_probe(struct usb_interface * usb_intf,const struct rt2x00_ops * ops)797 int rt2x00usb_probe(struct usb_interface *usb_intf,
798 const struct rt2x00_ops *ops)
799 {
800 struct usb_device *usb_dev = interface_to_usbdev(usb_intf);
801 struct ieee80211_hw *hw;
802 struct rt2x00_dev *rt2x00dev;
803 int retval;
804
805 usb_dev = usb_get_dev(usb_dev);
806 usb_reset_device(usb_dev);
807
808 hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
809 if (!hw) {
810 rt2x00_probe_err("Failed to allocate hardware\n");
811 retval = -ENOMEM;
812 goto exit_put_device;
813 }
814
815 usb_set_intfdata(usb_intf, hw);
816
817 rt2x00dev = hw->priv;
818 rt2x00dev->dev = &usb_intf->dev;
819 rt2x00dev->ops = ops;
820 rt2x00dev->hw = hw;
821
822 rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_USB);
823
824 INIT_WORK(&rt2x00dev->rxdone_work, rt2x00usb_work_rxdone);
825 INIT_WORK(&rt2x00dev->txdone_work, rt2x00usb_work_txdone);
826 hrtimer_init(&rt2x00dev->txstatus_timer, CLOCK_MONOTONIC,
827 HRTIMER_MODE_REL);
828
829 retval = rt2x00usb_alloc_reg(rt2x00dev);
830 if (retval)
831 goto exit_free_device;
832
833 rt2x00dev->anchor = devm_kmalloc(&usb_dev->dev,
834 sizeof(struct usb_anchor),
835 GFP_KERNEL);
836 if (!rt2x00dev->anchor) {
837 retval = -ENOMEM;
838 goto exit_free_reg;
839 }
840 init_usb_anchor(rt2x00dev->anchor);
841
842 retval = rt2x00lib_probe_dev(rt2x00dev);
843 if (retval)
844 goto exit_free_anchor;
845
846 return 0;
847
848 exit_free_anchor:
849 usb_kill_anchored_urbs(rt2x00dev->anchor);
850
851 exit_free_reg:
852 rt2x00usb_free_reg(rt2x00dev);
853
854 exit_free_device:
855 ieee80211_free_hw(hw);
856
857 exit_put_device:
858 usb_put_dev(usb_dev);
859
860 usb_set_intfdata(usb_intf, NULL);
861
862 return retval;
863 }
864 EXPORT_SYMBOL_GPL(rt2x00usb_probe);
865
rt2x00usb_disconnect(struct usb_interface * usb_intf)866 void rt2x00usb_disconnect(struct usb_interface *usb_intf)
867 {
868 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
869 struct rt2x00_dev *rt2x00dev = hw->priv;
870
871 /*
872 * Free all allocated data.
873 */
874 rt2x00lib_remove_dev(rt2x00dev);
875 rt2x00usb_free_reg(rt2x00dev);
876 ieee80211_free_hw(hw);
877
878 /*
879 * Free the USB device data.
880 */
881 usb_set_intfdata(usb_intf, NULL);
882 usb_put_dev(interface_to_usbdev(usb_intf));
883 }
884 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect);
885
886 #ifdef CONFIG_PM
rt2x00usb_suspend(struct usb_interface * usb_intf,pm_message_t state)887 int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
888 {
889 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
890 struct rt2x00_dev *rt2x00dev = hw->priv;
891
892 return rt2x00lib_suspend(rt2x00dev);
893 }
894 EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
895
rt2x00usb_resume(struct usb_interface * usb_intf)896 int rt2x00usb_resume(struct usb_interface *usb_intf)
897 {
898 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
899 struct rt2x00_dev *rt2x00dev = hw->priv;
900
901 return rt2x00lib_resume(rt2x00dev);
902 }
903 EXPORT_SYMBOL_GPL(rt2x00usb_resume);
904 #endif /* CONFIG_PM */
905
906 /*
907 * rt2x00usb module information.
908 */
909 MODULE_AUTHOR(DRV_PROJECT);
910 MODULE_VERSION(DRV_VERSION);
911 MODULE_DESCRIPTION("rt2x00 usb library");
912 MODULE_LICENSE("GPL");
913