2 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
3 <http://rt2x00.serialmonkey.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the
17 Free Software Foundation, Inc.,
18 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 Abstract: rt2x00 generic usb device routines.
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/slab.h>
29 #include <linux/usb.h>
30 #include <linux/bug.h>
33 #include "rt2x00usb.h"
36 * Interfacing with the HW.
38 int rt2x00usb_vendor_request(struct rt2x00_dev
*rt2x00dev
,
39 const u8 request
, const u8 requesttype
,
40 const u16 offset
, const u16 value
,
41 void *buffer
, const u16 buffer_length
,
44 struct usb_device
*usb_dev
= to_usb_device_intf(rt2x00dev
->dev
);
48 (requesttype
== USB_VENDOR_REQUEST_IN
) ?
49 usb_rcvctrlpipe(usb_dev
, 0) : usb_sndctrlpipe(usb_dev
, 0);
51 if (!test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
54 for (i
= 0; i
< REGISTER_BUSY_COUNT
; i
++) {
55 status
= usb_control_msg(usb_dev
, pipe
, request
, requesttype
,
56 value
, offset
, buffer
, buffer_length
,
63 * -ENODEV: Device has disappeared, no point continuing.
64 * All other errors: Try again.
66 else if (status
== -ENODEV
) {
67 clear_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
);
73 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
74 request
, offset
, status
);
78 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request
);
80 int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev
*rt2x00dev
,
81 const u8 request
, const u8 requesttype
,
82 const u16 offset
, void *buffer
,
83 const u16 buffer_length
, const int timeout
)
87 BUG_ON(!mutex_is_locked(&rt2x00dev
->csr_mutex
));
90 * Check for Cache availability.
92 if (unlikely(!rt2x00dev
->csr
.cache
|| buffer_length
> CSR_CACHE_SIZE
)) {
93 ERROR(rt2x00dev
, "CSR cache not available.\n");
97 if (requesttype
== USB_VENDOR_REQUEST_OUT
)
98 memcpy(rt2x00dev
->csr
.cache
, buffer
, buffer_length
);
100 status
= rt2x00usb_vendor_request(rt2x00dev
, request
, requesttype
,
101 offset
, 0, rt2x00dev
->csr
.cache
,
102 buffer_length
, timeout
);
104 if (!status
&& requesttype
== USB_VENDOR_REQUEST_IN
)
105 memcpy(buffer
, rt2x00dev
->csr
.cache
, buffer_length
);
109 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock
);
111 int rt2x00usb_vendor_request_buff(struct rt2x00_dev
*rt2x00dev
,
112 const u8 request
, const u8 requesttype
,
113 const u16 offset
, void *buffer
,
114 const u16 buffer_length
, const int timeout
)
120 mutex_lock(&rt2x00dev
->csr_mutex
);
125 while (len
&& !status
) {
126 bsize
= min_t(u16
, CSR_CACHE_SIZE
, len
);
127 status
= rt2x00usb_vendor_req_buff_lock(rt2x00dev
, request
,
128 requesttype
, off
, tb
,
136 mutex_unlock(&rt2x00dev
->csr_mutex
);
140 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff
);
142 int rt2x00usb_regbusy_read(struct rt2x00_dev
*rt2x00dev
,
143 const unsigned int offset
,
144 const struct rt2x00_field32 field
,
149 if (!test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
152 for (i
= 0; i
< REGISTER_BUSY_COUNT
; i
++) {
153 rt2x00usb_register_read_lock(rt2x00dev
, offset
, reg
);
154 if (!rt2x00_get_field32(*reg
, field
))
156 udelay(REGISTER_BUSY_DELAY
);
159 ERROR(rt2x00dev
, "Indirect register access failed: "
160 "offset=0x%.08x, value=0x%.08x\n", offset
, *reg
);
165 EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read
);
170 static void rt2x00usb_interrupt_txdone(struct urb
*urb
)
172 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
173 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
174 struct skb_frame_desc
*skbdesc
= get_skb_frame_desc(entry
->skb
);
175 struct txdone_entry_desc txdesc
;
177 if (!test_bit(DEVICE_STATE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
178 !test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
182 * Remove the descriptor from the front of the skb.
184 skb_pull(entry
->skb
, entry
->queue
->desc_size
);
187 * Signal that the TX descriptor is no longer in the skb.
189 skbdesc
->flags
&= ~SKBDESC_DESC_IN_SKB
;
192 * Obtain the status about this packet.
193 * Note that when the status is 0 it does not mean the
194 * frame was send out correctly. It only means the frame
195 * was succesfully pushed to the hardware, we have no
196 * way to determine the transmission status right now.
197 * (Only indirectly by looking at the failed TX counters
202 __set_bit(TXDONE_UNKNOWN
, &txdesc
.flags
);
204 __set_bit(TXDONE_FAILURE
, &txdesc
.flags
);
207 rt2x00lib_txdone(entry
, &txdesc
);
210 int rt2x00usb_write_tx_data(struct queue_entry
*entry
,
211 struct txentry_desc
*txdesc
)
213 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
214 struct usb_device
*usb_dev
= to_usb_device_intf(rt2x00dev
->dev
);
215 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
219 * Add the descriptor in front of the skb.
221 skb_push(entry
->skb
, entry
->queue
->desc_size
);
222 memset(entry
->skb
->data
, 0, entry
->queue
->desc_size
);
225 * USB devices cannot blindly pass the skb->len as the
226 * length of the data to usb_fill_bulk_urb. Pass the skb
227 * to the driver to determine what the length should be.
229 length
= rt2x00dev
->ops
->lib
->get_tx_data_len(entry
);
231 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
,
232 usb_sndbulkpipe(usb_dev
, entry
->queue
->usb_endpoint
),
233 entry
->skb
->data
, length
,
234 rt2x00usb_interrupt_txdone
, entry
);
237 * Call the driver's write_tx_datadesc function, if it exists.
239 if (rt2x00dev
->ops
->lib
->write_tx_datadesc
)
240 rt2x00dev
->ops
->lib
->write_tx_datadesc(entry
, txdesc
);
244 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data
);
246 static inline void rt2x00usb_kick_tx_entry(struct queue_entry
*entry
)
248 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
250 if (test_and_clear_bit(ENTRY_DATA_PENDING
, &entry
->flags
))
251 usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
254 void rt2x00usb_kick_tx_queue(struct rt2x00_dev
*rt2x00dev
,
255 const enum data_queue_qid qid
)
257 struct data_queue
*queue
= rt2x00queue_get_queue(rt2x00dev
, qid
);
258 unsigned long irqflags
;
260 unsigned int index_done
;
264 * Only protect the range we are going to loop over,
265 * if during our loop a extra entry is set to pending
266 * it should not be kicked during this run, since it
267 * is part of another TX operation.
269 spin_lock_irqsave(&queue
->lock
, irqflags
);
270 index
= queue
->index
[Q_INDEX
];
271 index_done
= queue
->index
[Q_INDEX_DONE
];
272 spin_unlock_irqrestore(&queue
->lock
, irqflags
);
275 * Start from the TX done pointer, this guarentees that we will
276 * send out all frames in the correct order.
278 if (index_done
< index
) {
279 for (i
= index_done
; i
< index
; i
++)
280 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
282 for (i
= index_done
; i
< queue
->limit
; i
++)
283 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
285 for (i
= 0; i
< index
; i
++)
286 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
289 EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue
);
291 void rt2x00usb_kill_tx_queue(struct rt2x00_dev
*rt2x00dev
,
292 const enum data_queue_qid qid
)
294 struct data_queue
*queue
= rt2x00queue_get_queue(rt2x00dev
, qid
);
295 struct queue_entry_priv_usb
*entry_priv
;
296 struct queue_entry_priv_usb_bcn
*bcn_priv
;
301 * When killing the beacon queue, we must also kill
302 * the beacon guard byte.
305 (qid
== QID_BEACON
) &&
306 (test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
));
309 * Cancel all entries.
311 for (i
= 0; i
< queue
->limit
; i
++) {
312 entry_priv
= queue
->entries
[i
].priv_data
;
313 usb_kill_urb(entry_priv
->urb
);
316 * Kill guardian urb (if required by driver).
319 bcn_priv
= queue
->entries
[i
].priv_data
;
320 usb_kill_urb(bcn_priv
->guardian_urb
);
324 EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue
);
329 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
331 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
332 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
333 struct skb_frame_desc
*skbdesc
= get_skb_frame_desc(entry
->skb
);
336 if (!test_bit(DEVICE_STATE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
337 !test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
341 * Check if the received data is simply too small
342 * to be actually valid, or if the urb is signaling
345 if (urb
->actual_length
< entry
->queue
->desc_size
|| urb
->status
) {
346 set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
347 usb_submit_urb(urb
, GFP_ATOMIC
);
352 * Fill in desc fields of the skb descriptor
355 skbdesc
->desc_len
= entry
->queue
->desc_size
;
358 * Send the frame to rt2x00lib for further processing.
360 rt2x00lib_rxdone(rt2x00dev
, entry
);
366 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
368 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0, 0,
372 * The USB version of kill_tx_queue also works
375 rt2x00dev
->ops
->lib
->kill_tx_queue(rt2x00dev
, QID_RX
);
377 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
380 * Device initialization handlers.
382 void rt2x00usb_clear_entry(struct queue_entry
*entry
)
384 struct usb_device
*usb_dev
=
385 to_usb_device_intf(entry
->queue
->rt2x00dev
->dev
);
386 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
389 if (entry
->queue
->qid
== QID_RX
) {
390 pipe
= usb_rcvbulkpipe(usb_dev
, entry
->queue
->usb_endpoint
);
391 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
, pipe
,
392 entry
->skb
->data
, entry
->skb
->len
,
393 rt2x00usb_interrupt_rxdone
, entry
);
395 set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
396 usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
401 EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry
);
403 static void rt2x00usb_assign_endpoint(struct data_queue
*queue
,
404 struct usb_endpoint_descriptor
*ep_desc
)
406 struct usb_device
*usb_dev
= to_usb_device_intf(queue
->rt2x00dev
->dev
);
409 queue
->usb_endpoint
= usb_endpoint_num(ep_desc
);
411 if (queue
->qid
== QID_RX
) {
412 pipe
= usb_rcvbulkpipe(usb_dev
, queue
->usb_endpoint
);
413 queue
->usb_maxpacket
= usb_maxpacket(usb_dev
, pipe
, 0);
415 pipe
= usb_sndbulkpipe(usb_dev
, queue
->usb_endpoint
);
416 queue
->usb_maxpacket
= usb_maxpacket(usb_dev
, pipe
, 1);
419 if (!queue
->usb_maxpacket
)
420 queue
->usb_maxpacket
= 1;
423 static int rt2x00usb_find_endpoints(struct rt2x00_dev
*rt2x00dev
)
425 struct usb_interface
*intf
= to_usb_interface(rt2x00dev
->dev
);
426 struct usb_host_interface
*intf_desc
= intf
->cur_altsetting
;
427 struct usb_endpoint_descriptor
*ep_desc
;
428 struct data_queue
*queue
= rt2x00dev
->tx
;
429 struct usb_endpoint_descriptor
*tx_ep_desc
= NULL
;
433 * Walk through all available endpoints to search for "bulk in"
434 * and "bulk out" endpoints. When we find such endpoints collect
435 * the information we need from the descriptor and assign it
438 for (i
= 0; i
< intf_desc
->desc
.bNumEndpoints
; i
++) {
439 ep_desc
= &intf_desc
->endpoint
[i
].desc
;
441 if (usb_endpoint_is_bulk_in(ep_desc
)) {
442 rt2x00usb_assign_endpoint(rt2x00dev
->rx
, ep_desc
);
443 } else if (usb_endpoint_is_bulk_out(ep_desc
) &&
444 (queue
!= queue_end(rt2x00dev
))) {
445 rt2x00usb_assign_endpoint(queue
, ep_desc
);
446 queue
= queue_next(queue
);
448 tx_ep_desc
= ep_desc
;
453 * At least 1 endpoint for RX and 1 endpoint for TX must be available.
455 if (!rt2x00dev
->rx
->usb_endpoint
|| !rt2x00dev
->tx
->usb_endpoint
) {
456 ERROR(rt2x00dev
, "Bulk-in/Bulk-out endpoints not found\n");
461 * It might be possible not all queues have a dedicated endpoint.
462 * Loop through all TX queues and copy the endpoint information
463 * which we have gathered from already assigned endpoints.
465 txall_queue_for_each(rt2x00dev
, queue
) {
466 if (!queue
->usb_endpoint
)
467 rt2x00usb_assign_endpoint(queue
, tx_ep_desc
);
473 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
474 struct data_queue
*queue
)
476 struct queue_entry_priv_usb
*entry_priv
;
477 struct queue_entry_priv_usb_bcn
*bcn_priv
;
480 for (i
= 0; i
< queue
->limit
; i
++) {
481 entry_priv
= queue
->entries
[i
].priv_data
;
482 entry_priv
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
483 if (!entry_priv
->urb
)
488 * If this is not the beacon queue or
489 * no guardian byte was required for the beacon,
492 if (rt2x00dev
->bcn
!= queue
||
493 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
496 for (i
= 0; i
< queue
->limit
; i
++) {
497 bcn_priv
= queue
->entries
[i
].priv_data
;
498 bcn_priv
->guardian_urb
= usb_alloc_urb(0, GFP_KERNEL
);
499 if (!bcn_priv
->guardian_urb
)
506 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
507 struct data_queue
*queue
)
509 struct queue_entry_priv_usb
*entry_priv
;
510 struct queue_entry_priv_usb_bcn
*bcn_priv
;
516 for (i
= 0; i
< queue
->limit
; i
++) {
517 entry_priv
= queue
->entries
[i
].priv_data
;
518 usb_kill_urb(entry_priv
->urb
);
519 usb_free_urb(entry_priv
->urb
);
523 * If this is not the beacon queue or
524 * no guardian byte was required for the beacon,
527 if (rt2x00dev
->bcn
!= queue
||
528 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
531 for (i
= 0; i
< queue
->limit
; i
++) {
532 bcn_priv
= queue
->entries
[i
].priv_data
;
533 usb_kill_urb(bcn_priv
->guardian_urb
);
534 usb_free_urb(bcn_priv
->guardian_urb
);
538 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
540 struct data_queue
*queue
;
544 * Find endpoints for each queue
546 status
= rt2x00usb_find_endpoints(rt2x00dev
);
553 queue_for_each(rt2x00dev
, queue
) {
554 status
= rt2x00usb_alloc_urb(rt2x00dev
, queue
);
562 rt2x00usb_uninitialize(rt2x00dev
);
566 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
568 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
570 struct data_queue
*queue
;
572 queue_for_each(rt2x00dev
, queue
)
573 rt2x00usb_free_urb(rt2x00dev
, queue
);
575 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
578 * USB driver handlers.
580 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
582 kfree(rt2x00dev
->rf
);
583 rt2x00dev
->rf
= NULL
;
585 kfree(rt2x00dev
->eeprom
);
586 rt2x00dev
->eeprom
= NULL
;
588 kfree(rt2x00dev
->csr
.cache
);
589 rt2x00dev
->csr
.cache
= NULL
;
592 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
594 rt2x00dev
->csr
.cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
595 if (!rt2x00dev
->csr
.cache
)
598 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
599 if (!rt2x00dev
->eeprom
)
602 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
609 ERROR_PROBE("Failed to allocate registers.\n");
611 rt2x00usb_free_reg(rt2x00dev
);
616 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
617 const struct usb_device_id
*id
)
619 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
620 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
621 struct ieee80211_hw
*hw
;
622 struct rt2x00_dev
*rt2x00dev
;
625 usb_dev
= usb_get_dev(usb_dev
);
627 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
629 ERROR_PROBE("Failed to allocate hardware.\n");
631 goto exit_put_device
;
634 usb_set_intfdata(usb_intf
, hw
);
636 rt2x00dev
= hw
->priv
;
637 rt2x00dev
->dev
= &usb_intf
->dev
;
638 rt2x00dev
->ops
= ops
;
641 rt2x00_set_chip_intf(rt2x00dev
, RT2X00_CHIP_INTF_USB
);
643 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
645 goto exit_free_device
;
647 retval
= rt2x00lib_probe_dev(rt2x00dev
);
654 rt2x00usb_free_reg(rt2x00dev
);
657 ieee80211_free_hw(hw
);
660 usb_put_dev(usb_dev
);
662 usb_set_intfdata(usb_intf
, NULL
);
666 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
668 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
670 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
671 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
674 * Free all allocated data.
676 rt2x00lib_remove_dev(rt2x00dev
);
677 rt2x00usb_free_reg(rt2x00dev
);
678 ieee80211_free_hw(hw
);
681 * Free the USB device data.
683 usb_set_intfdata(usb_intf
, NULL
);
684 usb_put_dev(interface_to_usbdev(usb_intf
));
686 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
689 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
691 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
692 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
695 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
700 * Decrease usbdev refcount.
702 usb_put_dev(interface_to_usbdev(usb_intf
));
706 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
708 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
710 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
711 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
713 usb_get_dev(interface_to_usbdev(usb_intf
));
715 return rt2x00lib_resume(rt2x00dev
);
717 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
718 #endif /* CONFIG_PM */
721 * rt2x00usb module information.
723 MODULE_AUTHOR(DRV_PROJECT
);
724 MODULE_VERSION(DRV_VERSION
);
725 MODULE_DESCRIPTION("rt2x00 usb library");
726 MODULE_LICENSE("GPL");