1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/usb.h>
29#include <linux/bug.h>
30
31#include "rt2x00.h"
32#include "rt2x00usb.h"
33
34
35
36
37int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev,
38 const u8 request, const u8 requesttype,
39 const u16 offset, const u16 value,
40 void *buffer, const u16 buffer_length,
41 const int timeout)
42{
43 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
44 int status;
45 unsigned int i;
46 unsigned int pipe =
47 (requesttype == USB_VENDOR_REQUEST_IN) ?
48 usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0);
49
50 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
51 return -ENODEV;
52
53 for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
54 status = usb_control_msg(usb_dev, pipe, request, requesttype,
55 value, offset, buffer, buffer_length,
56 timeout);
57 if (status >= 0)
58 return 0;
59
60
61
62
63
64
65 else if (status == -ENODEV) {
66 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
67 break;
68 }
69 }
70
71 ERROR(rt2x00dev,
72 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
73 request, offset, status);
74
75 return status;
76}
77EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request);
78
79int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev,
80 const u8 request, const u8 requesttype,
81 const u16 offset, void *buffer,
82 const u16 buffer_length, const int timeout)
83{
84 int status;
85
86 BUG_ON(!mutex_is_locked(&rt2x00dev->csr_mutex));
87
88
89
90
91 if (unlikely(!rt2x00dev->csr.cache || buffer_length > CSR_CACHE_SIZE)) {
92 ERROR(rt2x00dev, "CSR cache not available.\n");
93 return -ENOMEM;
94 }
95
96 if (requesttype == USB_VENDOR_REQUEST_OUT)
97 memcpy(rt2x00dev->csr.cache, buffer, buffer_length);
98
99 status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype,
100 offset, 0, rt2x00dev->csr.cache,
101 buffer_length, timeout);
102
103 if (!status && requesttype == USB_VENDOR_REQUEST_IN)
104 memcpy(buffer, rt2x00dev->csr.cache, buffer_length);
105
106 return status;
107}
108EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock);
109
110int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev,
111 const u8 request, const u8 requesttype,
112 const u16 offset, void *buffer,
113 const u16 buffer_length, const int timeout)
114{
115 int status;
116
117 mutex_lock(&rt2x00dev->csr_mutex);
118
119 status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
120 requesttype, offset, buffer,
121 buffer_length, timeout);
122
123 mutex_unlock(&rt2x00dev->csr_mutex);
124
125 return status;
126}
127EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
128
129int rt2x00usb_vendor_request_large_buff(struct rt2x00_dev *rt2x00dev,
130 const u8 request, const u8 requesttype,
131 const u16 offset, const void *buffer,
132 const u16 buffer_length,
133 const int timeout)
134{
135 int status = 0;
136 unsigned char *tb;
137 u16 off, len, bsize;
138
139 mutex_lock(&rt2x00dev->csr_mutex);
140
141 tb = (char *)buffer;
142 off = offset;
143 len = buffer_length;
144 while (len && !status) {
145 bsize = min_t(u16, CSR_CACHE_SIZE, len);
146 status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
147 requesttype, off, tb,
148 bsize, timeout);
149
150 tb += bsize;
151 len -= bsize;
152 off += bsize;
153 }
154
155 mutex_unlock(&rt2x00dev->csr_mutex);
156
157 return status;
158}
159EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_large_buff);
160
161int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
162 const unsigned int offset,
163 struct rt2x00_field32 field,
164 u32 *reg)
165{
166 unsigned int i;
167
168 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
169 return -ENODEV;
170
171 for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
172 rt2x00usb_register_read_lock(rt2x00dev, offset, reg);
173 if (!rt2x00_get_field32(*reg, field))
174 return 1;
175 udelay(REGISTER_BUSY_DELAY);
176 }
177
178 ERROR(rt2x00dev, "Indirect register access failed: "
179 "offset=0x%.08x, value=0x%.08x\n", offset, *reg);
180 *reg = ~0;
181
182 return 0;
183}
184EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read);
185
186
187
188
189static void rt2x00usb_interrupt_txdone(struct urb *urb)
190{
191 struct queue_entry *entry = (struct queue_entry *)urb->context;
192 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
193 struct txdone_entry_desc txdesc;
194
195 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
196 !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
197 return;
198
199
200
201
202
203
204
205
206
207
208 txdesc.flags = 0;
209 if (!urb->status)
210 __set_bit(TXDONE_UNKNOWN, &txdesc.flags);
211 else
212 __set_bit(TXDONE_FAILURE, &txdesc.flags);
213 txdesc.retry = 0;
214
215 rt2x00lib_txdone(entry, &txdesc);
216}
217
218int rt2x00usb_write_tx_data(struct queue_entry *entry)
219{
220 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
221 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
222 struct queue_entry_priv_usb *entry_priv = entry->priv_data;
223 struct skb_frame_desc *skbdesc;
224 u32 length;
225
226
227
228
229 skb_push(entry->skb, entry->queue->desc_size);
230 memset(entry->skb->data, 0, entry->queue->desc_size);
231
232
233
234
235 skbdesc = get_skb_frame_desc(entry->skb);
236 skbdesc->desc = entry->skb->data;
237 skbdesc->desc_len = entry->queue->desc_size;
238
239
240
241
242
243
244 length = rt2x00dev->ops->lib->get_tx_data_len(entry);
245
246 usb_fill_bulk_urb(entry_priv->urb, usb_dev,
247 usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint),
248 entry->skb->data, length,
249 rt2x00usb_interrupt_txdone, entry);
250
251
252
253
254
255 skb_pull(entry->skb, entry->queue->desc_size);
256
257 return 0;
258}
259EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data);
260
261static inline void rt2x00usb_kick_tx_entry(struct queue_entry *entry)
262{
263 struct queue_entry_priv_usb *entry_priv = entry->priv_data;
264
265 if (test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags))
266 usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
267}
268
269void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
270 const enum data_queue_qid qid)
271{
272 struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
273 unsigned long irqflags;
274 unsigned int index;
275 unsigned int index_done;
276 unsigned int i;
277
278
279
280
281
282
283
284 spin_lock_irqsave(&queue->lock, irqflags);
285 index = queue->index[Q_INDEX];
286 index_done = queue->index[Q_INDEX_DONE];
287 spin_unlock_irqrestore(&queue->lock, irqflags);
288
289
290
291
292
293 if (index_done < index) {
294 for (i = index_done; i < index; i++)
295 rt2x00usb_kick_tx_entry(&queue->entries[i]);
296 } else {
297 for (i = index_done; i < queue->limit; i++)
298 rt2x00usb_kick_tx_entry(&queue->entries[i]);
299
300 for (i = 0; i < index; i++)
301 rt2x00usb_kick_tx_entry(&queue->entries[i]);
302 }
303}
304EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue);
305
306void rt2x00usb_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
307 const enum data_queue_qid qid)
308{
309 struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
310 struct queue_entry_priv_usb *entry_priv;
311 struct queue_entry_priv_usb_bcn *bcn_priv;
312 unsigned int i;
313 bool kill_guard;
314
315
316
317
318
319 kill_guard =
320 (qid == QID_BEACON) &&
321 (test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags));
322
323
324
325
326 for (i = 0; i < queue->limit; i++) {
327 entry_priv = queue->entries[i].priv_data;
328 usb_kill_urb(entry_priv->urb);
329
330
331
332
333 if (kill_guard) {
334 bcn_priv = queue->entries[i].priv_data;
335 usb_kill_urb(bcn_priv->guardian_urb);
336 }
337 }
338}
339EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue);
340
341
342
343
344static void rt2x00usb_interrupt_rxdone(struct urb *urb)
345{
346 struct queue_entry *entry = (struct queue_entry *)urb->context;
347 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
348 struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
349 u8 rxd[32];
350
351 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
352 !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
353 return;
354
355
356
357
358
359
360 if (urb->actual_length < entry->queue->desc_size || urb->status) {
361 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
362 usb_submit_urb(urb, GFP_ATOMIC);
363 return;
364 }
365
366
367
368
369 skbdesc->desc = rxd;
370 skbdesc->desc_len = entry->queue->desc_size;
371
372
373
374
375 rt2x00lib_rxdone(rt2x00dev, entry);
376}
377
378
379
380
381void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
382{
383 rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
384 REGISTER_TIMEOUT);
385
386
387
388
389
390 rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev, QID_RX);
391}
392EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
393
394
395
396
397void rt2x00usb_clear_entry(struct queue_entry *entry)
398{
399 struct usb_device *usb_dev =
400 to_usb_device_intf(entry->queue->rt2x00dev->dev);
401 struct queue_entry_priv_usb *entry_priv = entry->priv_data;
402 int pipe;
403
404 if (entry->queue->qid == QID_RX) {
405 pipe = usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint);
406 usb_fill_bulk_urb(entry_priv->urb, usb_dev, pipe,
407 entry->skb->data, entry->skb->len,
408 rt2x00usb_interrupt_rxdone, entry);
409
410 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
411 usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
412 } else {
413 entry->flags = 0;
414 }
415}
416EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry);
417
418static void rt2x00usb_assign_endpoint(struct data_queue *queue,
419 struct usb_endpoint_descriptor *ep_desc)
420{
421 struct usb_device *usb_dev = to_usb_device_intf(queue->rt2x00dev->dev);
422 int pipe;
423
424 queue->usb_endpoint = usb_endpoint_num(ep_desc);
425
426 if (queue->qid == QID_RX) {
427 pipe = usb_rcvbulkpipe(usb_dev, queue->usb_endpoint);
428 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 0);
429 } else {
430 pipe = usb_sndbulkpipe(usb_dev, queue->usb_endpoint);
431 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 1);
432 }
433
434 if (!queue->usb_maxpacket)
435 queue->usb_maxpacket = 1;
436}
437
438static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
439{
440 struct usb_interface *intf = to_usb_interface(rt2x00dev->dev);
441 struct usb_host_interface *intf_desc = intf->cur_altsetting;
442 struct usb_endpoint_descriptor *ep_desc;
443 struct data_queue *queue = rt2x00dev->tx;
444 struct usb_endpoint_descriptor *tx_ep_desc = NULL;
445 unsigned int i;
446
447
448
449
450
451
452
453 for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
454 ep_desc = &intf_desc->endpoint[i].desc;
455
456 if (usb_endpoint_is_bulk_in(ep_desc)) {
457 rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc);
458 } else if (usb_endpoint_is_bulk_out(ep_desc) &&
459 (queue != queue_end(rt2x00dev))) {
460 rt2x00usb_assign_endpoint(queue, ep_desc);
461 queue = queue_next(queue);
462
463 tx_ep_desc = ep_desc;
464 }
465 }
466
467
468
469
470 if (!rt2x00dev->rx->usb_endpoint || !rt2x00dev->tx->usb_endpoint) {
471 ERROR(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n");
472 return -EPIPE;
473 }
474
475
476
477
478
479
480 txall_queue_for_each(rt2x00dev, queue) {
481 if (!queue->usb_endpoint)
482 rt2x00usb_assign_endpoint(queue, tx_ep_desc);
483 }
484
485 return 0;
486}
487
488static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
489 struct data_queue *queue)
490{
491 struct queue_entry_priv_usb *entry_priv;
492 struct queue_entry_priv_usb_bcn *bcn_priv;
493 unsigned int i;
494
495 for (i = 0; i < queue->limit; i++) {
496 entry_priv = queue->entries[i].priv_data;
497 entry_priv->urb = usb_alloc_urb(0, GFP_KERNEL);
498 if (!entry_priv->urb)
499 return -ENOMEM;
500 }
501
502
503
504
505
506
507 if (rt2x00dev->bcn != queue ||
508 !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
509 return 0;
510
511 for (i = 0; i < queue->limit; i++) {
512 bcn_priv = queue->entries[i].priv_data;
513 bcn_priv->guardian_urb = usb_alloc_urb(0, GFP_KERNEL);
514 if (!bcn_priv->guardian_urb)
515 return -ENOMEM;
516 }
517
518 return 0;
519}
520
521static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
522 struct data_queue *queue)
523{
524 struct queue_entry_priv_usb *entry_priv;
525 struct queue_entry_priv_usb_bcn *bcn_priv;
526 unsigned int i;
527
528 if (!queue->entries)
529 return;
530
531 for (i = 0; i < queue->limit; i++) {
532 entry_priv = queue->entries[i].priv_data;
533 usb_kill_urb(entry_priv->urb);
534 usb_free_urb(entry_priv->urb);
535 }
536
537
538
539
540
541
542 if (rt2x00dev->bcn != queue ||
543 !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
544 return;
545
546 for (i = 0; i < queue->limit; i++) {
547 bcn_priv = queue->entries[i].priv_data;
548 usb_kill_urb(bcn_priv->guardian_urb);
549 usb_free_urb(bcn_priv->guardian_urb);
550 }
551}
552
553int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
554{
555 struct data_queue *queue;
556 int status;
557
558
559
560
561 status = rt2x00usb_find_endpoints(rt2x00dev);
562 if (status)
563 goto exit;
564
565
566
567
568 queue_for_each(rt2x00dev, queue) {
569 status = rt2x00usb_alloc_urb(rt2x00dev, queue);
570 if (status)
571 goto exit;
572 }
573
574 return 0;
575
576exit:
577 rt2x00usb_uninitialize(rt2x00dev);
578
579 return status;
580}
581EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
582
583void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
584{
585 struct data_queue *queue;
586
587 queue_for_each(rt2x00dev, queue)
588 rt2x00usb_free_urb(rt2x00dev, queue);
589}
590EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
591
592
593
594
595static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev)
596{
597 kfree(rt2x00dev->rf);
598 rt2x00dev->rf = NULL;
599
600 kfree(rt2x00dev->eeprom);
601 rt2x00dev->eeprom = NULL;
602
603 kfree(rt2x00dev->csr.cache);
604 rt2x00dev->csr.cache = NULL;
605}
606
607static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
608{
609 rt2x00dev->csr.cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL);
610 if (!rt2x00dev->csr.cache)
611 goto exit;
612
613 rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
614 if (!rt2x00dev->eeprom)
615 goto exit;
616
617 rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
618 if (!rt2x00dev->rf)
619 goto exit;
620
621 return 0;
622
623exit:
624 ERROR_PROBE("Failed to allocate registers.\n");
625
626 rt2x00usb_free_reg(rt2x00dev);
627
628 return -ENOMEM;
629}
630
631int rt2x00usb_probe(struct usb_interface *usb_intf,
632 const struct usb_device_id *id)
633{
634 struct usb_device *usb_dev = interface_to_usbdev(usb_intf);
635 struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info;
636 struct ieee80211_hw *hw;
637 struct rt2x00_dev *rt2x00dev;
638 int retval;
639
640 usb_dev = usb_get_dev(usb_dev);
641
642 hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
643 if (!hw) {
644 ERROR_PROBE("Failed to allocate hardware.\n");
645 retval = -ENOMEM;
646 goto exit_put_device;
647 }
648
649 usb_set_intfdata(usb_intf, hw);
650
651 rt2x00dev = hw->priv;
652 rt2x00dev->dev = &usb_intf->dev;
653 rt2x00dev->ops = ops;
654 rt2x00dev->hw = hw;
655
656 retval = rt2x00usb_alloc_reg(rt2x00dev);
657 if (retval)
658 goto exit_free_device;
659
660 retval = rt2x00lib_probe_dev(rt2x00dev);
661 if (retval)
662 goto exit_free_reg;
663
664 return 0;
665
666exit_free_reg:
667 rt2x00usb_free_reg(rt2x00dev);
668
669exit_free_device:
670 ieee80211_free_hw(hw);
671
672exit_put_device:
673 usb_put_dev(usb_dev);
674
675 usb_set_intfdata(usb_intf, NULL);
676
677 return retval;
678}
679EXPORT_SYMBOL_GPL(rt2x00usb_probe);
680
681void rt2x00usb_disconnect(struct usb_interface *usb_intf)
682{
683 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
684 struct rt2x00_dev *rt2x00dev = hw->priv;
685
686
687
688
689 rt2x00lib_remove_dev(rt2x00dev);
690 rt2x00usb_free_reg(rt2x00dev);
691 ieee80211_free_hw(hw);
692
693
694
695
696 usb_set_intfdata(usb_intf, NULL);
697 usb_put_dev(interface_to_usbdev(usb_intf));
698}
699EXPORT_SYMBOL_GPL(rt2x00usb_disconnect);
700
701#ifdef CONFIG_PM
702int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
703{
704 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
705 struct rt2x00_dev *rt2x00dev = hw->priv;
706 int retval;
707
708 retval = rt2x00lib_suspend(rt2x00dev, state);
709 if (retval)
710 return retval;
711
712
713
714
715 usb_put_dev(interface_to_usbdev(usb_intf));
716
717 return 0;
718}
719EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
720
721int rt2x00usb_resume(struct usb_interface *usb_intf)
722{
723 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
724 struct rt2x00_dev *rt2x00dev = hw->priv;
725
726 usb_get_dev(interface_to_usbdev(usb_intf));
727
728 return rt2x00lib_resume(rt2x00dev);
729}
730EXPORT_SYMBOL_GPL(rt2x00usb_resume);
731#endif
732
733
734
735
736MODULE_AUTHOR(DRV_PROJECT);
737MODULE_VERSION(DRV_VERSION);
738MODULE_DESCRIPTION("rt2x00 usb library");
739MODULE_LICENSE("GPL");
740