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
= to_usb_device_intf(rt2x00dev
->dev
);
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
);
125 int rt2x00usb_vendor_request_large_buff(struct rt2x00_dev
*rt2x00dev
,
126 const u8 request
, const u8 requesttype
,
127 const u16 offset
, const void *buffer
,
128 const u16 buffer_length
,
135 mutex_lock(&rt2x00dev
->usb_cache_mutex
);
140 while (len
&& !status
) {
141 bsize
= min_t(u16
, CSR_CACHE_SIZE
, len
);
142 status
= rt2x00usb_vendor_req_buff_lock(rt2x00dev
, request
,
143 requesttype
, off
, tb
,
151 mutex_unlock(&rt2x00dev
->usb_cache_mutex
);
155 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_large_buff
);
160 static void rt2x00usb_interrupt_txdone(struct urb
*urb
)
162 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
163 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
164 struct txdone_entry_desc txdesc
;
166 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
167 !test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
171 * Remove the descriptor data from the buffer.
173 skb_pull(entry
->skb
, entry
->queue
->desc_size
);
176 * Obtain the status about this packet.
177 * Note that when the status is 0 it does not mean the
178 * frame was send out correctly. It only means the frame
179 * was succesfully pushed to the hardware, we have no
180 * way to determine the transmission status right now.
181 * (Only indirectly by looking at the failed TX counters
186 __set_bit(TXDONE_UNKNOWN
, &txdesc
.flags
);
188 __set_bit(TXDONE_FAILURE
, &txdesc
.flags
);
191 rt2x00lib_txdone(entry
, &txdesc
);
194 int rt2x00usb_write_tx_data(struct queue_entry
*entry
)
196 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
197 struct usb_device
*usb_dev
= to_usb_device_intf(rt2x00dev
->dev
);
198 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
199 struct skb_frame_desc
*skbdesc
;
203 * Add the descriptor in front of the skb.
205 skb_push(entry
->skb
, entry
->queue
->desc_size
);
206 memset(entry
->skb
->data
, 0, entry
->queue
->desc_size
);
209 * Fill in skb descriptor
211 skbdesc
= get_skb_frame_desc(entry
->skb
);
212 skbdesc
->desc
= entry
->skb
->data
;
213 skbdesc
->desc_len
= entry
->queue
->desc_size
;
216 * USB devices cannot blindly pass the skb->len as the
217 * length of the data to usb_fill_bulk_urb. Pass the skb
218 * to the driver to determine what the length should be.
220 length
= rt2x00dev
->ops
->lib
->get_tx_data_len(rt2x00dev
, entry
->skb
);
222 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
,
223 usb_sndbulkpipe(usb_dev
, 1),
224 entry
->skb
->data
, length
,
225 rt2x00usb_interrupt_txdone
, entry
);
229 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data
);
231 static inline void rt2x00usb_kick_tx_entry(struct queue_entry
*entry
)
233 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
235 if (__test_and_clear_bit(ENTRY_DATA_PENDING
, &entry
->flags
))
236 usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
239 void rt2x00usb_kick_tx_queue(struct rt2x00_dev
*rt2x00dev
,
240 const enum data_queue_qid qid
)
242 struct data_queue
*queue
= rt2x00queue_get_queue(rt2x00dev
, qid
);
243 unsigned long irqflags
;
245 unsigned int index_done
;
249 * Only protect the range we are going to loop over,
250 * if during our loop a extra entry is set to pending
251 * it should not be kicked during this run, since it
252 * is part of another TX operation.
254 spin_lock_irqsave(&queue
->lock
, irqflags
);
255 index
= queue
->index
[Q_INDEX
];
256 index_done
= queue
->index
[Q_INDEX_DONE
];
257 spin_unlock_irqrestore(&queue
->lock
, irqflags
);
260 * Start from the TX done pointer, this guarentees that we will
261 * send out all frames in the correct order.
263 if (index_done
< index
) {
264 for (i
= index_done
; i
< index
; i
++)
265 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
267 for (i
= index_done
; i
< queue
->limit
; i
++)
268 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
270 for (i
= 0; i
< index
; i
++)
271 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
274 EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue
);
279 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
281 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
282 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
283 struct skb_frame_desc
*skbdesc
= get_skb_frame_desc(entry
->skb
);
286 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
287 !test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
291 * Check if the received data is simply too small
292 * to be actually valid, or if the urb is signaling
295 if (urb
->actual_length
< entry
->queue
->desc_size
|| urb
->status
) {
296 __set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
297 usb_submit_urb(urb
, GFP_ATOMIC
);
302 * Fill in desc fields of the skb descriptor
305 skbdesc
->desc_len
= entry
->queue
->desc_size
;
308 * Send the frame to rt2x00lib for further processing.
310 rt2x00lib_rxdone(rt2x00dev
, entry
);
316 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
318 struct queue_entry_priv_usb
*entry_priv
;
319 struct queue_entry_priv_usb_bcn
*bcn_priv
;
320 struct data_queue
*queue
;
323 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0, 0,
329 queue_for_each(rt2x00dev
, queue
) {
330 for (i
= 0; i
< queue
->limit
; i
++) {
331 entry_priv
= queue
->entries
[i
].priv_data
;
332 usb_kill_urb(entry_priv
->urb
);
337 * Kill guardian urb (if required by driver).
339 if (!test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
342 for (i
= 0; i
< rt2x00dev
->bcn
->limit
; i
++) {
343 bcn_priv
= rt2x00dev
->bcn
->entries
[i
].priv_data
;
344 if (bcn_priv
->guardian_urb
)
345 usb_kill_urb(bcn_priv
->guardian_urb
);
348 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
351 * Device initialization handlers.
353 void rt2x00usb_init_rxentry(struct rt2x00_dev
*rt2x00dev
,
354 struct queue_entry
*entry
)
356 struct usb_device
*usb_dev
= to_usb_device_intf(rt2x00dev
->dev
);
357 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
359 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
,
360 usb_rcvbulkpipe(usb_dev
, 1),
361 entry
->skb
->data
, entry
->skb
->len
,
362 rt2x00usb_interrupt_rxdone
, entry
);
364 __set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
365 usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
367 EXPORT_SYMBOL_GPL(rt2x00usb_init_rxentry
);
369 void rt2x00usb_init_txentry(struct rt2x00_dev
*rt2x00dev
,
370 struct queue_entry
*entry
)
374 EXPORT_SYMBOL_GPL(rt2x00usb_init_txentry
);
376 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
377 struct data_queue
*queue
)
379 struct queue_entry_priv_usb
*entry_priv
;
380 struct queue_entry_priv_usb_bcn
*bcn_priv
;
383 for (i
= 0; i
< queue
->limit
; i
++) {
384 entry_priv
= queue
->entries
[i
].priv_data
;
385 entry_priv
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
386 if (!entry_priv
->urb
)
391 * If this is not the beacon queue or
392 * no guardian byte was required for the beacon,
395 if (rt2x00dev
->bcn
!= queue
||
396 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
399 for (i
= 0; i
< queue
->limit
; i
++) {
400 bcn_priv
= queue
->entries
[i
].priv_data
;
401 bcn_priv
->guardian_urb
= usb_alloc_urb(0, GFP_KERNEL
);
402 if (!bcn_priv
->guardian_urb
)
409 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
410 struct data_queue
*queue
)
412 struct queue_entry_priv_usb
*entry_priv
;
413 struct queue_entry_priv_usb_bcn
*bcn_priv
;
419 for (i
= 0; i
< queue
->limit
; i
++) {
420 entry_priv
= queue
->entries
[i
].priv_data
;
421 usb_kill_urb(entry_priv
->urb
);
422 usb_free_urb(entry_priv
->urb
);
426 * If this is not the beacon queue or
427 * no guardian byte was required for the beacon,
430 if (rt2x00dev
->bcn
!= queue
||
431 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
434 for (i
= 0; i
< queue
->limit
; i
++) {
435 bcn_priv
= queue
->entries
[i
].priv_data
;
436 usb_kill_urb(bcn_priv
->guardian_urb
);
437 usb_free_urb(bcn_priv
->guardian_urb
);
441 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
443 struct data_queue
*queue
;
449 queue_for_each(rt2x00dev
, queue
) {
450 status
= rt2x00usb_alloc_urb(rt2x00dev
, queue
);
458 rt2x00usb_uninitialize(rt2x00dev
);
462 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
464 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
466 struct data_queue
*queue
;
468 queue_for_each(rt2x00dev
, queue
)
469 rt2x00usb_free_urb(rt2x00dev
, queue
);
471 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
474 * USB driver handlers.
476 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
478 kfree(rt2x00dev
->rf
);
479 rt2x00dev
->rf
= NULL
;
481 kfree(rt2x00dev
->eeprom
);
482 rt2x00dev
->eeprom
= NULL
;
484 kfree(rt2x00dev
->csr
.cache
);
485 rt2x00dev
->csr
.cache
= NULL
;
488 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
490 rt2x00dev
->csr
.cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
491 if (!rt2x00dev
->csr
.cache
)
494 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
495 if (!rt2x00dev
->eeprom
)
498 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
505 ERROR_PROBE("Failed to allocate registers.\n");
507 rt2x00usb_free_reg(rt2x00dev
);
512 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
513 const struct usb_device_id
*id
)
515 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
516 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
517 struct ieee80211_hw
*hw
;
518 struct rt2x00_dev
*rt2x00dev
;
521 usb_dev
= usb_get_dev(usb_dev
);
523 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
525 ERROR_PROBE("Failed to allocate hardware.\n");
527 goto exit_put_device
;
530 usb_set_intfdata(usb_intf
, hw
);
532 rt2x00dev
= hw
->priv
;
533 rt2x00dev
->dev
= &usb_intf
->dev
;
534 rt2x00dev
->ops
= ops
;
536 mutex_init(&rt2x00dev
->usb_cache_mutex
);
538 rt2x00dev
->usb_maxpacket
=
539 usb_maxpacket(usb_dev
, usb_sndbulkpipe(usb_dev
, 1), 1);
540 if (!rt2x00dev
->usb_maxpacket
)
541 rt2x00dev
->usb_maxpacket
= 1;
543 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
545 goto exit_free_device
;
547 retval
= rt2x00lib_probe_dev(rt2x00dev
);
554 rt2x00usb_free_reg(rt2x00dev
);
557 ieee80211_free_hw(hw
);
560 usb_put_dev(usb_dev
);
562 usb_set_intfdata(usb_intf
, NULL
);
566 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
568 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
570 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
571 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
574 * Free all allocated data.
576 rt2x00lib_remove_dev(rt2x00dev
);
577 rt2x00usb_free_reg(rt2x00dev
);
578 ieee80211_free_hw(hw
);
581 * Free the USB device data.
583 usb_set_intfdata(usb_intf
, NULL
);
584 usb_put_dev(interface_to_usbdev(usb_intf
));
586 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
589 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
591 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
592 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
595 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
599 rt2x00usb_free_reg(rt2x00dev
);
602 * Decrease usbdev refcount.
604 usb_put_dev(interface_to_usbdev(usb_intf
));
608 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
610 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
612 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
613 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
616 usb_get_dev(interface_to_usbdev(usb_intf
));
618 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
622 retval
= rt2x00lib_resume(rt2x00dev
);
629 rt2x00usb_free_reg(rt2x00dev
);
633 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
634 #endif /* CONFIG_PM */
637 * rt2x00usb module information.
639 MODULE_AUTHOR(DRV_PROJECT
);
640 MODULE_VERSION(DRV_VERSION
);
641 MODULE_DESCRIPTION("rt2x00 usb library");
642 MODULE_LICENSE("GPL");