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
;
223 struct rxdata_entry_desc desc
;
226 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
227 !test_and_clear_bit(ENTRY_OWNER_NIC
, &entry
->flags
))
231 * Check if the received data is simply too small
232 * to be actually valid, or if the urb is signaling
235 if (urb
->actual_length
< entry
->ring
->desc_size
|| urb
->status
)
238 memset(&desc
, 0x00, sizeof(desc
));
239 rt2x00dev
->ops
->lib
->fill_rxdone(entry
, &desc
);
242 * Allocate a new sk buffer to replace the current one.
243 * If allocation fails, we should drop the current frame
244 * so we can recycle the existing sk buffer for the new frame.
246 frame_size
= entry
->ring
->data_size
+ entry
->ring
->desc_size
;
247 skb
= dev_alloc_skb(frame_size
+ NET_IP_ALIGN
);
251 skb_reserve(skb
, NET_IP_ALIGN
);
252 skb_put(skb
, frame_size
);
255 * Trim the skb_buffer to only contain the valid
256 * frame data (so ignore the device's descriptor).
258 skb_trim(entry
->skb
, desc
.size
);
261 * Send the frame to rt2x00lib for further processing.
263 rt2x00lib_rxdone(entry
, entry
->skb
, &desc
);
266 * Replace current entry's skb with the newly allocated one,
267 * and reinitialize the urb.
270 urb
->transfer_buffer
= entry
->skb
->data
;
271 urb
->transfer_buffer_length
= entry
->skb
->len
;
274 if (test_bit(DEVICE_ENABLED_RADIO
, &ring
->rt2x00dev
->flags
)) {
275 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
276 usb_submit_urb(urb
, GFP_ATOMIC
);
279 rt2x00_ring_index_inc(ring
);
285 void rt2x00usb_enable_radio(struct rt2x00_dev
*rt2x00dev
)
287 struct usb_device
*usb_dev
=
288 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
289 struct data_ring
*ring
;
290 struct data_entry
*entry
;
294 * Initialize the TX rings
296 txringall_for_each(rt2x00dev
, ring
) {
297 for (i
= 0; i
< ring
->stats
.limit
; i
++)
298 ring
->entry
[i
].flags
= 0;
300 rt2x00_ring_index_clear(ring
);
304 * Initialize and start the RX ring.
306 rt2x00_ring_index_clear(rt2x00dev
->rx
);
308 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
309 entry
= &rt2x00dev
->rx
->entry
[i
];
311 usb_fill_bulk_urb(entry
->priv
, usb_dev
,
312 usb_rcvbulkpipe(usb_dev
, 1),
313 entry
->skb
->data
, entry
->skb
->len
,
314 rt2x00usb_interrupt_rxdone
, entry
);
316 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
317 usb_submit_urb(entry
->priv
, GFP_ATOMIC
);
320 EXPORT_SYMBOL_GPL(rt2x00usb_enable_radio
);
322 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
324 struct data_ring
*ring
;
327 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0x0000, 0x0000,
333 ring_for_each(rt2x00dev
, ring
) {
334 for (i
= 0; i
< ring
->stats
.limit
; i
++)
335 usb_kill_urb(ring
->entry
[i
].priv
);
338 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
341 * Device initialization handlers.
343 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
344 struct data_ring
*ring
)
351 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
352 ring
->entry
[i
].priv
= usb_alloc_urb(0, GFP_KERNEL
);
353 if (!ring
->entry
[i
].priv
)
360 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
361 struct data_ring
*ring
)
368 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
369 usb_kill_urb(ring
->entry
[i
].priv
);
370 usb_free_urb(ring
->entry
[i
].priv
);
371 if (ring
->entry
[i
].skb
)
372 kfree_skb(ring
->entry
[i
].skb
);
376 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
378 struct data_ring
*ring
;
380 unsigned int entry_size
;
387 ring_for_each(rt2x00dev
, ring
) {
388 status
= rt2x00usb_alloc_urb(rt2x00dev
, ring
);
394 * For the RX ring, skb's should be allocated.
396 entry_size
= rt2x00dev
->rx
->data_size
+ rt2x00dev
->rx
->desc_size
;
397 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
398 skb
= dev_alloc_skb(NET_IP_ALIGN
+ entry_size
);
402 skb_reserve(skb
, NET_IP_ALIGN
);
403 skb_put(skb
, entry_size
);
405 rt2x00dev
->rx
->entry
[i
].skb
= skb
;
411 rt2x00usb_uninitialize(rt2x00dev
);
415 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
417 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
419 struct data_ring
*ring
;
421 ring_for_each(rt2x00dev
, ring
)
422 rt2x00usb_free_urb(rt2x00dev
, ring
);
424 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
427 * USB driver handlers.
429 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
431 kfree(rt2x00dev
->rf
);
432 rt2x00dev
->rf
= NULL
;
434 kfree(rt2x00dev
->eeprom
);
435 rt2x00dev
->eeprom
= NULL
;
437 kfree(rt2x00dev
->csr_cache
);
438 rt2x00dev
->csr_cache
= NULL
;
441 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
443 rt2x00dev
->csr_cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
444 if (!rt2x00dev
->csr_cache
)
447 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
448 if (!rt2x00dev
->eeprom
)
451 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
458 ERROR_PROBE("Failed to allocate registers.\n");
460 rt2x00usb_free_reg(rt2x00dev
);
465 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
466 const struct usb_device_id
*id
)
468 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
469 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
470 struct ieee80211_hw
*hw
;
471 struct rt2x00_dev
*rt2x00dev
;
474 usb_dev
= usb_get_dev(usb_dev
);
476 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
478 ERROR_PROBE("Failed to allocate hardware.\n");
480 goto exit_put_device
;
483 usb_set_intfdata(usb_intf
, hw
);
485 rt2x00dev
= hw
->priv
;
486 rt2x00dev
->dev
= usb_intf
;
487 rt2x00dev
->ops
= ops
;
490 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
492 goto exit_free_device
;
494 retval
= rt2x00lib_probe_dev(rt2x00dev
);
501 rt2x00usb_free_reg(rt2x00dev
);
504 ieee80211_free_hw(hw
);
507 usb_put_dev(usb_dev
);
509 usb_set_intfdata(usb_intf
, NULL
);
513 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
515 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
517 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
518 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
521 * Free all allocated data.
523 rt2x00lib_remove_dev(rt2x00dev
);
524 rt2x00usb_free_reg(rt2x00dev
);
525 ieee80211_free_hw(hw
);
528 * Free the USB device data.
530 usb_set_intfdata(usb_intf
, NULL
);
531 usb_put_dev(interface_to_usbdev(usb_intf
));
533 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
536 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
538 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
539 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
542 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
546 rt2x00usb_free_reg(rt2x00dev
);
549 * Decrease usbdev refcount.
551 usb_put_dev(interface_to_usbdev(usb_intf
));
555 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
557 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
559 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
560 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
563 usb_get_dev(interface_to_usbdev(usb_intf
));
565 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
569 retval
= rt2x00lib_resume(rt2x00dev
);
576 rt2x00usb_free_reg(rt2x00dev
);
580 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
581 #endif /* CONFIG_PM */
584 * rt2x00pci module information.
586 MODULE_AUTHOR(DRV_PROJECT
);
587 MODULE_VERSION(DRV_VERSION
);
588 MODULE_DESCRIPTION("rt2x00 library");
589 MODULE_LICENSE("GPL");