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 * -ENODEV: Device has disappeared, no point continuing.
65 * All other errors: Try again.
67 else if (status
== -ENODEV
)
72 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
73 request
, offset
, status
);
77 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request
);
79 int rt2x00usb_vendor_request_buff(const 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
)
87 * Check for Cache availability.
89 if (unlikely(!rt2x00dev
->csr_cache
|| buffer_length
> CSR_CACHE_SIZE
)) {
90 ERROR(rt2x00dev
, "CSR cache not available.\n");
94 if (requesttype
== USB_VENDOR_REQUEST_OUT
)
95 memcpy(rt2x00dev
->csr_cache
, buffer
, buffer_length
);
97 status
= rt2x00usb_vendor_request(rt2x00dev
, request
, requesttype
,
98 offset
, 0, rt2x00dev
->csr_cache
,
99 buffer_length
, timeout
);
101 if (!status
&& requesttype
== USB_VENDOR_REQUEST_IN
)
102 memcpy(buffer
, rt2x00dev
->csr_cache
, buffer_length
);
106 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff
);
111 static void rt2x00usb_interrupt_txdone(struct urb
*urb
)
113 struct data_entry
*entry
= (struct data_entry
*)urb
->context
;
114 struct data_ring
*ring
= entry
->ring
;
115 struct rt2x00_dev
*rt2x00dev
= ring
->rt2x00dev
;
116 struct data_desc
*txd
= (struct data_desc
*)entry
->skb
->data
;
120 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
121 !__test_and_clear_bit(ENTRY_OWNER_NIC
, &entry
->flags
))
124 rt2x00_desc_read(txd
, 0, &word
);
127 * Remove the descriptor data from the buffer.
129 skb_pull(entry
->skb
, ring
->desc_size
);
132 * Obtain the status about this packet.
134 tx_status
= !urb
->status
? TX_SUCCESS
: TX_FAIL_RETRY
;
136 rt2x00lib_txdone(entry
, tx_status
, 0);
139 * Make this entry available for reuse.
142 rt2x00_ring_index_done_inc(entry
->ring
);
145 * If the data ring was full before the txdone handler
146 * we must make sure the packet queue in the mac80211 stack
147 * is reenabled when the txdone handler has finished.
149 if (!rt2x00_ring_full(ring
))
150 ieee80211_wake_queue(rt2x00dev
->hw
,
151 entry
->tx_status
.control
.queue
);
154 int rt2x00usb_write_tx_data(struct rt2x00_dev
*rt2x00dev
,
155 struct data_ring
*ring
, struct sk_buff
*skb
,
156 struct ieee80211_tx_control
*control
)
158 struct usb_device
*usb_dev
=
159 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
160 struct ieee80211_hdr
*ieee80211hdr
= (struct ieee80211_hdr
*)skb
->data
;
161 struct data_entry
*entry
= rt2x00_get_data_entry(ring
);
162 u32 length
= skb
->len
;
164 if (rt2x00_ring_full(ring
)) {
165 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
169 if (test_bit(ENTRY_OWNER_NIC
, &entry
->flags
)) {
171 "Arrived at non-free entry in the non-full queue %d.\n"
172 "Please file bug report to %s.\n",
173 control
->queue
, DRV_PROJECT
);
174 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
179 * Add the descriptor in front of the skb.
181 skb_push(skb
, rt2x00dev
->hw
->extra_tx_headroom
);
182 memset(skb
->data
, 0x00, rt2x00dev
->hw
->extra_tx_headroom
);
184 rt2x00lib_write_tx_desc(rt2x00dev
, (struct data_desc
*)skb
->data
,
185 ieee80211hdr
, length
, control
);
186 memcpy(&entry
->tx_status
.control
, control
, sizeof(*control
));
190 * Length passed to usb_fill_urb cannot be an odd number,
191 * so add 1 byte to make it even.
193 length
+= rt2x00dev
->hw
->extra_tx_headroom
;
197 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
198 usb_fill_bulk_urb(entry
->priv
, usb_dev
,
199 usb_sndbulkpipe(usb_dev
, 1),
200 skb
->data
, length
, rt2x00usb_interrupt_txdone
, entry
);
201 usb_submit_urb(entry
->priv
, GFP_ATOMIC
);
203 rt2x00_ring_index_inc(ring
);
205 if (rt2x00_ring_full(ring
))
206 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
210 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data
);
215 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
217 struct data_entry
*entry
= (struct data_entry
*)urb
->context
;
218 struct data_ring
*ring
= entry
->ring
;
219 struct rt2x00_dev
*rt2x00dev
= ring
->rt2x00dev
;
221 struct rxdata_entry_desc desc
;
224 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
225 !test_and_clear_bit(ENTRY_OWNER_NIC
, &entry
->flags
))
229 * Check if the received data is simply too small
230 * to be actually valid, or if the urb is signaling
233 if (urb
->actual_length
< entry
->ring
->desc_size
|| urb
->status
)
236 memset(&desc
, 0x00, sizeof(desc
));
237 rt2x00dev
->ops
->lib
->fill_rxdone(entry
, &desc
);
240 * Allocate a new sk buffer to replace the current one.
241 * If allocation fails, we should drop the current frame
242 * so we can recycle the existing sk buffer for the new frame.
244 frame_size
= entry
->ring
->data_size
+ entry
->ring
->desc_size
;
245 skb
= dev_alloc_skb(frame_size
+ NET_IP_ALIGN
);
249 skb_reserve(skb
, NET_IP_ALIGN
);
250 skb_put(skb
, frame_size
);
253 * Trim the skb_buffer to only contain the valid
254 * frame data (so ignore the device's descriptor).
256 skb_trim(entry
->skb
, desc
.size
);
259 * Send the frame to rt2x00lib for further processing.
261 rt2x00lib_rxdone(entry
, entry
->skb
, &desc
);
264 * Replace current entry's skb with the newly allocated one,
265 * and reinitialize the urb.
268 urb
->transfer_buffer
= entry
->skb
->data
;
269 urb
->transfer_buffer_length
= entry
->skb
->len
;
272 if (test_bit(DEVICE_ENABLED_RADIO
, &ring
->rt2x00dev
->flags
)) {
273 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
274 usb_submit_urb(urb
, GFP_ATOMIC
);
277 rt2x00_ring_index_inc(ring
);
283 void rt2x00usb_enable_radio(struct rt2x00_dev
*rt2x00dev
)
285 struct usb_device
*usb_dev
=
286 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
287 struct data_ring
*ring
;
288 struct data_entry
*entry
;
292 * Initialize the TX rings
294 txringall_for_each(rt2x00dev
, ring
) {
295 for (i
= 0; i
< ring
->stats
.limit
; i
++)
296 ring
->entry
[i
].flags
= 0;
298 rt2x00_ring_index_clear(ring
);
302 * Initialize and start the RX ring.
304 rt2x00_ring_index_clear(rt2x00dev
->rx
);
306 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
307 entry
= &rt2x00dev
->rx
->entry
[i
];
309 usb_fill_bulk_urb(entry
->priv
, usb_dev
,
310 usb_rcvbulkpipe(usb_dev
, 1),
311 entry
->skb
->data
, entry
->skb
->len
,
312 rt2x00usb_interrupt_rxdone
, entry
);
314 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
315 usb_submit_urb(entry
->priv
, GFP_ATOMIC
);
318 EXPORT_SYMBOL_GPL(rt2x00usb_enable_radio
);
320 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
322 struct data_ring
*ring
;
325 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0x0000, 0x0000,
331 ring_for_each(rt2x00dev
, ring
) {
332 for (i
= 0; i
< ring
->stats
.limit
; i
++)
333 usb_kill_urb(ring
->entry
[i
].priv
);
336 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
339 * Device initialization handlers.
341 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
342 struct data_ring
*ring
)
349 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
350 ring
->entry
[i
].priv
= usb_alloc_urb(0, GFP_KERNEL
);
351 if (!ring
->entry
[i
].priv
)
358 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
359 struct data_ring
*ring
)
366 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
367 usb_kill_urb(ring
->entry
[i
].priv
);
368 usb_free_urb(ring
->entry
[i
].priv
);
369 if (ring
->entry
[i
].skb
)
370 kfree_skb(ring
->entry
[i
].skb
);
374 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
376 struct data_ring
*ring
;
378 unsigned int entry_size
;
385 ring_for_each(rt2x00dev
, ring
) {
386 status
= rt2x00usb_alloc_urb(rt2x00dev
, ring
);
392 * For the RX ring, skb's should be allocated.
394 entry_size
= rt2x00dev
->rx
->data_size
+ rt2x00dev
->rx
->desc_size
;
395 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
396 skb
= dev_alloc_skb(NET_IP_ALIGN
+ entry_size
);
400 skb_reserve(skb
, NET_IP_ALIGN
);
401 skb_put(skb
, entry_size
);
403 rt2x00dev
->rx
->entry
[i
].skb
= skb
;
409 rt2x00usb_uninitialize(rt2x00dev
);
413 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
415 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
417 struct data_ring
*ring
;
419 ring_for_each(rt2x00dev
, ring
)
420 rt2x00usb_free_urb(rt2x00dev
, ring
);
422 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
425 * USB driver handlers.
427 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
429 kfree(rt2x00dev
->rf
);
430 rt2x00dev
->rf
= NULL
;
432 kfree(rt2x00dev
->eeprom
);
433 rt2x00dev
->eeprom
= NULL
;
435 kfree(rt2x00dev
->csr_cache
);
436 rt2x00dev
->csr_cache
= NULL
;
439 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
441 rt2x00dev
->csr_cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
442 if (!rt2x00dev
->csr_cache
)
445 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
446 if (!rt2x00dev
->eeprom
)
449 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
456 ERROR_PROBE("Failed to allocate registers.\n");
458 rt2x00usb_free_reg(rt2x00dev
);
463 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
464 const struct usb_device_id
*id
)
466 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
467 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
468 struct ieee80211_hw
*hw
;
469 struct rt2x00_dev
*rt2x00dev
;
472 usb_dev
= usb_get_dev(usb_dev
);
474 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
476 ERROR_PROBE("Failed to allocate hardware.\n");
478 goto exit_put_device
;
481 usb_set_intfdata(usb_intf
, hw
);
483 rt2x00dev
= hw
->priv
;
484 rt2x00dev
->dev
= usb_intf
;
485 rt2x00dev
->ops
= ops
;
488 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
490 goto exit_free_device
;
492 retval
= rt2x00lib_probe_dev(rt2x00dev
);
499 rt2x00usb_free_reg(rt2x00dev
);
502 ieee80211_free_hw(hw
);
505 usb_put_dev(usb_dev
);
507 usb_set_intfdata(usb_intf
, NULL
);
511 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
513 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
515 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
516 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
519 * Free all allocated data.
521 rt2x00lib_remove_dev(rt2x00dev
);
522 rt2x00usb_free_reg(rt2x00dev
);
523 ieee80211_free_hw(hw
);
526 * Free the USB device data.
528 usb_set_intfdata(usb_intf
, NULL
);
529 usb_put_dev(interface_to_usbdev(usb_intf
));
531 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
534 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
536 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
537 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
540 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
544 rt2x00usb_free_reg(rt2x00dev
);
547 * Decrease usbdev refcount.
549 usb_put_dev(interface_to_usbdev(usb_intf
));
553 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
555 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
557 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
558 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
561 usb_get_dev(interface_to_usbdev(usb_intf
));
563 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
567 retval
= rt2x00lib_resume(rt2x00dev
);
574 rt2x00usb_free_reg(rt2x00dev
);
578 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
579 #endif /* CONFIG_PM */
582 * rt2x00pci module information.
584 MODULE_AUTHOR(DRV_PROJECT
);
585 MODULE_VERSION(DRV_VERSION
);
586 MODULE_DESCRIPTION("rt2x00 library");
587 MODULE_LICENSE("GPL");