2 Copyright (C) 2004 - 2007 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.
27 * Set enviroment defines for rt2x00.h
29 #define DRV_NAME "rt2x00usb"
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/usb.h>
36 #include "rt2x00usb.h"
39 * Interfacing with the HW.
41 int rt2x00usb_vendor_request(const struct rt2x00_dev
*rt2x00dev
,
42 const u8 request
, const u8 requesttype
,
43 const u16 offset
, const u16 value
,
44 void *buffer
, const u16 buffer_length
,
47 struct usb_device
*usb_dev
=
48 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
52 (requesttype
== USB_VENDOR_REQUEST_IN
) ?
53 usb_rcvctrlpipe(usb_dev
, 0) : usb_sndctrlpipe(usb_dev
, 0);
55 for (i
= 0; i
< REGISTER_BUSY_COUNT
; i
++) {
56 status
= usb_control_msg(usb_dev
, pipe
, request
, requesttype
,
57 value
, offset
, buffer
, buffer_length
,
64 * -ETIMEDOUT: We need a bit more time to complete.
65 * -ENODEV: Device has disappeared, no point continuing.
67 if (status
== -ETIMEDOUT
)
69 else if (status
== -ENODEV
)
74 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
75 request
, offset
, status
);
79 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request
);
81 int rt2x00usb_vendor_request_buff(const struct rt2x00_dev
*rt2x00dev
,
82 const u8 request
, const u8 requesttype
,
83 const u16 offset
, void *buffer
,
84 const u16 buffer_length
, u16 timeout
)
89 * Check for Cache availability.
91 if (unlikely(!rt2x00dev
->csr_cache
|| buffer_length
> CSR_CACHE_SIZE
)) {
92 ERROR(rt2x00dev
, "CSR cache not available.\n");
96 if (requesttype
== USB_VENDOR_REQUEST_OUT
)
97 memcpy(rt2x00dev
->csr_cache
, buffer
, buffer_length
);
99 status
= rt2x00usb_vendor_request(rt2x00dev
, request
, requesttype
,
100 offset
, 0, rt2x00dev
->csr_cache
,
101 buffer_length
, timeout
);
103 if (!status
&& requesttype
== USB_VENDOR_REQUEST_IN
)
104 memcpy(buffer
, rt2x00dev
->csr_cache
, buffer_length
);
108 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff
);
113 static void rt2x00usb_interrupt_txdone(struct urb
*urb
)
115 struct data_entry
*entry
= (struct data_entry
*)urb
->context
;
116 struct data_ring
*ring
= entry
->ring
;
117 struct rt2x00_dev
*rt2x00dev
= ring
->rt2x00dev
;
118 struct data_desc
*txd
= (struct data_desc
*)entry
->skb
->data
;
122 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
123 !__test_and_clear_bit(ENTRY_OWNER_NIC
, &entry
->flags
))
126 rt2x00_desc_read(txd
, 0, &word
);
129 * Remove the descriptor data from the buffer.
131 skb_pull(entry
->skb
, ring
->desc_size
);
134 * Obtain the status about this packet.
136 tx_status
= !urb
->status
? TX_SUCCESS
: TX_FAIL_RETRY
;
138 rt2x00lib_txdone(entry
, tx_status
, 0);
141 * Make this entry available for reuse.
144 rt2x00_ring_index_done_inc(entry
->ring
);
147 * If the data ring was full before the txdone handler
148 * we must make sure the packet queue in the mac80211 stack
149 * is reenabled when the txdone handler has finished.
151 if (!rt2x00_ring_full(ring
))
152 ieee80211_wake_queue(rt2x00dev
->hw
,
153 entry
->tx_status
.control
.queue
);
156 int rt2x00usb_write_tx_data(struct rt2x00_dev
*rt2x00dev
,
157 struct data_ring
*ring
, struct sk_buff
*skb
,
158 struct ieee80211_tx_control
*control
)
160 struct usb_device
*usb_dev
=
161 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
162 struct ieee80211_hdr
*ieee80211hdr
= (struct ieee80211_hdr
*)skb
->data
;
163 struct data_entry
*entry
= rt2x00_get_data_entry(ring
);
164 u32 length
= skb
->len
;
166 if (rt2x00_ring_full(ring
)) {
167 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
171 if (test_bit(ENTRY_OWNER_NIC
, &entry
->flags
)) {
173 "Arrived at non-free entry in the non-full queue %d.\n"
174 "Please file bug report to %s.\n",
175 control
->queue
, DRV_PROJECT
);
176 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
181 * Add the descriptor in front of the skb.
183 skb_push(skb
, rt2x00dev
->hw
->extra_tx_headroom
);
184 memset(skb
->data
, 0x00, rt2x00dev
->hw
->extra_tx_headroom
);
186 rt2x00lib_write_tx_desc(rt2x00dev
, (struct data_desc
*)skb
->data
,
187 ieee80211hdr
, length
, control
);
188 memcpy(&entry
->tx_status
.control
, control
, sizeof(*control
));
192 * Length passed to usb_fill_urb cannot be an odd number,
193 * so add 1 byte to make it even.
195 length
+= rt2x00dev
->hw
->extra_tx_headroom
;
199 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
200 usb_fill_bulk_urb(entry
->priv
, usb_dev
,
201 usb_sndbulkpipe(usb_dev
, 1),
202 skb
->data
, length
, rt2x00usb_interrupt_txdone
, entry
);
203 usb_submit_urb(entry
->priv
, GFP_ATOMIC
);
205 rt2x00_ring_index_inc(ring
);
207 if (rt2x00_ring_full(ring
))
208 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
212 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data
);
217 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
219 struct data_entry
*entry
= (struct data_entry
*)urb
->context
;
220 struct data_ring
*ring
= entry
->ring
;
221 struct rt2x00_dev
*rt2x00dev
= ring
->rt2x00dev
;
230 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
231 !test_and_clear_bit(ENTRY_OWNER_NIC
, &entry
->flags
))
235 * Check if the received data is simply too small
236 * to be actually valid, or if the urb is signaling
239 if (urb
->actual_length
< entry
->ring
->desc_size
|| urb
->status
)
242 retval
= rt2x00dev
->ops
->lib
->fill_rxdone(entry
, &signal
, &rssi
,
248 * Allocate a new sk buffer to replace the current one.
249 * If allocation fails, we should drop the current frame
250 * so we can recycle the existing sk buffer for the new frame.
252 frame_size
= entry
->ring
->data_size
+ entry
->ring
->desc_size
;
253 skb
= dev_alloc_skb(frame_size
+ NET_IP_ALIGN
);
257 skb_reserve(skb
, NET_IP_ALIGN
);
258 skb_put(skb
, frame_size
);
261 * Trim the skb_buffer to only contain the valid
262 * frame data (so ignore the device's descriptor).
264 skb_trim(entry
->skb
, size
);
267 * Send the frame to rt2x00lib for further processing.
269 rt2x00lib_rxdone(entry
, entry
->skb
, signal
, rssi
, ofdm
);
272 * Replace current entry's skb with the newly allocated one,
273 * and reinitialize the urb.
276 urb
->transfer_buffer
= entry
->skb
->data
;
277 urb
->transfer_buffer_length
= entry
->skb
->len
;
280 if (test_bit(DEVICE_ENABLED_RADIO
, &ring
->rt2x00dev
->flags
)) {
281 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
282 usb_submit_urb(urb
, GFP_ATOMIC
);
285 rt2x00_ring_index_inc(ring
);
291 void rt2x00usb_enable_radio(struct rt2x00_dev
*rt2x00dev
)
293 struct usb_device
*usb_dev
=
294 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
295 struct data_ring
*ring
;
296 struct data_entry
*entry
;
300 * Initialize the TX rings
302 txringall_for_each(rt2x00dev
, ring
) {
303 for (i
= 0; i
< ring
->stats
.limit
; i
++)
304 ring
->entry
[i
].flags
= 0;
306 rt2x00_ring_index_clear(ring
);
310 * Initialize and start the RX ring.
312 rt2x00_ring_index_clear(rt2x00dev
->rx
);
314 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
315 entry
= &rt2x00dev
->rx
->entry
[i
];
317 usb_fill_bulk_urb(entry
->priv
, usb_dev
,
318 usb_rcvbulkpipe(usb_dev
, 1),
319 entry
->skb
->data
, entry
->skb
->len
,
320 rt2x00usb_interrupt_rxdone
, entry
);
322 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
323 usb_submit_urb(entry
->priv
, GFP_ATOMIC
);
326 EXPORT_SYMBOL_GPL(rt2x00usb_enable_radio
);
328 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
330 struct data_ring
*ring
;
333 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0x0000, 0x0000,
339 ring_for_each(rt2x00dev
, ring
) {
340 for (i
= 0; i
< ring
->stats
.limit
; i
++)
341 usb_kill_urb(ring
->entry
[i
].priv
);
344 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
347 * Device initialization handlers.
349 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
350 struct data_ring
*ring
)
357 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
358 ring
->entry
[i
].priv
= usb_alloc_urb(0, GFP_KERNEL
);
359 if (!ring
->entry
[i
].priv
)
366 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
367 struct data_ring
*ring
)
374 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
375 usb_kill_urb(ring
->entry
[i
].priv
);
376 usb_free_urb(ring
->entry
[i
].priv
);
377 if (ring
->entry
[i
].skb
)
378 kfree_skb(ring
->entry
[i
].skb
);
382 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
384 struct data_ring
*ring
;
386 unsigned int entry_size
;
393 ring_for_each(rt2x00dev
, ring
) {
394 status
= rt2x00usb_alloc_urb(rt2x00dev
, ring
);
400 * For the RX ring, skb's should be allocated.
402 entry_size
= rt2x00dev
->rx
->data_size
+ rt2x00dev
->rx
->desc_size
;
403 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
404 skb
= dev_alloc_skb(NET_IP_ALIGN
+ entry_size
);
408 skb_reserve(skb
, NET_IP_ALIGN
);
409 skb_put(skb
, entry_size
);
411 rt2x00dev
->rx
->entry
[i
].skb
= skb
;
417 rt2x00usb_uninitialize(rt2x00dev
);
421 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
423 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
425 struct data_ring
*ring
;
427 ring_for_each(rt2x00dev
, ring
)
428 rt2x00usb_free_urb(rt2x00dev
, ring
);
430 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
433 * USB driver handlers.
435 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
437 kfree(rt2x00dev
->rf
);
438 rt2x00dev
->rf
= NULL
;
440 kfree(rt2x00dev
->eeprom
);
441 rt2x00dev
->eeprom
= NULL
;
443 kfree(rt2x00dev
->csr_cache
);
444 rt2x00dev
->csr_cache
= NULL
;
447 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
449 rt2x00dev
->csr_cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
450 if (!rt2x00dev
->csr_cache
)
453 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
454 if (!rt2x00dev
->eeprom
)
457 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
464 ERROR_PROBE("Failed to allocate registers.\n");
466 rt2x00usb_free_reg(rt2x00dev
);
471 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
472 const struct usb_device_id
*id
)
474 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
475 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
476 struct ieee80211_hw
*hw
;
477 struct rt2x00_dev
*rt2x00dev
;
480 usb_dev
= usb_get_dev(usb_dev
);
482 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
484 ERROR_PROBE("Failed to allocate hardware.\n");
486 goto exit_put_device
;
489 usb_set_intfdata(usb_intf
, hw
);
491 rt2x00dev
= hw
->priv
;
492 rt2x00dev
->dev
= usb_intf
;
493 rt2x00dev
->ops
= ops
;
496 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
498 goto exit_free_device
;
500 retval
= rt2x00lib_probe_dev(rt2x00dev
);
507 rt2x00usb_free_reg(rt2x00dev
);
510 ieee80211_free_hw(hw
);
513 usb_put_dev(usb_dev
);
515 usb_set_intfdata(usb_intf
, NULL
);
519 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
521 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
523 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
524 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
527 * Free all allocated data.
529 rt2x00lib_remove_dev(rt2x00dev
);
530 rt2x00usb_free_reg(rt2x00dev
);
531 ieee80211_free_hw(hw
);
534 * Free the USB device data.
536 usb_set_intfdata(usb_intf
, NULL
);
537 usb_put_dev(interface_to_usbdev(usb_intf
));
539 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
542 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
544 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
545 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
548 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
552 rt2x00usb_free_reg(rt2x00dev
);
555 * Decrease usbdev refcount.
557 usb_put_dev(interface_to_usbdev(usb_intf
));
561 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
563 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
565 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
566 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
569 usb_get_dev(interface_to_usbdev(usb_intf
));
571 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
575 retval
= rt2x00lib_resume(rt2x00dev
);
582 rt2x00usb_free_reg(rt2x00dev
);
586 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
587 #endif /* CONFIG_PM */
590 * rt2x00pci module information.
592 MODULE_AUTHOR(DRV_PROJECT
);
593 MODULE_VERSION(DRV_VERSION
);
594 MODULE_DESCRIPTION("rt2x00 library");
595 MODULE_LICENSE("GPL");