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.
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
=
44 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
48 (requesttype
== USB_VENDOR_REQUEST_IN
) ?
49 usb_rcvctrlpipe(usb_dev
, 0) : usb_sndctrlpipe(usb_dev
, 0);
52 for (i
= 0; i
< REGISTER_BUSY_COUNT
; i
++) {
53 status
= usb_control_msg(usb_dev
, pipe
, request
, requesttype
,
54 value
, offset
, buffer
, buffer_length
,
61 * -ENODEV: Device has disappeared, no point continuing.
62 * All other errors: Try again.
64 else if (status
== -ENODEV
)
69 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
70 request
, offset
, status
);
74 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request
);
76 int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev
*rt2x00dev
,
77 const u8 request
, const u8 requesttype
,
78 const u16 offset
, void *buffer
,
79 const u16 buffer_length
, const int timeout
)
83 BUG_ON(!mutex_is_locked(&rt2x00dev
->usb_cache_mutex
));
86 * Check for Cache availability.
88 if (unlikely(!rt2x00dev
->csr_cache
|| buffer_length
> CSR_CACHE_SIZE
)) {
89 ERROR(rt2x00dev
, "CSR cache not available.\n");
93 if (requesttype
== USB_VENDOR_REQUEST_OUT
)
94 memcpy(rt2x00dev
->csr_cache
, buffer
, buffer_length
);
96 status
= rt2x00usb_vendor_request(rt2x00dev
, request
, requesttype
,
97 offset
, 0, rt2x00dev
->csr_cache
,
98 buffer_length
, timeout
);
100 if (!status
&& requesttype
== USB_VENDOR_REQUEST_IN
)
101 memcpy(buffer
, rt2x00dev
->csr_cache
, buffer_length
);
105 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock
);
107 int rt2x00usb_vendor_request_buff(struct rt2x00_dev
*rt2x00dev
,
108 const u8 request
, const u8 requesttype
,
109 const u16 offset
, void *buffer
,
110 const u16 buffer_length
, const int timeout
)
114 mutex_lock(&rt2x00dev
->usb_cache_mutex
);
116 status
= rt2x00usb_vendor_req_buff_lock(rt2x00dev
, request
,
117 requesttype
, offset
, buffer
,
118 buffer_length
, timeout
);
120 mutex_unlock(&rt2x00dev
->usb_cache_mutex
);
124 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff
);
129 static void rt2x00usb_interrupt_txdone(struct urb
*urb
)
131 struct data_entry
*entry
= (struct data_entry
*)urb
->context
;
132 struct data_ring
*ring
= entry
->ring
;
133 struct rt2x00_dev
*rt2x00dev
= ring
->rt2x00dev
;
134 __le32
*txd
= (__le32
*)entry
->skb
->data
;
138 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
139 !__test_and_clear_bit(ENTRY_OWNER_NIC
, &entry
->flags
))
142 rt2x00_desc_read(txd
, 0, &word
);
145 * Remove the descriptor data from the buffer.
147 skb_pull(entry
->skb
, ring
->desc_size
);
150 * Obtain the status about this packet.
152 tx_status
= !urb
->status
? TX_SUCCESS
: TX_FAIL_RETRY
;
154 rt2x00lib_txdone(entry
, tx_status
, 0);
157 * Make this entry available for reuse.
160 rt2x00_ring_index_done_inc(entry
->ring
);
163 * If the data ring was full before the txdone handler
164 * we must make sure the packet queue in the mac80211 stack
165 * is reenabled when the txdone handler has finished.
167 if (!rt2x00_ring_full(ring
))
168 ieee80211_wake_queue(rt2x00dev
->hw
,
169 entry
->tx_status
.control
.queue
);
172 int rt2x00usb_write_tx_data(struct rt2x00_dev
*rt2x00dev
,
173 struct data_ring
*ring
, struct sk_buff
*skb
,
174 struct ieee80211_tx_control
*control
)
176 struct usb_device
*usb_dev
=
177 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
178 struct data_entry
*entry
= rt2x00_get_data_entry(ring
);
179 struct skb_desc
*desc
;
182 if (rt2x00_ring_full(ring
))
185 if (test_bit(ENTRY_OWNER_NIC
, &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
, ring
->desc_size
);
197 memset(skb
->data
, 0, ring
->desc_size
);
200 * Fill in skb descriptor
202 desc
= get_skb_desc(skb
);
203 desc
->desc_len
= ring
->desc_size
;
204 desc
->data_len
= skb
->len
- ring
->desc_size
;
205 desc
->desc
= skb
->data
;
206 desc
->data
= skb
->data
+ ring
->desc_size
;
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_NIC
, &entry
->flags
);
223 usb_fill_bulk_urb(entry
->priv
, usb_dev
, usb_sndbulkpipe(usb_dev
, 1),
224 skb
->data
, length
, rt2x00usb_interrupt_txdone
, entry
);
225 usb_submit_urb(entry
->priv
, GFP_ATOMIC
);
227 rt2x00_ring_index_inc(ring
);
231 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data
);
236 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
238 struct data_entry
*entry
= (struct data_entry
*)urb
->context
;
239 struct data_ring
*ring
= entry
->ring
;
240 struct rt2x00_dev
*rt2x00dev
= ring
->rt2x00dev
;
242 struct ieee80211_hdr
*hdr
;
243 struct skb_desc
*skbdesc
;
244 struct rxdata_entry_desc desc
;
248 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
249 !test_and_clear_bit(ENTRY_OWNER_NIC
, &entry
->flags
))
253 * Check if the received data is simply too small
254 * to be actually valid, or if the urb is signaling
257 if (urb
->actual_length
< entry
->ring
->desc_size
|| urb
->status
)
260 memset(&desc
, 0, sizeof(desc
));
261 rt2x00dev
->ops
->lib
->fill_rxdone(entry
, &desc
);
264 * Allocate a new sk buffer to replace the current one.
265 * If allocation fails, we should drop the current frame
266 * so we can recycle the existing sk buffer for the new frame.
267 * As alignment we use 2 and not NET_IP_ALIGN because we need
268 * to be sure we have 2 bytes room in the head. (NET_IP_ALIGN
269 * can be 0 on some hardware). We use these 2 bytes for frame
270 * alignment later, we assume that the chance that
271 * header_size % 4 == 2 is bigger then header_size % 2 == 0
272 * and thus optimize alignment by reserving the 2 bytes in
275 frame_size
= entry
->ring
->data_size
+ entry
->ring
->desc_size
;
276 skb
= dev_alloc_skb(frame_size
+ 2);
281 skb_put(skb
, frame_size
);
284 * The data behind the ieee80211 header must be
285 * aligned on a 4 byte boundary.
286 * After that trim the entire buffer down to only
287 * contain the valid frame data excluding the device
290 hdr
= (struct ieee80211_hdr
*)entry
->skb
->data
;
292 ieee80211_get_hdrlen(le16_to_cpu(hdr
->frame_control
));
294 if (header_size
% 4 == 0) {
295 skb_push(entry
->skb
, 2);
296 memmove(entry
->skb
->data
, entry
->skb
->data
+ 2, skb
->len
- 2);
298 skb_trim(entry
->skb
, desc
.size
);
301 * Fill in skb descriptor
303 skbdesc
= get_skb_desc(entry
->skb
);
304 skbdesc
->desc_len
= entry
->ring
->desc_size
;
305 skbdesc
->data_len
= entry
->skb
->len
;
306 skbdesc
->desc
= entry
->skb
->data
- skbdesc
->desc_len
;
307 skbdesc
->data
= entry
->skb
->data
;
308 skbdesc
->ring
= ring
;
309 skbdesc
->entry
= entry
;
312 * Send the frame to rt2x00lib for further processing.
314 rt2x00lib_rxdone(entry
, entry
->skb
, &desc
);
317 * Replace current entry's skb with the newly allocated one,
318 * and reinitialize the urb.
321 urb
->transfer_buffer
= entry
->skb
->data
;
322 urb
->transfer_buffer_length
= entry
->skb
->len
;
325 if (test_bit(DEVICE_ENABLED_RADIO
, &ring
->rt2x00dev
->flags
)) {
326 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
327 usb_submit_urb(urb
, GFP_ATOMIC
);
330 rt2x00_ring_index_inc(ring
);
336 void rt2x00usb_enable_radio(struct rt2x00_dev
*rt2x00dev
)
338 struct usb_device
*usb_dev
=
339 interface_to_usbdev(rt2x00dev_usb(rt2x00dev
));
340 struct data_ring
*ring
;
341 struct data_entry
*entry
;
345 * Initialize the TX rings
347 txringall_for_each(rt2x00dev
, ring
) {
348 for (i
= 0; i
< ring
->stats
.limit
; i
++)
349 ring
->entry
[i
].flags
= 0;
351 rt2x00_ring_index_clear(ring
);
355 * Initialize and start the RX ring.
357 rt2x00_ring_index_clear(rt2x00dev
->rx
);
359 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
360 entry
= &rt2x00dev
->rx
->entry
[i
];
362 usb_fill_bulk_urb(entry
->priv
, usb_dev
,
363 usb_rcvbulkpipe(usb_dev
, 1),
364 entry
->skb
->data
, entry
->skb
->len
,
365 rt2x00usb_interrupt_rxdone
, entry
);
367 __set_bit(ENTRY_OWNER_NIC
, &entry
->flags
);
368 usb_submit_urb(entry
->priv
, GFP_ATOMIC
);
371 EXPORT_SYMBOL_GPL(rt2x00usb_enable_radio
);
373 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
375 struct data_ring
*ring
;
378 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0x0000, 0x0000,
384 ring_for_each(rt2x00dev
, ring
) {
385 for (i
= 0; i
< ring
->stats
.limit
; i
++)
386 usb_kill_urb(ring
->entry
[i
].priv
);
389 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
392 * Device initialization handlers.
394 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
395 struct data_ring
*ring
)
402 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
403 ring
->entry
[i
].priv
= usb_alloc_urb(0, GFP_KERNEL
);
404 if (!ring
->entry
[i
].priv
)
411 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
412 struct data_ring
*ring
)
419 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
420 usb_kill_urb(ring
->entry
[i
].priv
);
421 usb_free_urb(ring
->entry
[i
].priv
);
422 if (ring
->entry
[i
].skb
)
423 kfree_skb(ring
->entry
[i
].skb
);
427 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
429 struct data_ring
*ring
;
431 unsigned int entry_size
;
438 ring_for_each(rt2x00dev
, ring
) {
439 status
= rt2x00usb_alloc_urb(rt2x00dev
, ring
);
445 * For the RX ring, skb's should be allocated.
447 entry_size
= rt2x00dev
->rx
->data_size
+ rt2x00dev
->rx
->desc_size
;
448 for (i
= 0; i
< rt2x00dev
->rx
->stats
.limit
; i
++) {
449 skb
= dev_alloc_skb(NET_IP_ALIGN
+ entry_size
);
453 skb_reserve(skb
, NET_IP_ALIGN
);
454 skb_put(skb
, entry_size
);
456 rt2x00dev
->rx
->entry
[i
].skb
= skb
;
462 rt2x00usb_uninitialize(rt2x00dev
);
466 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
468 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
470 struct data_ring
*ring
;
472 ring_for_each(rt2x00dev
, ring
)
473 rt2x00usb_free_urb(rt2x00dev
, ring
);
475 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
478 * USB driver handlers.
480 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
482 kfree(rt2x00dev
->rf
);
483 rt2x00dev
->rf
= NULL
;
485 kfree(rt2x00dev
->eeprom
);
486 rt2x00dev
->eeprom
= NULL
;
488 kfree(rt2x00dev
->csr_cache
);
489 rt2x00dev
->csr_cache
= NULL
;
492 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
494 rt2x00dev
->csr_cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
495 if (!rt2x00dev
->csr_cache
)
498 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
499 if (!rt2x00dev
->eeprom
)
502 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
509 ERROR_PROBE("Failed to allocate registers.\n");
511 rt2x00usb_free_reg(rt2x00dev
);
516 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
517 const struct usb_device_id
*id
)
519 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
520 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
521 struct ieee80211_hw
*hw
;
522 struct rt2x00_dev
*rt2x00dev
;
525 usb_dev
= usb_get_dev(usb_dev
);
527 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
529 ERROR_PROBE("Failed to allocate hardware.\n");
531 goto exit_put_device
;
534 usb_set_intfdata(usb_intf
, hw
);
536 rt2x00dev
= hw
->priv
;
537 rt2x00dev
->dev
= usb_intf
;
538 rt2x00dev
->ops
= ops
;
540 mutex_init(&rt2x00dev
->usb_cache_mutex
);
542 rt2x00dev
->usb_maxpacket
=
543 usb_maxpacket(usb_dev
, usb_sndbulkpipe(usb_dev
, 1), 1);
544 if (!rt2x00dev
->usb_maxpacket
)
545 rt2x00dev
->usb_maxpacket
= 1;
547 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
549 goto exit_free_device
;
551 retval
= rt2x00lib_probe_dev(rt2x00dev
);
558 rt2x00usb_free_reg(rt2x00dev
);
561 ieee80211_free_hw(hw
);
564 usb_put_dev(usb_dev
);
566 usb_set_intfdata(usb_intf
, NULL
);
570 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
572 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
574 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
575 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
578 * Free all allocated data.
580 rt2x00lib_remove_dev(rt2x00dev
);
581 rt2x00usb_free_reg(rt2x00dev
);
582 ieee80211_free_hw(hw
);
585 * Free the USB device data.
587 usb_set_intfdata(usb_intf
, NULL
);
588 usb_put_dev(interface_to_usbdev(usb_intf
));
590 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
593 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
595 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
596 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
599 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
603 rt2x00usb_free_reg(rt2x00dev
);
606 * Decrease usbdev refcount.
608 usb_put_dev(interface_to_usbdev(usb_intf
));
612 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
614 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
616 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
617 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
620 usb_get_dev(interface_to_usbdev(usb_intf
));
622 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
626 retval
= rt2x00lib_resume(rt2x00dev
);
633 rt2x00usb_free_reg(rt2x00dev
);
637 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
638 #endif /* CONFIG_PM */
641 * rt2x00pci module information.
643 MODULE_AUTHOR(DRV_PROJECT
);
644 MODULE_VERSION(DRV_VERSION
);
645 MODULE_DESCRIPTION("rt2x00 library");
646 MODULE_LICENSE("GPL");