2 Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
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/usb.h>
29 #include <linux/bug.h>
32 #include "rt2x00usb.h"
35 * Interfacing with the HW.
37 int 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
,
43 struct usb_device
*usb_dev
= rt2x00dev_usb_dev(rt2x00dev
);
47 (requesttype
== USB_VENDOR_REQUEST_IN
) ?
48 usb_rcvctrlpipe(usb_dev
, 0) : usb_sndctrlpipe(usb_dev
, 0);
51 for (i
= 0; i
< REGISTER_BUSY_COUNT
; i
++) {
52 status
= usb_control_msg(usb_dev
, pipe
, request
, requesttype
,
53 value
, offset
, buffer
, buffer_length
,
60 * -ENODEV: Device has disappeared, no point continuing.
61 * All other errors: Try again.
63 else if (status
== -ENODEV
)
68 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
69 request
, offset
, status
);
73 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request
);
75 int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev
*rt2x00dev
,
76 const u8 request
, const u8 requesttype
,
77 const u16 offset
, void *buffer
,
78 const u16 buffer_length
, const int timeout
)
82 BUG_ON(!mutex_is_locked(&rt2x00dev
->usb_cache_mutex
));
85 * Check for Cache availability.
87 if (unlikely(!rt2x00dev
->csr_cache
|| buffer_length
> CSR_CACHE_SIZE
)) {
88 ERROR(rt2x00dev
, "CSR cache not available.\n");
92 if (requesttype
== USB_VENDOR_REQUEST_OUT
)
93 memcpy(rt2x00dev
->csr_cache
, buffer
, buffer_length
);
95 status
= rt2x00usb_vendor_request(rt2x00dev
, request
, requesttype
,
96 offset
, 0, rt2x00dev
->csr_cache
,
97 buffer_length
, timeout
);
99 if (!status
&& requesttype
== USB_VENDOR_REQUEST_IN
)
100 memcpy(buffer
, rt2x00dev
->csr_cache
, buffer_length
);
104 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock
);
106 int rt2x00usb_vendor_request_buff(struct rt2x00_dev
*rt2x00dev
,
107 const u8 request
, const u8 requesttype
,
108 const u16 offset
, void *buffer
,
109 const u16 buffer_length
, const int timeout
)
113 mutex_lock(&rt2x00dev
->usb_cache_mutex
);
115 status
= rt2x00usb_vendor_req_buff_lock(rt2x00dev
, request
,
116 requesttype
, offset
, buffer
,
117 buffer_length
, timeout
);
119 mutex_unlock(&rt2x00dev
->usb_cache_mutex
);
123 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff
);
128 static void rt2x00usb_interrupt_txdone(struct urb
*urb
)
130 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
131 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
132 struct queue_entry_priv_usb_tx
*priv_tx
= entry
->priv_data
;
133 struct txdone_entry_desc txdesc
;
134 __le32
*txd
= (__le32
*)entry
->skb
->data
;
137 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
138 !__test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
141 rt2x00_desc_read(txd
, 0, &word
);
144 * Remove the descriptor data from the buffer.
146 skb_pull(entry
->skb
, entry
->queue
->desc_size
);
149 * Obtain the status about this packet.
151 txdesc
.status
= !urb
->status
? TX_SUCCESS
: TX_FAIL_RETRY
;
153 txdesc
.control
= &priv_tx
->control
;
155 rt2x00lib_txdone(entry
, &txdesc
);
158 * Make this entry available for reuse.
161 rt2x00queue_index_inc(entry
->queue
, Q_INDEX_DONE
);
164 * If the data queue was full before the txdone handler
165 * we must make sure the packet queue in the mac80211 stack
166 * is reenabled when the txdone handler has finished.
168 if (!rt2x00queue_full(entry
->queue
))
169 ieee80211_wake_queue(rt2x00dev
->hw
, priv_tx
->control
.queue
);
172 int rt2x00usb_write_tx_data(struct rt2x00_dev
*rt2x00dev
,
173 struct data_queue
*queue
, struct sk_buff
*skb
,
174 struct ieee80211_tx_control
*control
)
176 struct usb_device
*usb_dev
= rt2x00dev_usb_dev(rt2x00dev
);
177 struct queue_entry
*entry
= rt2x00queue_get_entry(queue
, Q_INDEX
);
178 struct queue_entry_priv_usb_tx
*priv_tx
= entry
->priv_data
;
179 struct skb_frame_desc
*skbdesc
;
182 if (rt2x00queue_full(queue
))
185 if (test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
)) {
187 "Arrived at non-free entry in the non-full queue %d.\n"
188 "Please file bug report to %s.\n",
189 control
->queue
, DRV_PROJECT
);
194 * Add the descriptor in front of the skb.
196 skb_push(skb
, queue
->desc_size
);
197 memset(skb
->data
, 0, queue
->desc_size
);
200 * Fill in skb descriptor
202 skbdesc
= get_skb_frame_desc(skb
);
203 memset(skbdesc
, 0, sizeof(*skbdesc
));
204 skbdesc
->data
= skb
->data
+ queue
->desc_size
;
205 skbdesc
->data_len
= queue
->data_size
;
206 skbdesc
->desc
= skb
->data
;
207 skbdesc
->desc_len
= queue
->desc_size
;
208 skbdesc
->entry
= entry
;
210 rt2x00lib_write_tx_desc(rt2x00dev
, skb
, control
);
213 * USB devices cannot blindly pass the skb->len as the
214 * length of the data to usb_fill_bulk_urb. Pass the skb
215 * to the driver to determine what the length should be.
217 length
= rt2x00dev
->ops
->lib
->get_tx_data_len(rt2x00dev
, skb
);
220 * Initialize URB and send the frame to the device.
222 __set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
223 usb_fill_bulk_urb(priv_tx
->urb
, usb_dev
, usb_sndbulkpipe(usb_dev
, 1),
224 skb
->data
, length
, rt2x00usb_interrupt_txdone
, entry
);
225 usb_submit_urb(priv_tx
->urb
, GFP_ATOMIC
);
227 rt2x00queue_index_inc(queue
, Q_INDEX
);
231 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data
);
236 static struct sk_buff
* rt2x00usb_alloc_rxskb(struct data_queue
*queue
)
239 unsigned int frame_size
;
242 * As alignment we use 2 and not NET_IP_ALIGN because we need
243 * to be sure we have 2 bytes room in the head. (NET_IP_ALIGN
244 * can be 0 on some hardware). We use these 2 bytes for frame
245 * alignment later, we assume that the chance that
246 * header_size % 4 == 2 is bigger then header_size % 2 == 0
247 * and thus optimize alignment by reserving the 2 bytes in
250 frame_size
= queue
->data_size
+ queue
->desc_size
;
251 skb
= dev_alloc_skb(frame_size
+ 2);
256 skb_put(skb
, frame_size
);
261 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
263 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
264 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
266 struct skb_frame_desc
*skbdesc
;
267 struct rxdone_entry_desc rxdesc
;
269 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
270 !test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
274 * Check if the received data is simply too small
275 * to be actually valid, or if the urb is signaling
278 if (urb
->actual_length
< entry
->queue
->desc_size
|| urb
->status
)
282 * Fill in skb descriptor
284 skbdesc
= get_skb_frame_desc(entry
->skb
);
285 memset(skbdesc
, 0, sizeof(*skbdesc
));
286 skbdesc
->entry
= entry
;
288 memset(&rxdesc
, 0, sizeof(rxdesc
));
289 rt2x00dev
->ops
->lib
->fill_rxdone(entry
, &rxdesc
);
292 * Allocate a new sk buffer to replace the current one.
293 * If allocation fails, we should drop the current frame
294 * so we can recycle the existing sk buffer for the new frame.
296 skb
= rt2x00usb_alloc_rxskb(entry
->queue
);
301 * Send the frame to rt2x00lib for further processing.
303 rt2x00lib_rxdone(entry
, &rxdesc
);
306 * Replace current entry's skb with the newly allocated one,
307 * and reinitialize the urb.
310 urb
->transfer_buffer
= entry
->skb
->data
;
311 urb
->transfer_buffer_length
= entry
->skb
->len
;
314 if (test_bit(DEVICE_ENABLED_RADIO
, &entry
->queue
->rt2x00dev
->flags
)) {
315 __set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
316 usb_submit_urb(urb
, GFP_ATOMIC
);
319 rt2x00queue_index_inc(entry
->queue
, Q_INDEX
);
325 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
327 struct queue_entry_priv_usb_rx
*priv_rx
;
328 struct queue_entry_priv_usb_tx
*priv_tx
;
329 struct data_queue
*queue
;
332 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0x0000, 0x0000,
338 for (i
= 0; i
< rt2x00dev
->rx
->limit
; i
++) {
339 priv_rx
= rt2x00dev
->rx
->entries
[i
].priv_data
;
340 usb_kill_urb(priv_rx
->urb
);
343 txall_queue_for_each(rt2x00dev
, queue
) {
344 for (i
= 0; i
< queue
->limit
; i
++) {
345 priv_tx
= queue
->entries
[i
].priv_data
;
346 usb_kill_urb(priv_tx
->urb
);
350 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
353 * Device initialization handlers.
355 void rt2x00usb_init_rxentry(struct rt2x00_dev
*rt2x00dev
,
356 struct queue_entry
*entry
)
358 struct usb_device
*usb_dev
= rt2x00dev_usb_dev(rt2x00dev
);
359 struct queue_entry_priv_usb_rx
*priv_rx
= entry
->priv_data
;
361 usb_fill_bulk_urb(priv_rx
->urb
, usb_dev
,
362 usb_rcvbulkpipe(usb_dev
, 1),
363 entry
->skb
->data
, entry
->skb
->len
,
364 rt2x00usb_interrupt_rxdone
, entry
);
366 __set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
367 usb_submit_urb(priv_rx
->urb
, GFP_ATOMIC
);
369 EXPORT_SYMBOL_GPL(rt2x00usb_init_rxentry
);
371 void rt2x00usb_init_txentry(struct rt2x00_dev
*rt2x00dev
,
372 struct queue_entry
*entry
)
376 EXPORT_SYMBOL_GPL(rt2x00usb_init_txentry
);
378 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
379 struct data_queue
*queue
)
381 struct queue_entry_priv_usb_rx
*priv_rx
;
382 struct queue_entry_priv_usb_tx
*priv_tx
;
383 struct queue_entry_priv_usb_bcn
*priv_bcn
;
385 unsigned int guardian
=
386 test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
);
392 for (i
= 0; i
< queue
->limit
; i
++) {
393 urb
= usb_alloc_urb(0, GFP_KERNEL
);
397 if (queue
->qid
== QID_RX
) {
398 priv_rx
= queue
->entries
[i
].priv_data
;
400 } else if (queue
->qid
== QID_MGMT
&& guardian
) {
401 priv_bcn
= queue
->entries
[i
].priv_data
;
404 urb
= usb_alloc_urb(0, GFP_KERNEL
);
408 priv_bcn
->guardian_urb
= urb
;
410 priv_tx
= queue
->entries
[i
].priv_data
;
418 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
419 struct data_queue
*queue
)
421 struct queue_entry_priv_usb_rx
*priv_rx
;
422 struct queue_entry_priv_usb_tx
*priv_tx
;
423 struct queue_entry_priv_usb_bcn
*priv_bcn
;
425 unsigned int guardian
=
426 test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
);
432 for (i
= 0; i
< queue
->limit
; i
++) {
433 if (queue
->qid
== QID_RX
) {
434 priv_rx
= queue
->entries
[i
].priv_data
;
436 } else if (queue
->qid
== QID_MGMT
&& guardian
) {
437 priv_bcn
= queue
->entries
[i
].priv_data
;
439 usb_kill_urb(priv_bcn
->guardian_urb
);
440 usb_free_urb(priv_bcn
->guardian_urb
);
444 priv_tx
= queue
->entries
[i
].priv_data
;
450 if (queue
->entries
[i
].skb
)
451 kfree_skb(queue
->entries
[i
].skb
);
455 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
457 struct data_queue
*queue
;
459 unsigned int entry_size
;
461 int uninitialized_var(status
);
466 queue_for_each(rt2x00dev
, queue
) {
467 status
= rt2x00usb_alloc_urb(rt2x00dev
, queue
);
473 * For the RX queue, skb's should be allocated.
475 entry_size
= rt2x00dev
->rx
->data_size
+ rt2x00dev
->rx
->desc_size
;
476 for (i
= 0; i
< rt2x00dev
->rx
->limit
; i
++) {
477 skb
= rt2x00usb_alloc_rxskb(rt2x00dev
->rx
);
481 rt2x00dev
->rx
->entries
[i
].skb
= skb
;
487 rt2x00usb_uninitialize(rt2x00dev
);
491 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
493 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
495 struct data_queue
*queue
;
497 queue_for_each(rt2x00dev
, queue
)
498 rt2x00usb_free_urb(rt2x00dev
, queue
);
500 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
503 * USB driver handlers.
505 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
507 kfree(rt2x00dev
->rf
);
508 rt2x00dev
->rf
= NULL
;
510 kfree(rt2x00dev
->eeprom
);
511 rt2x00dev
->eeprom
= NULL
;
513 kfree(rt2x00dev
->csr_cache
);
514 rt2x00dev
->csr_cache
= NULL
;
517 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
519 rt2x00dev
->csr_cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
520 if (!rt2x00dev
->csr_cache
)
523 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
524 if (!rt2x00dev
->eeprom
)
527 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
534 ERROR_PROBE("Failed to allocate registers.\n");
536 rt2x00usb_free_reg(rt2x00dev
);
541 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
542 const struct usb_device_id
*id
)
544 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
545 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
546 struct ieee80211_hw
*hw
;
547 struct rt2x00_dev
*rt2x00dev
;
550 usb_dev
= usb_get_dev(usb_dev
);
552 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
554 ERROR_PROBE("Failed to allocate hardware.\n");
556 goto exit_put_device
;
559 usb_set_intfdata(usb_intf
, hw
);
561 rt2x00dev
= hw
->priv
;
562 rt2x00dev
->dev
= usb_intf
;
563 rt2x00dev
->ops
= ops
;
565 mutex_init(&rt2x00dev
->usb_cache_mutex
);
567 rt2x00dev
->usb_maxpacket
=
568 usb_maxpacket(usb_dev
, usb_sndbulkpipe(usb_dev
, 1), 1);
569 if (!rt2x00dev
->usb_maxpacket
)
570 rt2x00dev
->usb_maxpacket
= 1;
572 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
574 goto exit_free_device
;
576 retval
= rt2x00lib_probe_dev(rt2x00dev
);
583 rt2x00usb_free_reg(rt2x00dev
);
586 ieee80211_free_hw(hw
);
589 usb_put_dev(usb_dev
);
591 usb_set_intfdata(usb_intf
, NULL
);
595 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
597 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
599 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
600 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
603 * Free all allocated data.
605 rt2x00lib_remove_dev(rt2x00dev
);
606 rt2x00usb_free_reg(rt2x00dev
);
607 ieee80211_free_hw(hw
);
610 * Free the USB device data.
612 usb_set_intfdata(usb_intf
, NULL
);
613 usb_put_dev(interface_to_usbdev(usb_intf
));
615 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
618 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
620 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
621 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
624 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
628 rt2x00usb_free_reg(rt2x00dev
);
631 * Decrease usbdev refcount.
633 usb_put_dev(interface_to_usbdev(usb_intf
));
637 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
639 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
641 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
642 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
645 usb_get_dev(interface_to_usbdev(usb_intf
));
647 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
651 retval
= rt2x00lib_resume(rt2x00dev
);
658 rt2x00usb_free_reg(rt2x00dev
);
662 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
663 #endif /* CONFIG_PM */
666 * rt2x00usb module information.
668 MODULE_AUTHOR(DRV_PROJECT
);
669 MODULE_VERSION(DRV_VERSION
);
670 MODULE_DESCRIPTION("rt2x00 usb library");
671 MODULE_LICENSE("GPL");