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
=
44 interface_to_usbdev(to_usb_interface(rt2x00dev
->dev
));
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 queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
132 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
133 struct txdone_entry_desc txdesc
;
134 enum data_queue_qid qid
= skb_get_queue_mapping(entry
->skb
);
136 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
137 !__test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
141 * Remove the descriptor data from the buffer.
143 skb_pull(entry
->skb
, entry
->queue
->desc_size
);
146 * Obtain the status about this packet.
147 * Note that when the status is 0 it does not mean the
148 * frame was send out correctly. It only means the frame
149 * was succesfully pushed to the hardware, we have no
150 * way to determine the transmission status right now.
151 * (Only indirectly by looking at the failed TX counters
155 __set_bit(TXDONE_UNKNOWN
, &txdesc
.flags
);
157 __set_bit(TXDONE_FAILURE
, &txdesc
.flags
);
160 rt2x00lib_txdone(entry
, &txdesc
);
163 * Make this entry available for reuse.
166 rt2x00queue_index_inc(entry
->queue
, Q_INDEX_DONE
);
169 * If the data queue was below the threshold before the txdone
170 * handler we must make sure the packet queue in the mac80211 stack
171 * is reenabled when the txdone handler has finished.
173 if (!rt2x00queue_threshold(entry
->queue
))
174 ieee80211_wake_queue(rt2x00dev
->hw
, qid
);
177 int rt2x00usb_write_tx_data(struct queue_entry
*entry
)
179 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
180 struct usb_device
*usb_dev
=
181 interface_to_usbdev(to_usb_interface(rt2x00dev
->dev
));
182 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
183 struct skb_frame_desc
*skbdesc
;
187 * Add the descriptor in front of the skb.
189 skb_push(entry
->skb
, entry
->queue
->desc_size
);
190 memset(entry
->skb
->data
, 0, entry
->queue
->desc_size
);
193 * Fill in skb descriptor
195 skbdesc
= get_skb_frame_desc(entry
->skb
);
196 memset(skbdesc
, 0, sizeof(*skbdesc
));
197 skbdesc
->desc
= entry
->skb
->data
;
198 skbdesc
->desc_len
= entry
->queue
->desc_size
;
199 skbdesc
->entry
= entry
;
202 * USB devices cannot blindly pass the skb->len as the
203 * length of the data to usb_fill_bulk_urb. Pass the skb
204 * to the driver to determine what the length should be.
206 length
= rt2x00dev
->ops
->lib
->get_tx_data_len(rt2x00dev
, entry
->skb
);
208 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
,
209 usb_sndbulkpipe(usb_dev
, 1),
210 entry
->skb
->data
, length
,
211 rt2x00usb_interrupt_txdone
, entry
);
215 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data
);
217 static inline void rt2x00usb_kick_tx_entry(struct queue_entry
*entry
)
219 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
221 if (__test_and_clear_bit(ENTRY_DATA_PENDING
, &entry
->flags
))
222 usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
225 void rt2x00usb_kick_tx_queue(struct rt2x00_dev
*rt2x00dev
,
226 const enum data_queue_qid qid
)
228 struct data_queue
*queue
= rt2x00queue_get_queue(rt2x00dev
, qid
);
229 unsigned long irqflags
;
231 unsigned int index_done
;
235 * Only protect the range we are going to loop over,
236 * if during our loop a extra entry is set to pending
237 * it should not be kicked during this run, since it
238 * is part of another TX operation.
240 spin_lock_irqsave(&queue
->lock
, irqflags
);
241 index
= queue
->index
[Q_INDEX
];
242 index_done
= queue
->index
[Q_INDEX_DONE
];
243 spin_unlock_irqrestore(&queue
->lock
, irqflags
);
246 * Start from the TX done pointer, this guarentees that we will
247 * send out all frames in the correct order.
249 if (index_done
< index
) {
250 for (i
= index_done
; i
< index
; i
++)
251 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
253 for (i
= index_done
; i
< queue
->limit
; i
++)
254 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
256 for (i
= 0; i
< index
; i
++)
257 rt2x00usb_kick_tx_entry(&queue
->entries
[i
]);
260 EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue
);
265 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
267 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
268 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
270 struct skb_frame_desc
*skbdesc
;
271 struct rxdone_entry_desc rxdesc
;
274 if (!test_bit(DEVICE_ENABLED_RADIO
, &rt2x00dev
->flags
) ||
275 !test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
279 * Check if the received data is simply too small
280 * to be actually valid, or if the urb is signaling
283 if (urb
->actual_length
< entry
->queue
->desc_size
|| urb
->status
)
287 * Fill in skb descriptor
289 skbdesc
= get_skb_frame_desc(entry
->skb
);
290 memset(skbdesc
, 0, sizeof(*skbdesc
));
291 skbdesc
->entry
= entry
;
293 skbdesc
->desc_len
= entry
->queue
->desc_size
;
295 memset(&rxdesc
, 0, sizeof(rxdesc
));
296 rt2x00dev
->ops
->lib
->fill_rxdone(entry
, &rxdesc
);
299 * Allocate a new sk buffer to replace the current one.
300 * If allocation fails, we should drop the current frame
301 * so we can recycle the existing sk buffer for the new frame.
303 skb
= rt2x00queue_alloc_rxskb(entry
->queue
);
308 * Send the frame to rt2x00lib for further processing.
310 rt2x00lib_rxdone(entry
, &rxdesc
);
313 * Replace current entry's skb with the newly allocated one,
314 * and reinitialize the urb.
317 urb
->transfer_buffer
= entry
->skb
->data
;
318 urb
->transfer_buffer_length
= entry
->skb
->len
;
321 if (test_bit(DEVICE_ENABLED_RADIO
, &entry
->queue
->rt2x00dev
->flags
)) {
322 __set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
323 usb_submit_urb(urb
, GFP_ATOMIC
);
326 rt2x00queue_index_inc(entry
->queue
, Q_INDEX
);
332 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
334 struct queue_entry_priv_usb
*entry_priv
;
335 struct queue_entry_priv_usb_bcn
*bcn_priv
;
338 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0, 0,
344 for (i
= 0; i
< rt2x00dev
->rx
->limit
; i
++) {
345 entry_priv
= rt2x00dev
->rx
->entries
[i
].priv_data
;
346 usb_kill_urb(entry_priv
->urb
);
350 * Kill guardian urb (if required by driver).
352 if (!test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
355 for (i
= 0; i
< rt2x00dev
->bcn
->limit
; i
++) {
356 bcn_priv
= rt2x00dev
->bcn
->entries
[i
].priv_data
;
357 if (bcn_priv
->guardian_urb
)
358 usb_kill_urb(bcn_priv
->guardian_urb
);
361 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
364 * Device initialization handlers.
366 void rt2x00usb_init_rxentry(struct rt2x00_dev
*rt2x00dev
,
367 struct queue_entry
*entry
)
369 struct usb_device
*usb_dev
=
370 interface_to_usbdev(to_usb_interface(rt2x00dev
->dev
));
371 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
373 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
,
374 usb_rcvbulkpipe(usb_dev
, 1),
375 entry
->skb
->data
, entry
->skb
->len
,
376 rt2x00usb_interrupt_rxdone
, entry
);
378 __set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
379 usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
381 EXPORT_SYMBOL_GPL(rt2x00usb_init_rxentry
);
383 void rt2x00usb_init_txentry(struct rt2x00_dev
*rt2x00dev
,
384 struct queue_entry
*entry
)
388 EXPORT_SYMBOL_GPL(rt2x00usb_init_txentry
);
390 static int rt2x00usb_alloc_urb(struct rt2x00_dev
*rt2x00dev
,
391 struct data_queue
*queue
)
393 struct queue_entry_priv_usb
*entry_priv
;
394 struct queue_entry_priv_usb_bcn
*bcn_priv
;
397 for (i
= 0; i
< queue
->limit
; i
++) {
398 entry_priv
= queue
->entries
[i
].priv_data
;
399 entry_priv
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
400 if (!entry_priv
->urb
)
405 * If this is not the beacon queue or
406 * no guardian byte was required for the beacon,
409 if (rt2x00dev
->bcn
!= queue
||
410 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
413 for (i
= 0; i
< queue
->limit
; i
++) {
414 bcn_priv
= queue
->entries
[i
].priv_data
;
415 bcn_priv
->guardian_urb
= usb_alloc_urb(0, GFP_KERNEL
);
416 if (!bcn_priv
->guardian_urb
)
423 static void rt2x00usb_free_urb(struct rt2x00_dev
*rt2x00dev
,
424 struct data_queue
*queue
)
426 struct queue_entry_priv_usb
*entry_priv
;
427 struct queue_entry_priv_usb_bcn
*bcn_priv
;
433 for (i
= 0; i
< queue
->limit
; i
++) {
434 entry_priv
= queue
->entries
[i
].priv_data
;
435 usb_kill_urb(entry_priv
->urb
);
436 usb_free_urb(entry_priv
->urb
);
437 if (queue
->entries
[i
].skb
)
438 kfree_skb(queue
->entries
[i
].skb
);
442 * If this is not the beacon queue or
443 * no guardian byte was required for the beacon,
446 if (rt2x00dev
->bcn
!= queue
||
447 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
450 for (i
= 0; i
< queue
->limit
; i
++) {
451 bcn_priv
= queue
->entries
[i
].priv_data
;
452 usb_kill_urb(bcn_priv
->guardian_urb
);
453 usb_free_urb(bcn_priv
->guardian_urb
);
457 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
459 struct data_queue
*queue
;
461 unsigned int entry_size
;
463 int uninitialized_var(status
);
468 queue_for_each(rt2x00dev
, queue
) {
469 status
= rt2x00usb_alloc_urb(rt2x00dev
, queue
);
475 * For the RX queue, skb's should be allocated.
477 entry_size
= rt2x00dev
->rx
->data_size
+ rt2x00dev
->rx
->desc_size
;
478 for (i
= 0; i
< rt2x00dev
->rx
->limit
; i
++) {
479 skb
= rt2x00queue_alloc_rxskb(rt2x00dev
->rx
);
483 rt2x00dev
->rx
->entries
[i
].skb
= skb
;
489 rt2x00usb_uninitialize(rt2x00dev
);
493 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
495 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
497 struct data_queue
*queue
;
499 queue_for_each(rt2x00dev
, queue
)
500 rt2x00usb_free_urb(rt2x00dev
, queue
);
502 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
505 * USB driver handlers.
507 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
509 kfree(rt2x00dev
->rf
);
510 rt2x00dev
->rf
= NULL
;
512 kfree(rt2x00dev
->eeprom
);
513 rt2x00dev
->eeprom
= NULL
;
515 kfree(rt2x00dev
->csr
.cache
);
516 rt2x00dev
->csr
.cache
= NULL
;
519 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
521 rt2x00dev
->csr
.cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
522 if (!rt2x00dev
->csr
.cache
)
525 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
526 if (!rt2x00dev
->eeprom
)
529 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
536 ERROR_PROBE("Failed to allocate registers.\n");
538 rt2x00usb_free_reg(rt2x00dev
);
543 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
544 const struct usb_device_id
*id
)
546 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
547 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
548 struct ieee80211_hw
*hw
;
549 struct rt2x00_dev
*rt2x00dev
;
552 usb_dev
= usb_get_dev(usb_dev
);
554 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
556 ERROR_PROBE("Failed to allocate hardware.\n");
558 goto exit_put_device
;
561 usb_set_intfdata(usb_intf
, hw
);
563 rt2x00dev
= hw
->priv
;
564 rt2x00dev
->dev
= &usb_intf
->dev
;
565 rt2x00dev
->ops
= ops
;
567 mutex_init(&rt2x00dev
->usb_cache_mutex
);
569 rt2x00dev
->usb_maxpacket
=
570 usb_maxpacket(usb_dev
, usb_sndbulkpipe(usb_dev
, 1), 1);
571 if (!rt2x00dev
->usb_maxpacket
)
572 rt2x00dev
->usb_maxpacket
= 1;
574 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
576 goto exit_free_device
;
578 retval
= rt2x00lib_probe_dev(rt2x00dev
);
585 rt2x00usb_free_reg(rt2x00dev
);
588 ieee80211_free_hw(hw
);
591 usb_put_dev(usb_dev
);
593 usb_set_intfdata(usb_intf
, NULL
);
597 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
599 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
601 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
602 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
605 * Free all allocated data.
607 rt2x00lib_remove_dev(rt2x00dev
);
608 rt2x00usb_free_reg(rt2x00dev
);
609 ieee80211_free_hw(hw
);
612 * Free the USB device data.
614 usb_set_intfdata(usb_intf
, NULL
);
615 usb_put_dev(interface_to_usbdev(usb_intf
));
617 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
620 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
622 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
623 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
626 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
630 rt2x00usb_free_reg(rt2x00dev
);
633 * Decrease usbdev refcount.
635 usb_put_dev(interface_to_usbdev(usb_intf
));
639 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
641 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
643 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
644 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
647 usb_get_dev(interface_to_usbdev(usb_intf
));
649 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
653 retval
= rt2x00lib_resume(rt2x00dev
);
660 rt2x00usb_free_reg(rt2x00dev
);
664 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
665 #endif /* CONFIG_PM */
668 * rt2x00usb module information.
670 MODULE_AUTHOR(DRV_PROJECT
);
671 MODULE_VERSION(DRV_VERSION
);
672 MODULE_DESCRIPTION("rt2x00 usb library");
673 MODULE_LICENSE("GPL");