]>
Commit | Line | Data |
---|---|---|
95ea3627 ID |
1 | /* |
2 | Copyright (C) 2004 - 2007 rt2x00 SourceForge Project | |
3 | <http://rt2x00.serialmonkey.com> | |
4 | ||
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. | |
9 | ||
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. | |
14 | ||
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. | |
19 | */ | |
20 | ||
21 | /* | |
22 | Module: rt2x00usb | |
23 | Abstract: rt2x00 generic usb device routines. | |
24 | */ | |
25 | ||
26 | /* | |
27 | * Set enviroment defines for rt2x00.h | |
28 | */ | |
29 | #define DRV_NAME "rt2x00usb" | |
30 | ||
31 | #include <linux/kernel.h> | |
32 | #include <linux/module.h> | |
33 | #include <linux/usb.h> | |
34 | ||
35 | #include "rt2x00.h" | |
36 | #include "rt2x00usb.h" | |
37 | ||
38 | /* | |
39 | * Interfacing with the HW. | |
40 | */ | |
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, | |
e9136550 | 45 | const int timeout) |
95ea3627 ID |
46 | { |
47 | struct usb_device *usb_dev = | |
48 | interface_to_usbdev(rt2x00dev_usb(rt2x00dev)); | |
49 | int status; | |
50 | unsigned int i; | |
51 | unsigned int pipe = | |
52 | (requesttype == USB_VENDOR_REQUEST_IN) ? | |
53 | usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0); | |
54 | ||
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, | |
58 | timeout); | |
59 | if (status >= 0) | |
60 | return 0; | |
61 | ||
62 | /* | |
e9136550 | 63 | * Check for errors |
95ea3627 | 64 | * -ENODEV: Device has disappeared, no point continuing. |
e9136550 | 65 | * All other errors: Try again. |
95ea3627 | 66 | */ |
95ea3627 ID |
67 | else if (status == -ENODEV) |
68 | break; | |
69 | } | |
70 | ||
71 | ERROR(rt2x00dev, | |
72 | "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n", | |
73 | request, offset, status); | |
74 | ||
75 | return status; | |
76 | } | |
77 | EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request); | |
78 | ||
79 | int rt2x00usb_vendor_request_buff(const struct rt2x00_dev *rt2x00dev, | |
80 | const u8 request, const u8 requesttype, | |
81 | const u16 offset, void *buffer, | |
e9136550 | 82 | const u16 buffer_length, const int timeout) |
95ea3627 ID |
83 | { |
84 | int status; | |
85 | ||
86 | /* | |
87 | * Check for Cache availability. | |
88 | */ | |
89 | if (unlikely(!rt2x00dev->csr_cache || buffer_length > CSR_CACHE_SIZE)) { | |
90 | ERROR(rt2x00dev, "CSR cache not available.\n"); | |
91 | return -ENOMEM; | |
92 | } | |
93 | ||
94 | if (requesttype == USB_VENDOR_REQUEST_OUT) | |
95 | memcpy(rt2x00dev->csr_cache, buffer, buffer_length); | |
96 | ||
97 | status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype, | |
98 | offset, 0, rt2x00dev->csr_cache, | |
99 | buffer_length, timeout); | |
100 | ||
101 | if (!status && requesttype == USB_VENDOR_REQUEST_IN) | |
102 | memcpy(buffer, rt2x00dev->csr_cache, buffer_length); | |
103 | ||
104 | return status; | |
105 | } | |
106 | EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff); | |
107 | ||
108 | /* | |
109 | * TX data handlers. | |
110 | */ | |
111 | static void rt2x00usb_interrupt_txdone(struct urb *urb) | |
112 | { | |
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; | |
117 | u32 word; | |
118 | int tx_status; | |
119 | ||
120 | if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) || | |
121 | !__test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags)) | |
122 | return; | |
123 | ||
124 | rt2x00_desc_read(txd, 0, &word); | |
125 | ||
126 | /* | |
127 | * Remove the descriptor data from the buffer. | |
128 | */ | |
129 | skb_pull(entry->skb, ring->desc_size); | |
130 | ||
131 | /* | |
132 | * Obtain the status about this packet. | |
133 | */ | |
134 | tx_status = !urb->status ? TX_SUCCESS : TX_FAIL_RETRY; | |
135 | ||
136 | rt2x00lib_txdone(entry, tx_status, 0); | |
137 | ||
138 | /* | |
139 | * Make this entry available for reuse. | |
140 | */ | |
141 | entry->flags = 0; | |
142 | rt2x00_ring_index_done_inc(entry->ring); | |
143 | ||
144 | /* | |
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. | |
148 | */ | |
149 | if (!rt2x00_ring_full(ring)) | |
150 | ieee80211_wake_queue(rt2x00dev->hw, | |
151 | entry->tx_status.control.queue); | |
152 | } | |
153 | ||
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) | |
157 | { | |
158 | struct usb_device *usb_dev = | |
159 | interface_to_usbdev(rt2x00dev_usb(rt2x00dev)); | |
95ea3627 | 160 | struct data_entry *entry = rt2x00_get_data_entry(ring); |
dd9fa2d2 | 161 | int pipe = usb_sndbulkpipe(usb_dev, 1); |
dd9fa2d2 | 162 | u32 length; |
95ea3627 ID |
163 | |
164 | if (rt2x00_ring_full(ring)) { | |
165 | ieee80211_stop_queue(rt2x00dev->hw, control->queue); | |
166 | return -EINVAL; | |
167 | } | |
168 | ||
169 | if (test_bit(ENTRY_OWNER_NIC, &entry->flags)) { | |
170 | ERROR(rt2x00dev, | |
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); | |
175 | return -EINVAL; | |
176 | } | |
177 | ||
178 | /* | |
179 | * Add the descriptor in front of the skb. | |
180 | */ | |
dd9fa2d2 ID |
181 | skb_push(skb, ring->desc_size); |
182 | memset(skb->data, 0, ring->desc_size); | |
95ea3627 ID |
183 | |
184 | rt2x00lib_write_tx_desc(rt2x00dev, (struct data_desc *)skb->data, | |
dd9fa2d2 ID |
185 | (struct ieee80211_hdr *)(skb->data + |
186 | ring->desc_size), | |
187 | skb->len - ring->desc_size, control); | |
95ea3627 ID |
188 | memcpy(&entry->tx_status.control, control, sizeof(*control)); |
189 | entry->skb = skb; | |
190 | ||
191 | /* | |
dd9fa2d2 ID |
192 | * USB devices cannot blindly pass the skb->len as the |
193 | * length of the data to usb_fill_bulk_urb. Pass the skb | |
194 | * to the driver to determine what the length should be. | |
95ea3627 | 195 | */ |
b242e891 | 196 | length = rt2x00dev->ops->lib->get_tx_data_len(rt2x00dev, skb); |
95ea3627 | 197 | |
dd9fa2d2 ID |
198 | /* |
199 | * Initialize URB and send the frame to the device. | |
200 | */ | |
95ea3627 | 201 | __set_bit(ENTRY_OWNER_NIC, &entry->flags); |
dd9fa2d2 | 202 | usb_fill_bulk_urb(entry->priv, usb_dev, pipe, |
95ea3627 ID |
203 | skb->data, length, rt2x00usb_interrupt_txdone, entry); |
204 | usb_submit_urb(entry->priv, GFP_ATOMIC); | |
205 | ||
206 | rt2x00_ring_index_inc(ring); | |
207 | ||
208 | if (rt2x00_ring_full(ring)) | |
209 | ieee80211_stop_queue(rt2x00dev->hw, control->queue); | |
210 | ||
211 | return 0; | |
212 | } | |
213 | EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data); | |
214 | ||
215 | /* | |
216 | * RX data handlers. | |
217 | */ | |
218 | static void rt2x00usb_interrupt_rxdone(struct urb *urb) | |
219 | { | |
220 | struct data_entry *entry = (struct data_entry *)urb->context; | |
221 | struct data_ring *ring = entry->ring; | |
222 | struct rt2x00_dev *rt2x00dev = ring->rt2x00dev; | |
223 | struct sk_buff *skb; | |
4150c572 | 224 | struct rxdata_entry_desc desc; |
95ea3627 ID |
225 | int frame_size; |
226 | ||
227 | if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) || | |
228 | !test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags)) | |
229 | return; | |
230 | ||
231 | /* | |
232 | * Check if the received data is simply too small | |
233 | * to be actually valid, or if the urb is signaling | |
234 | * a problem. | |
235 | */ | |
236 | if (urb->actual_length < entry->ring->desc_size || urb->status) | |
237 | goto skip_entry; | |
238 | ||
4150c572 JB |
239 | memset(&desc, 0x00, sizeof(desc)); |
240 | rt2x00dev->ops->lib->fill_rxdone(entry, &desc); | |
95ea3627 ID |
241 | |
242 | /* | |
243 | * Allocate a new sk buffer to replace the current one. | |
244 | * If allocation fails, we should drop the current frame | |
245 | * so we can recycle the existing sk buffer for the new frame. | |
246 | */ | |
247 | frame_size = entry->ring->data_size + entry->ring->desc_size; | |
248 | skb = dev_alloc_skb(frame_size + NET_IP_ALIGN); | |
249 | if (!skb) | |
250 | goto skip_entry; | |
251 | ||
252 | skb_reserve(skb, NET_IP_ALIGN); | |
253 | skb_put(skb, frame_size); | |
254 | ||
255 | /* | |
256 | * Trim the skb_buffer to only contain the valid | |
257 | * frame data (so ignore the device's descriptor). | |
258 | */ | |
4150c572 | 259 | skb_trim(entry->skb, desc.size); |
95ea3627 ID |
260 | |
261 | /* | |
262 | * Send the frame to rt2x00lib for further processing. | |
263 | */ | |
4150c572 | 264 | rt2x00lib_rxdone(entry, entry->skb, &desc); |
95ea3627 ID |
265 | |
266 | /* | |
267 | * Replace current entry's skb with the newly allocated one, | |
268 | * and reinitialize the urb. | |
269 | */ | |
270 | entry->skb = skb; | |
271 | urb->transfer_buffer = entry->skb->data; | |
272 | urb->transfer_buffer_length = entry->skb->len; | |
273 | ||
274 | skip_entry: | |
275 | if (test_bit(DEVICE_ENABLED_RADIO, &ring->rt2x00dev->flags)) { | |
276 | __set_bit(ENTRY_OWNER_NIC, &entry->flags); | |
277 | usb_submit_urb(urb, GFP_ATOMIC); | |
278 | } | |
279 | ||
280 | rt2x00_ring_index_inc(ring); | |
281 | } | |
282 | ||
283 | /* | |
284 | * Radio handlers | |
285 | */ | |
286 | void rt2x00usb_enable_radio(struct rt2x00_dev *rt2x00dev) | |
287 | { | |
288 | struct usb_device *usb_dev = | |
289 | interface_to_usbdev(rt2x00dev_usb(rt2x00dev)); | |
290 | struct data_ring *ring; | |
291 | struct data_entry *entry; | |
292 | unsigned int i; | |
293 | ||
294 | /* | |
295 | * Initialize the TX rings | |
296 | */ | |
297 | txringall_for_each(rt2x00dev, ring) { | |
298 | for (i = 0; i < ring->stats.limit; i++) | |
299 | ring->entry[i].flags = 0; | |
300 | ||
301 | rt2x00_ring_index_clear(ring); | |
302 | } | |
303 | ||
304 | /* | |
305 | * Initialize and start the RX ring. | |
306 | */ | |
307 | rt2x00_ring_index_clear(rt2x00dev->rx); | |
308 | ||
309 | for (i = 0; i < rt2x00dev->rx->stats.limit; i++) { | |
310 | entry = &rt2x00dev->rx->entry[i]; | |
311 | ||
312 | usb_fill_bulk_urb(entry->priv, usb_dev, | |
313 | usb_rcvbulkpipe(usb_dev, 1), | |
314 | entry->skb->data, entry->skb->len, | |
315 | rt2x00usb_interrupt_rxdone, entry); | |
316 | ||
317 | __set_bit(ENTRY_OWNER_NIC, &entry->flags); | |
318 | usb_submit_urb(entry->priv, GFP_ATOMIC); | |
319 | } | |
320 | } | |
321 | EXPORT_SYMBOL_GPL(rt2x00usb_enable_radio); | |
322 | ||
323 | void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev) | |
324 | { | |
325 | struct data_ring *ring; | |
326 | unsigned int i; | |
327 | ||
328 | rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0x0000, 0x0000, | |
329 | REGISTER_TIMEOUT); | |
330 | ||
331 | /* | |
332 | * Cancel all rings. | |
333 | */ | |
334 | ring_for_each(rt2x00dev, ring) { | |
335 | for (i = 0; i < ring->stats.limit; i++) | |
336 | usb_kill_urb(ring->entry[i].priv); | |
337 | } | |
338 | } | |
339 | EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio); | |
340 | ||
341 | /* | |
342 | * Device initialization handlers. | |
343 | */ | |
344 | static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev, | |
345 | struct data_ring *ring) | |
346 | { | |
347 | unsigned int i; | |
348 | ||
349 | /* | |
350 | * Allocate the URB's | |
351 | */ | |
352 | for (i = 0; i < ring->stats.limit; i++) { | |
353 | ring->entry[i].priv = usb_alloc_urb(0, GFP_KERNEL); | |
354 | if (!ring->entry[i].priv) | |
355 | return -ENOMEM; | |
356 | } | |
357 | ||
358 | return 0; | |
359 | } | |
360 | ||
361 | static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev, | |
362 | struct data_ring *ring) | |
363 | { | |
364 | unsigned int i; | |
365 | ||
366 | if (!ring->entry) | |
367 | return; | |
368 | ||
369 | for (i = 0; i < ring->stats.limit; i++) { | |
370 | usb_kill_urb(ring->entry[i].priv); | |
371 | usb_free_urb(ring->entry[i].priv); | |
372 | if (ring->entry[i].skb) | |
373 | kfree_skb(ring->entry[i].skb); | |
374 | } | |
375 | } | |
376 | ||
377 | int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev) | |
378 | { | |
379 | struct data_ring *ring; | |
380 | struct sk_buff *skb; | |
381 | unsigned int entry_size; | |
382 | unsigned int i; | |
383 | int status; | |
384 | ||
385 | /* | |
386 | * Allocate DMA | |
387 | */ | |
388 | ring_for_each(rt2x00dev, ring) { | |
389 | status = rt2x00usb_alloc_urb(rt2x00dev, ring); | |
390 | if (status) | |
391 | goto exit; | |
392 | } | |
393 | ||
394 | /* | |
395 | * For the RX ring, skb's should be allocated. | |
396 | */ | |
397 | entry_size = rt2x00dev->rx->data_size + rt2x00dev->rx->desc_size; | |
398 | for (i = 0; i < rt2x00dev->rx->stats.limit; i++) { | |
399 | skb = dev_alloc_skb(NET_IP_ALIGN + entry_size); | |
400 | if (!skb) | |
401 | goto exit; | |
402 | ||
403 | skb_reserve(skb, NET_IP_ALIGN); | |
404 | skb_put(skb, entry_size); | |
405 | ||
406 | rt2x00dev->rx->entry[i].skb = skb; | |
407 | } | |
408 | ||
409 | return 0; | |
410 | ||
411 | exit: | |
412 | rt2x00usb_uninitialize(rt2x00dev); | |
413 | ||
414 | return status; | |
415 | } | |
416 | EXPORT_SYMBOL_GPL(rt2x00usb_initialize); | |
417 | ||
418 | void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev) | |
419 | { | |
420 | struct data_ring *ring; | |
421 | ||
422 | ring_for_each(rt2x00dev, ring) | |
423 | rt2x00usb_free_urb(rt2x00dev, ring); | |
424 | } | |
425 | EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize); | |
426 | ||
427 | /* | |
428 | * USB driver handlers. | |
429 | */ | |
430 | static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev) | |
431 | { | |
432 | kfree(rt2x00dev->rf); | |
433 | rt2x00dev->rf = NULL; | |
434 | ||
435 | kfree(rt2x00dev->eeprom); | |
436 | rt2x00dev->eeprom = NULL; | |
437 | ||
438 | kfree(rt2x00dev->csr_cache); | |
439 | rt2x00dev->csr_cache = NULL; | |
440 | } | |
441 | ||
442 | static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev) | |
443 | { | |
444 | rt2x00dev->csr_cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL); | |
445 | if (!rt2x00dev->csr_cache) | |
446 | goto exit; | |
447 | ||
448 | rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL); | |
449 | if (!rt2x00dev->eeprom) | |
450 | goto exit; | |
451 | ||
452 | rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL); | |
453 | if (!rt2x00dev->rf) | |
454 | goto exit; | |
455 | ||
456 | return 0; | |
457 | ||
458 | exit: | |
459 | ERROR_PROBE("Failed to allocate registers.\n"); | |
460 | ||
461 | rt2x00usb_free_reg(rt2x00dev); | |
462 | ||
463 | return -ENOMEM; | |
464 | } | |
465 | ||
466 | int rt2x00usb_probe(struct usb_interface *usb_intf, | |
467 | const struct usb_device_id *id) | |
468 | { | |
469 | struct usb_device *usb_dev = interface_to_usbdev(usb_intf); | |
470 | struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info; | |
471 | struct ieee80211_hw *hw; | |
472 | struct rt2x00_dev *rt2x00dev; | |
473 | int retval; | |
474 | ||
475 | usb_dev = usb_get_dev(usb_dev); | |
476 | ||
477 | hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw); | |
478 | if (!hw) { | |
479 | ERROR_PROBE("Failed to allocate hardware.\n"); | |
480 | retval = -ENOMEM; | |
481 | goto exit_put_device; | |
482 | } | |
483 | ||
484 | usb_set_intfdata(usb_intf, hw); | |
485 | ||
486 | rt2x00dev = hw->priv; | |
487 | rt2x00dev->dev = usb_intf; | |
488 | rt2x00dev->ops = ops; | |
489 | rt2x00dev->hw = hw; | |
490 | ||
b242e891 ID |
491 | rt2x00dev->usb_maxpacket = |
492 | usb_maxpacket(usb_dev, usb_sndbulkpipe(usb_dev, 1), 1); | |
493 | if (!rt2x00dev->usb_maxpacket) | |
494 | rt2x00dev->usb_maxpacket = 1; | |
495 | ||
95ea3627 ID |
496 | retval = rt2x00usb_alloc_reg(rt2x00dev); |
497 | if (retval) | |
498 | goto exit_free_device; | |
499 | ||
500 | retval = rt2x00lib_probe_dev(rt2x00dev); | |
501 | if (retval) | |
502 | goto exit_free_reg; | |
503 | ||
504 | return 0; | |
505 | ||
506 | exit_free_reg: | |
507 | rt2x00usb_free_reg(rt2x00dev); | |
508 | ||
509 | exit_free_device: | |
510 | ieee80211_free_hw(hw); | |
511 | ||
512 | exit_put_device: | |
513 | usb_put_dev(usb_dev); | |
514 | ||
515 | usb_set_intfdata(usb_intf, NULL); | |
516 | ||
517 | return retval; | |
518 | } | |
519 | EXPORT_SYMBOL_GPL(rt2x00usb_probe); | |
520 | ||
521 | void rt2x00usb_disconnect(struct usb_interface *usb_intf) | |
522 | { | |
523 | struct ieee80211_hw *hw = usb_get_intfdata(usb_intf); | |
524 | struct rt2x00_dev *rt2x00dev = hw->priv; | |
525 | ||
526 | /* | |
527 | * Free all allocated data. | |
528 | */ | |
529 | rt2x00lib_remove_dev(rt2x00dev); | |
530 | rt2x00usb_free_reg(rt2x00dev); | |
531 | ieee80211_free_hw(hw); | |
532 | ||
533 | /* | |
534 | * Free the USB device data. | |
535 | */ | |
536 | usb_set_intfdata(usb_intf, NULL); | |
537 | usb_put_dev(interface_to_usbdev(usb_intf)); | |
538 | } | |
539 | EXPORT_SYMBOL_GPL(rt2x00usb_disconnect); | |
540 | ||
541 | #ifdef CONFIG_PM | |
542 | int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state) | |
543 | { | |
544 | struct ieee80211_hw *hw = usb_get_intfdata(usb_intf); | |
545 | struct rt2x00_dev *rt2x00dev = hw->priv; | |
546 | int retval; | |
547 | ||
548 | retval = rt2x00lib_suspend(rt2x00dev, state); | |
549 | if (retval) | |
550 | return retval; | |
551 | ||
552 | rt2x00usb_free_reg(rt2x00dev); | |
553 | ||
554 | /* | |
555 | * Decrease usbdev refcount. | |
556 | */ | |
557 | usb_put_dev(interface_to_usbdev(usb_intf)); | |
558 | ||
559 | return 0; | |
560 | } | |
561 | EXPORT_SYMBOL_GPL(rt2x00usb_suspend); | |
562 | ||
563 | int rt2x00usb_resume(struct usb_interface *usb_intf) | |
564 | { | |
565 | struct ieee80211_hw *hw = usb_get_intfdata(usb_intf); | |
566 | struct rt2x00_dev *rt2x00dev = hw->priv; | |
567 | int retval; | |
568 | ||
569 | usb_get_dev(interface_to_usbdev(usb_intf)); | |
570 | ||
571 | retval = rt2x00usb_alloc_reg(rt2x00dev); | |
572 | if (retval) | |
573 | return retval; | |
574 | ||
575 | retval = rt2x00lib_resume(rt2x00dev); | |
576 | if (retval) | |
577 | goto exit_free_reg; | |
578 | ||
579 | return 0; | |
580 | ||
581 | exit_free_reg: | |
582 | rt2x00usb_free_reg(rt2x00dev); | |
583 | ||
584 | return retval; | |
585 | } | |
586 | EXPORT_SYMBOL_GPL(rt2x00usb_resume); | |
587 | #endif /* CONFIG_PM */ | |
588 | ||
589 | /* | |
590 | * rt2x00pci module information. | |
591 | */ | |
592 | MODULE_AUTHOR(DRV_PROJECT); | |
593 | MODULE_VERSION(DRV_VERSION); | |
594 | MODULE_DESCRIPTION("rt2x00 library"); | |
595 | MODULE_LICENSE("GPL"); |