2 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
3 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
4 <http://rt2x00.serialmonkey.com>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the
18 Free Software Foundation, Inc.,
19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 Abstract: rt2x00 generic usb device routines.
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/usb.h>
31 #include <linux/bug.h>
34 #include "rt2x00usb.h"
37 * Interfacing with the HW.
39 int rt2x00usb_vendor_request(struct rt2x00_dev
*rt2x00dev
,
40 const u8 request
, const u8 requesttype
,
41 const u16 offset
, const u16 value
,
42 void *buffer
, const u16 buffer_length
,
45 struct usb_device
*usb_dev
= to_usb_device_intf(rt2x00dev
->dev
);
49 (requesttype
== USB_VENDOR_REQUEST_IN
) ?
50 usb_rcvctrlpipe(usb_dev
, 0) : usb_sndctrlpipe(usb_dev
, 0);
52 if (!test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
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
) {
68 clear_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
);
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_req_buff_lock(struct rt2x00_dev
*rt2x00dev
,
82 const u8 request
, const u8 requesttype
,
83 const u16 offset
, void *buffer
,
84 const u16 buffer_length
, const int timeout
)
88 BUG_ON(!mutex_is_locked(&rt2x00dev
->csr_mutex
));
91 * Check for Cache availability.
93 if (unlikely(!rt2x00dev
->csr
.cache
|| buffer_length
> CSR_CACHE_SIZE
)) {
94 ERROR(rt2x00dev
, "CSR cache not available.\n");
98 if (requesttype
== USB_VENDOR_REQUEST_OUT
)
99 memcpy(rt2x00dev
->csr
.cache
, buffer
, buffer_length
);
101 status
= rt2x00usb_vendor_request(rt2x00dev
, request
, requesttype
,
102 offset
, 0, rt2x00dev
->csr
.cache
,
103 buffer_length
, timeout
);
105 if (!status
&& requesttype
== USB_VENDOR_REQUEST_IN
)
106 memcpy(buffer
, rt2x00dev
->csr
.cache
, buffer_length
);
110 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock
);
112 int rt2x00usb_vendor_request_buff(struct rt2x00_dev
*rt2x00dev
,
113 const u8 request
, const u8 requesttype
,
114 const u16 offset
, void *buffer
,
115 const u16 buffer_length
, const int timeout
)
121 mutex_lock(&rt2x00dev
->csr_mutex
);
126 while (len
&& !status
) {
127 bsize
= min_t(u16
, CSR_CACHE_SIZE
, len
);
128 status
= rt2x00usb_vendor_req_buff_lock(rt2x00dev
, request
,
129 requesttype
, off
, tb
,
137 mutex_unlock(&rt2x00dev
->csr_mutex
);
141 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff
);
143 int rt2x00usb_regbusy_read(struct rt2x00_dev
*rt2x00dev
,
144 const unsigned int offset
,
145 const struct rt2x00_field32 field
,
150 if (!test_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
))
153 for (i
= 0; i
< REGISTER_BUSY_COUNT
; i
++) {
154 rt2x00usb_register_read_lock(rt2x00dev
, offset
, reg
);
155 if (!rt2x00_get_field32(*reg
, field
))
157 udelay(REGISTER_BUSY_DELAY
);
160 ERROR(rt2x00dev
, "Indirect register access failed: "
161 "offset=0x%.08x, value=0x%.08x\n", offset
, *reg
);
166 EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read
);
171 static void rt2x00usb_work_txdone_entry(struct queue_entry
*entry
)
174 * If the transfer to hardware succeeded, it does not mean the
175 * frame was send out correctly. It only means the frame
176 * was succesfully pushed to the hardware, we have no
177 * way to determine the transmission status right now.
178 * (Only indirectly by looking at the failed TX counters
181 if (test_bit(ENTRY_DATA_IO_FAILED
, &entry
->flags
))
182 rt2x00lib_txdone_noinfo(entry
, TXDONE_FAILURE
);
184 rt2x00lib_txdone_noinfo(entry
, TXDONE_UNKNOWN
);
187 static void rt2x00usb_work_txdone(struct work_struct
*work
)
189 struct rt2x00_dev
*rt2x00dev
=
190 container_of(work
, struct rt2x00_dev
, txdone_work
);
191 struct data_queue
*queue
;
192 struct queue_entry
*entry
;
194 tx_queue_for_each(rt2x00dev
, queue
) {
195 while (!rt2x00queue_empty(queue
)) {
196 entry
= rt2x00queue_get_entry(queue
, Q_INDEX_DONE
);
198 if (test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
201 rt2x00usb_work_txdone_entry(entry
);
206 static void rt2x00usb_interrupt_txdone(struct urb
*urb
)
208 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
209 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
211 if (!test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
215 * Report the frame as DMA done
217 rt2x00lib_dmadone(entry
);
220 * Check if the frame was correctly uploaded
223 set_bit(ENTRY_DATA_IO_FAILED
, &entry
->flags
);
226 * Schedule the delayed work for reading the TX status
229 ieee80211_queue_work(rt2x00dev
->hw
, &rt2x00dev
->txdone_work
);
232 static void rt2x00usb_kick_tx_entry(struct queue_entry
*entry
)
234 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
235 struct usb_device
*usb_dev
= to_usb_device_intf(rt2x00dev
->dev
);
236 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
240 if (!test_and_clear_bit(ENTRY_DATA_PENDING
, &entry
->flags
))
244 * USB devices cannot blindly pass the skb->len as the
245 * length of the data to usb_fill_bulk_urb. Pass the skb
246 * to the driver to determine what the length should be.
248 length
= rt2x00dev
->ops
->lib
->get_tx_data_len(entry
);
250 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
,
251 usb_sndbulkpipe(usb_dev
, entry
->queue
->usb_endpoint
),
252 entry
->skb
->data
, length
,
253 rt2x00usb_interrupt_txdone
, entry
);
255 status
= usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
257 if (status
== -ENODEV
)
258 clear_bit(DEVICE_STATE_PRESENT
, &rt2x00dev
->flags
);
259 set_bit(ENTRY_DATA_IO_FAILED
, &entry
->flags
);
260 rt2x00lib_dmadone(entry
);
264 void rt2x00usb_kick_queue(struct data_queue
*queue
)
266 switch (queue
->qid
) {
271 if (!rt2x00queue_empty(queue
))
272 rt2x00queue_for_each_entry(queue
, Q_INDEX_DONE
, Q_INDEX
,
273 rt2x00usb_kick_tx_entry
);
279 EXPORT_SYMBOL_GPL(rt2x00usb_kick_queue
);
281 static void rt2x00usb_kill_entry(struct queue_entry
*entry
)
283 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
284 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
285 struct queue_entry_priv_usb_bcn
*bcn_priv
= entry
->priv_data
;
287 if (!test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
290 usb_kill_urb(entry_priv
->urb
);
293 * Kill guardian urb (if required by driver).
295 if ((entry
->queue
->qid
== QID_BEACON
) &&
296 (test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
)))
297 usb_kill_urb(bcn_priv
->guardian_urb
);
300 void rt2x00usb_stop_queue(struct data_queue
*queue
)
302 rt2x00queue_for_each_entry(queue
, Q_INDEX_DONE
, Q_INDEX
,
303 rt2x00usb_kill_entry
);
305 EXPORT_SYMBOL_GPL(rt2x00usb_stop_queue
);
307 static void rt2x00usb_watchdog_tx_dma(struct data_queue
*queue
)
309 struct rt2x00_dev
*rt2x00dev
= queue
->rt2x00dev
;
310 unsigned short threshold
= queue
->threshold
;
312 WARNING(queue
->rt2x00dev
, "TX queue %d DMA timed out,"
313 " invoke forced forced reset\n", queue
->qid
);
316 * Temporarily disable the TX queue, this will force mac80211
317 * to use the other queues until this queue has been restored.
319 * Set the queue threshold to the queue limit. This prevents the
320 * queue from being enabled during the txdone handler.
322 queue
->threshold
= queue
->limit
;
323 ieee80211_stop_queue(rt2x00dev
->hw
, queue
->qid
);
326 * Kill all entries in the queue, afterwards we need to
327 * wait a bit for all URBs to be cancelled.
329 rt2x00usb_stop_queue(queue
);
332 * In case that a driver has overriden the txdone_work
333 * function, we invoke the TX done through there.
335 rt2x00dev
->txdone_work
.func(&rt2x00dev
->txdone_work
);
338 * The queue has been reset, and mac80211 is allowed to use the
341 queue
->threshold
= threshold
;
342 ieee80211_wake_queue(rt2x00dev
->hw
, queue
->qid
);
345 static void rt2x00usb_watchdog_tx_status(struct data_queue
*queue
)
347 WARNING(queue
->rt2x00dev
, "TX queue %d status timed out,"
348 " invoke forced tx handler\n", queue
->qid
);
350 ieee80211_queue_work(queue
->rt2x00dev
->hw
, &queue
->rt2x00dev
->txdone_work
);
353 void rt2x00usb_watchdog(struct rt2x00_dev
*rt2x00dev
)
355 struct data_queue
*queue
;
357 tx_queue_for_each(rt2x00dev
, queue
) {
358 if (!rt2x00queue_empty(queue
)) {
359 if (rt2x00queue_dma_timeout(queue
))
360 rt2x00usb_watchdog_tx_dma(queue
);
361 if (rt2x00queue_status_timeout(queue
))
362 rt2x00usb_watchdog_tx_status(queue
);
366 EXPORT_SYMBOL_GPL(rt2x00usb_watchdog
);
371 static void rt2x00usb_work_rxdone(struct work_struct
*work
)
373 struct rt2x00_dev
*rt2x00dev
=
374 container_of(work
, struct rt2x00_dev
, rxdone_work
);
375 struct queue_entry
*entry
;
376 struct skb_frame_desc
*skbdesc
;
379 while (!rt2x00queue_empty(rt2x00dev
->rx
)) {
380 entry
= rt2x00queue_get_entry(rt2x00dev
->rx
, Q_INDEX_DONE
);
382 if (test_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
386 * Fill in desc fields of the skb descriptor
388 skbdesc
= get_skb_frame_desc(entry
->skb
);
390 skbdesc
->desc_len
= entry
->queue
->desc_size
;
393 * Send the frame to rt2x00lib for further processing.
395 rt2x00lib_rxdone(entry
);
399 static void rt2x00usb_interrupt_rxdone(struct urb
*urb
)
401 struct queue_entry
*entry
= (struct queue_entry
*)urb
->context
;
402 struct rt2x00_dev
*rt2x00dev
= entry
->queue
->rt2x00dev
;
404 if (!test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
))
408 * Report the frame as DMA done
410 rt2x00lib_dmadone(entry
);
413 * Check if the received data is simply too small
414 * to be actually valid, or if the urb is signaling
417 if (urb
->actual_length
< entry
->queue
->desc_size
|| urb
->status
)
418 set_bit(ENTRY_DATA_IO_FAILED
, &entry
->flags
);
421 * Schedule the delayed work for reading the RX status
424 ieee80211_queue_work(rt2x00dev
->hw
, &rt2x00dev
->rxdone_work
);
430 void rt2x00usb_disable_radio(struct rt2x00_dev
*rt2x00dev
)
432 rt2x00usb_vendor_request_sw(rt2x00dev
, USB_RX_CONTROL
, 0, 0,
435 rt2x00dev
->ops
->lib
->stop_queue(rt2x00dev
->rx
);
437 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio
);
440 * Device initialization handlers.
442 void rt2x00usb_clear_entry(struct queue_entry
*entry
)
444 struct usb_device
*usb_dev
=
445 to_usb_device_intf(entry
->queue
->rt2x00dev
->dev
);
446 struct queue_entry_priv_usb
*entry_priv
= entry
->priv_data
;
452 if (entry
->queue
->qid
== QID_RX
) {
453 pipe
= usb_rcvbulkpipe(usb_dev
, entry
->queue
->usb_endpoint
);
454 usb_fill_bulk_urb(entry_priv
->urb
, usb_dev
, pipe
,
455 entry
->skb
->data
, entry
->skb
->len
,
456 rt2x00usb_interrupt_rxdone
, entry
);
458 set_bit(ENTRY_OWNER_DEVICE_DATA
, &entry
->flags
);
460 status
= usb_submit_urb(entry_priv
->urb
, GFP_ATOMIC
);
462 if (status
== -ENODEV
)
463 clear_bit(DEVICE_STATE_PRESENT
,
464 &entry
->queue
->rt2x00dev
->flags
);
465 set_bit(ENTRY_DATA_IO_FAILED
, &entry
->flags
);
466 rt2x00lib_dmadone(entry
);
470 EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry
);
472 static void rt2x00usb_assign_endpoint(struct data_queue
*queue
,
473 struct usb_endpoint_descriptor
*ep_desc
)
475 struct usb_device
*usb_dev
= to_usb_device_intf(queue
->rt2x00dev
->dev
);
478 queue
->usb_endpoint
= usb_endpoint_num(ep_desc
);
480 if (queue
->qid
== QID_RX
) {
481 pipe
= usb_rcvbulkpipe(usb_dev
, queue
->usb_endpoint
);
482 queue
->usb_maxpacket
= usb_maxpacket(usb_dev
, pipe
, 0);
484 pipe
= usb_sndbulkpipe(usb_dev
, queue
->usb_endpoint
);
485 queue
->usb_maxpacket
= usb_maxpacket(usb_dev
, pipe
, 1);
488 if (!queue
->usb_maxpacket
)
489 queue
->usb_maxpacket
= 1;
492 static int rt2x00usb_find_endpoints(struct rt2x00_dev
*rt2x00dev
)
494 struct usb_interface
*intf
= to_usb_interface(rt2x00dev
->dev
);
495 struct usb_host_interface
*intf_desc
= intf
->cur_altsetting
;
496 struct usb_endpoint_descriptor
*ep_desc
;
497 struct data_queue
*queue
= rt2x00dev
->tx
;
498 struct usb_endpoint_descriptor
*tx_ep_desc
= NULL
;
502 * Walk through all available endpoints to search for "bulk in"
503 * and "bulk out" endpoints. When we find such endpoints collect
504 * the information we need from the descriptor and assign it
507 for (i
= 0; i
< intf_desc
->desc
.bNumEndpoints
; i
++) {
508 ep_desc
= &intf_desc
->endpoint
[i
].desc
;
510 if (usb_endpoint_is_bulk_in(ep_desc
)) {
511 rt2x00usb_assign_endpoint(rt2x00dev
->rx
, ep_desc
);
512 } else if (usb_endpoint_is_bulk_out(ep_desc
) &&
513 (queue
!= queue_end(rt2x00dev
))) {
514 rt2x00usb_assign_endpoint(queue
, ep_desc
);
515 queue
= queue_next(queue
);
517 tx_ep_desc
= ep_desc
;
522 * At least 1 endpoint for RX and 1 endpoint for TX must be available.
524 if (!rt2x00dev
->rx
->usb_endpoint
|| !rt2x00dev
->tx
->usb_endpoint
) {
525 ERROR(rt2x00dev
, "Bulk-in/Bulk-out endpoints not found\n");
530 * It might be possible not all queues have a dedicated endpoint.
531 * Loop through all TX queues and copy the endpoint information
532 * which we have gathered from already assigned endpoints.
534 txall_queue_for_each(rt2x00dev
, queue
) {
535 if (!queue
->usb_endpoint
)
536 rt2x00usb_assign_endpoint(queue
, tx_ep_desc
);
542 static int rt2x00usb_alloc_entries(struct data_queue
*queue
)
544 struct rt2x00_dev
*rt2x00dev
= queue
->rt2x00dev
;
545 struct queue_entry_priv_usb
*entry_priv
;
546 struct queue_entry_priv_usb_bcn
*bcn_priv
;
549 for (i
= 0; i
< queue
->limit
; i
++) {
550 entry_priv
= queue
->entries
[i
].priv_data
;
551 entry_priv
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
552 if (!entry_priv
->urb
)
557 * If this is not the beacon queue or
558 * no guardian byte was required for the beacon,
561 if (queue
->qid
!= QID_BEACON
||
562 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
565 for (i
= 0; i
< queue
->limit
; i
++) {
566 bcn_priv
= queue
->entries
[i
].priv_data
;
567 bcn_priv
->guardian_urb
= usb_alloc_urb(0, GFP_KERNEL
);
568 if (!bcn_priv
->guardian_urb
)
575 static void rt2x00usb_free_entries(struct data_queue
*queue
)
577 struct rt2x00_dev
*rt2x00dev
= queue
->rt2x00dev
;
578 struct queue_entry_priv_usb
*entry_priv
;
579 struct queue_entry_priv_usb_bcn
*bcn_priv
;
585 for (i
= 0; i
< queue
->limit
; i
++) {
586 entry_priv
= queue
->entries
[i
].priv_data
;
587 usb_kill_urb(entry_priv
->urb
);
588 usb_free_urb(entry_priv
->urb
);
592 * If this is not the beacon queue or
593 * no guardian byte was required for the beacon,
596 if (queue
->qid
!= QID_BEACON
||
597 !test_bit(DRIVER_REQUIRE_BEACON_GUARD
, &rt2x00dev
->flags
))
600 for (i
= 0; i
< queue
->limit
; i
++) {
601 bcn_priv
= queue
->entries
[i
].priv_data
;
602 usb_kill_urb(bcn_priv
->guardian_urb
);
603 usb_free_urb(bcn_priv
->guardian_urb
);
607 int rt2x00usb_initialize(struct rt2x00_dev
*rt2x00dev
)
609 struct data_queue
*queue
;
613 * Find endpoints for each queue
615 status
= rt2x00usb_find_endpoints(rt2x00dev
);
622 queue_for_each(rt2x00dev
, queue
) {
623 status
= rt2x00usb_alloc_entries(queue
);
631 rt2x00usb_uninitialize(rt2x00dev
);
635 EXPORT_SYMBOL_GPL(rt2x00usb_initialize
);
637 void rt2x00usb_uninitialize(struct rt2x00_dev
*rt2x00dev
)
639 struct data_queue
*queue
;
641 queue_for_each(rt2x00dev
, queue
)
642 rt2x00usb_free_entries(queue
);
644 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize
);
647 * USB driver handlers.
649 static void rt2x00usb_free_reg(struct rt2x00_dev
*rt2x00dev
)
651 kfree(rt2x00dev
->rf
);
652 rt2x00dev
->rf
= NULL
;
654 kfree(rt2x00dev
->eeprom
);
655 rt2x00dev
->eeprom
= NULL
;
657 kfree(rt2x00dev
->csr
.cache
);
658 rt2x00dev
->csr
.cache
= NULL
;
661 static int rt2x00usb_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
663 rt2x00dev
->csr
.cache
= kzalloc(CSR_CACHE_SIZE
, GFP_KERNEL
);
664 if (!rt2x00dev
->csr
.cache
)
667 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
668 if (!rt2x00dev
->eeprom
)
671 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
678 ERROR_PROBE("Failed to allocate registers.\n");
680 rt2x00usb_free_reg(rt2x00dev
);
685 int rt2x00usb_probe(struct usb_interface
*usb_intf
,
686 const struct usb_device_id
*id
)
688 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
689 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_info
;
690 struct ieee80211_hw
*hw
;
691 struct rt2x00_dev
*rt2x00dev
;
694 usb_dev
= usb_get_dev(usb_dev
);
696 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
698 ERROR_PROBE("Failed to allocate hardware.\n");
700 goto exit_put_device
;
703 usb_set_intfdata(usb_intf
, hw
);
705 rt2x00dev
= hw
->priv
;
706 rt2x00dev
->dev
= &usb_intf
->dev
;
707 rt2x00dev
->ops
= ops
;
710 rt2x00_set_chip_intf(rt2x00dev
, RT2X00_CHIP_INTF_USB
);
712 INIT_WORK(&rt2x00dev
->rxdone_work
, rt2x00usb_work_rxdone
);
713 INIT_WORK(&rt2x00dev
->txdone_work
, rt2x00usb_work_txdone
);
715 retval
= rt2x00usb_alloc_reg(rt2x00dev
);
717 goto exit_free_device
;
719 retval
= rt2x00lib_probe_dev(rt2x00dev
);
726 rt2x00usb_free_reg(rt2x00dev
);
729 ieee80211_free_hw(hw
);
732 usb_put_dev(usb_dev
);
734 usb_set_intfdata(usb_intf
, NULL
);
738 EXPORT_SYMBOL_GPL(rt2x00usb_probe
);
740 void rt2x00usb_disconnect(struct usb_interface
*usb_intf
)
742 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
743 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
746 * Free all allocated data.
748 rt2x00lib_remove_dev(rt2x00dev
);
749 rt2x00usb_free_reg(rt2x00dev
);
750 ieee80211_free_hw(hw
);
753 * Free the USB device data.
755 usb_set_intfdata(usb_intf
, NULL
);
756 usb_put_dev(interface_to_usbdev(usb_intf
));
758 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect
);
761 int rt2x00usb_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
763 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
764 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
767 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
772 * Decrease usbdev refcount.
774 usb_put_dev(interface_to_usbdev(usb_intf
));
778 EXPORT_SYMBOL_GPL(rt2x00usb_suspend
);
780 int rt2x00usb_resume(struct usb_interface
*usb_intf
)
782 struct ieee80211_hw
*hw
= usb_get_intfdata(usb_intf
);
783 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
785 usb_get_dev(interface_to_usbdev(usb_intf
));
787 return rt2x00lib_resume(rt2x00dev
);
789 EXPORT_SYMBOL_GPL(rt2x00usb_resume
);
790 #endif /* CONFIG_PM */
793 * rt2x00usb module information.
795 MODULE_AUTHOR(DRV_PROJECT
);
796 MODULE_VERSION(DRV_VERSION
);
797 MODULE_DESCRIPTION("rt2x00 usb library");
798 MODULE_LICENSE("GPL");