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, | |
45 | u16 timeout) | |
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 | /* | |
63 | * Check for errors, | |
64 | * -ETIMEDOUT: We need a bit more time to complete. | |
65 | * -ENODEV: Device has disappeared, no point continuing. | |
66 | */ | |
67 | if (status == -ETIMEDOUT) | |
68 | timeout *= 2; | |
69 | else if (status == -ENODEV) | |
70 | break; | |
71 | } | |
72 | ||
73 | ERROR(rt2x00dev, | |
74 | "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n", | |
75 | request, offset, status); | |
76 | ||
77 | return status; | |
78 | } | |
79 | EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request); | |
80 | ||
81 | int rt2x00usb_vendor_request_buff(const struct rt2x00_dev *rt2x00dev, | |
82 | const u8 request, const u8 requesttype, | |
83 | const u16 offset, void *buffer, | |
84 | const u16 buffer_length, u16 timeout) | |
85 | { | |
86 | int status; | |
87 | ||
88 | /* | |
89 | * Check for Cache availability. | |
90 | */ | |
91 | if (unlikely(!rt2x00dev->csr_cache || buffer_length > CSR_CACHE_SIZE)) { | |
92 | ERROR(rt2x00dev, "CSR cache not available.\n"); | |
93 | return -ENOMEM; | |
94 | } | |
95 | ||
96 | if (requesttype == USB_VENDOR_REQUEST_OUT) | |
97 | memcpy(rt2x00dev->csr_cache, buffer, buffer_length); | |
98 | ||
99 | status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype, | |
100 | offset, 0, rt2x00dev->csr_cache, | |
101 | buffer_length, timeout); | |
102 | ||
103 | if (!status && requesttype == USB_VENDOR_REQUEST_IN) | |
104 | memcpy(buffer, rt2x00dev->csr_cache, buffer_length); | |
105 | ||
106 | return status; | |
107 | } | |
108 | EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff); | |
109 | ||
110 | /* | |
111 | * TX data handlers. | |
112 | */ | |
113 | static void rt2x00usb_interrupt_txdone(struct urb *urb) | |
114 | { | |
115 | struct data_entry *entry = (struct data_entry *)urb->context; | |
116 | struct data_ring *ring = entry->ring; | |
117 | struct rt2x00_dev *rt2x00dev = ring->rt2x00dev; | |
118 | struct data_desc *txd = (struct data_desc *)entry->skb->data; | |
119 | u32 word; | |
120 | int tx_status; | |
121 | ||
122 | if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) || | |
123 | !__test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags)) | |
124 | return; | |
125 | ||
126 | rt2x00_desc_read(txd, 0, &word); | |
127 | ||
128 | /* | |
129 | * Remove the descriptor data from the buffer. | |
130 | */ | |
131 | skb_pull(entry->skb, ring->desc_size); | |
132 | ||
133 | /* | |
134 | * Obtain the status about this packet. | |
135 | */ | |
136 | tx_status = !urb->status ? TX_SUCCESS : TX_FAIL_RETRY; | |
137 | ||
138 | rt2x00lib_txdone(entry, tx_status, 0); | |
139 | ||
140 | /* | |
141 | * Make this entry available for reuse. | |
142 | */ | |
143 | entry->flags = 0; | |
144 | rt2x00_ring_index_done_inc(entry->ring); | |
145 | ||
146 | /* | |
147 | * If the data ring was full before the txdone handler | |
148 | * we must make sure the packet queue in the mac80211 stack | |
149 | * is reenabled when the txdone handler has finished. | |
150 | */ | |
151 | if (!rt2x00_ring_full(ring)) | |
152 | ieee80211_wake_queue(rt2x00dev->hw, | |
153 | entry->tx_status.control.queue); | |
154 | } | |
155 | ||
156 | int rt2x00usb_write_tx_data(struct rt2x00_dev *rt2x00dev, | |
157 | struct data_ring *ring, struct sk_buff *skb, | |
158 | struct ieee80211_tx_control *control) | |
159 | { | |
160 | struct usb_device *usb_dev = | |
161 | interface_to_usbdev(rt2x00dev_usb(rt2x00dev)); | |
162 | struct ieee80211_hdr *ieee80211hdr = (struct ieee80211_hdr *)skb->data; | |
163 | struct data_entry *entry = rt2x00_get_data_entry(ring); | |
164 | u32 length = skb->len; | |
165 | ||
166 | if (rt2x00_ring_full(ring)) { | |
167 | ieee80211_stop_queue(rt2x00dev->hw, control->queue); | |
168 | return -EINVAL; | |
169 | } | |
170 | ||
171 | if (test_bit(ENTRY_OWNER_NIC, &entry->flags)) { | |
172 | ERROR(rt2x00dev, | |
173 | "Arrived at non-free entry in the non-full queue %d.\n" | |
174 | "Please file bug report to %s.\n", | |
175 | control->queue, DRV_PROJECT); | |
176 | ieee80211_stop_queue(rt2x00dev->hw, control->queue); | |
177 | return -EINVAL; | |
178 | } | |
179 | ||
180 | /* | |
181 | * Add the descriptor in front of the skb. | |
182 | */ | |
183 | skb_push(skb, rt2x00dev->hw->extra_tx_headroom); | |
184 | memset(skb->data, 0x00, rt2x00dev->hw->extra_tx_headroom); | |
185 | ||
186 | rt2x00lib_write_tx_desc(rt2x00dev, (struct data_desc *)skb->data, | |
187 | ieee80211hdr, length, control); | |
188 | memcpy(&entry->tx_status.control, control, sizeof(*control)); | |
189 | entry->skb = skb; | |
190 | ||
191 | /* | |
192 | * Length passed to usb_fill_urb cannot be an odd number, | |
193 | * so add 1 byte to make it even. | |
194 | */ | |
195 | length += rt2x00dev->hw->extra_tx_headroom; | |
196 | if (length % 2) | |
197 | length++; | |
198 | ||
199 | __set_bit(ENTRY_OWNER_NIC, &entry->flags); | |
200 | usb_fill_bulk_urb(entry->priv, usb_dev, | |
201 | usb_sndbulkpipe(usb_dev, 1), | |
202 | skb->data, length, rt2x00usb_interrupt_txdone, entry); | |
203 | usb_submit_urb(entry->priv, GFP_ATOMIC); | |
204 | ||
205 | rt2x00_ring_index_inc(ring); | |
206 | ||
207 | if (rt2x00_ring_full(ring)) | |
208 | ieee80211_stop_queue(rt2x00dev->hw, control->queue); | |
209 | ||
210 | return 0; | |
211 | } | |
212 | EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data); | |
213 | ||
214 | /* | |
215 | * RX data handlers. | |
216 | */ | |
217 | static void rt2x00usb_interrupt_rxdone(struct urb *urb) | |
218 | { | |
219 | struct data_entry *entry = (struct data_entry *)urb->context; | |
220 | struct data_ring *ring = entry->ring; | |
221 | struct rt2x00_dev *rt2x00dev = ring->rt2x00dev; | |
222 | struct sk_buff *skb; | |
223 | int retval; | |
224 | int signal; | |
225 | int rssi; | |
226 | int ofdm; | |
227 | int size; | |
228 | int frame_size; | |
229 | ||
230 | if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) || | |
231 | !test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags)) | |
232 | return; | |
233 | ||
234 | /* | |
235 | * Check if the received data is simply too small | |
236 | * to be actually valid, or if the urb is signaling | |
237 | * a problem. | |
238 | */ | |
239 | if (urb->actual_length < entry->ring->desc_size || urb->status) | |
240 | goto skip_entry; | |
241 | ||
242 | retval = rt2x00dev->ops->lib->fill_rxdone(entry, &signal, &rssi, | |
243 | &ofdm, &size); | |
244 | if (retval) | |
245 | goto skip_entry; | |
246 | ||
247 | /* | |
248 | * Allocate a new sk buffer to replace the current one. | |
249 | * If allocation fails, we should drop the current frame | |
250 | * so we can recycle the existing sk buffer for the new frame. | |
251 | */ | |
252 | frame_size = entry->ring->data_size + entry->ring->desc_size; | |
253 | skb = dev_alloc_skb(frame_size + NET_IP_ALIGN); | |
254 | if (!skb) | |
255 | goto skip_entry; | |
256 | ||
257 | skb_reserve(skb, NET_IP_ALIGN); | |
258 | skb_put(skb, frame_size); | |
259 | ||
260 | /* | |
261 | * Trim the skb_buffer to only contain the valid | |
262 | * frame data (so ignore the device's descriptor). | |
263 | */ | |
264 | skb_trim(entry->skb, size); | |
265 | ||
266 | /* | |
267 | * Send the frame to rt2x00lib for further processing. | |
268 | */ | |
269 | rt2x00lib_rxdone(entry, entry->skb, signal, rssi, ofdm); | |
270 | ||
271 | /* | |
272 | * Replace current entry's skb with the newly allocated one, | |
273 | * and reinitialize the urb. | |
274 | */ | |
275 | entry->skb = skb; | |
276 | urb->transfer_buffer = entry->skb->data; | |
277 | urb->transfer_buffer_length = entry->skb->len; | |
278 | ||
279 | skip_entry: | |
280 | if (test_bit(DEVICE_ENABLED_RADIO, &ring->rt2x00dev->flags)) { | |
281 | __set_bit(ENTRY_OWNER_NIC, &entry->flags); | |
282 | usb_submit_urb(urb, GFP_ATOMIC); | |
283 | } | |
284 | ||
285 | rt2x00_ring_index_inc(ring); | |
286 | } | |
287 | ||
288 | /* | |
289 | * Radio handlers | |
290 | */ | |
291 | void rt2x00usb_enable_radio(struct rt2x00_dev *rt2x00dev) | |
292 | { | |
293 | struct usb_device *usb_dev = | |
294 | interface_to_usbdev(rt2x00dev_usb(rt2x00dev)); | |
295 | struct data_ring *ring; | |
296 | struct data_entry *entry; | |
297 | unsigned int i; | |
298 | ||
299 | /* | |
300 | * Initialize the TX rings | |
301 | */ | |
302 | txringall_for_each(rt2x00dev, ring) { | |
303 | for (i = 0; i < ring->stats.limit; i++) | |
304 | ring->entry[i].flags = 0; | |
305 | ||
306 | rt2x00_ring_index_clear(ring); | |
307 | } | |
308 | ||
309 | /* | |
310 | * Initialize and start the RX ring. | |
311 | */ | |
312 | rt2x00_ring_index_clear(rt2x00dev->rx); | |
313 | ||
314 | for (i = 0; i < rt2x00dev->rx->stats.limit; i++) { | |
315 | entry = &rt2x00dev->rx->entry[i]; | |
316 | ||
317 | usb_fill_bulk_urb(entry->priv, usb_dev, | |
318 | usb_rcvbulkpipe(usb_dev, 1), | |
319 | entry->skb->data, entry->skb->len, | |
320 | rt2x00usb_interrupt_rxdone, entry); | |
321 | ||
322 | __set_bit(ENTRY_OWNER_NIC, &entry->flags); | |
323 | usb_submit_urb(entry->priv, GFP_ATOMIC); | |
324 | } | |
325 | } | |
326 | EXPORT_SYMBOL_GPL(rt2x00usb_enable_radio); | |
327 | ||
328 | void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev) | |
329 | { | |
330 | struct data_ring *ring; | |
331 | unsigned int i; | |
332 | ||
333 | rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0x0000, 0x0000, | |
334 | REGISTER_TIMEOUT); | |
335 | ||
336 | /* | |
337 | * Cancel all rings. | |
338 | */ | |
339 | ring_for_each(rt2x00dev, ring) { | |
340 | for (i = 0; i < ring->stats.limit; i++) | |
341 | usb_kill_urb(ring->entry[i].priv); | |
342 | } | |
343 | } | |
344 | EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio); | |
345 | ||
346 | /* | |
347 | * Device initialization handlers. | |
348 | */ | |
349 | static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev, | |
350 | struct data_ring *ring) | |
351 | { | |
352 | unsigned int i; | |
353 | ||
354 | /* | |
355 | * Allocate the URB's | |
356 | */ | |
357 | for (i = 0; i < ring->stats.limit; i++) { | |
358 | ring->entry[i].priv = usb_alloc_urb(0, GFP_KERNEL); | |
359 | if (!ring->entry[i].priv) | |
360 | return -ENOMEM; | |
361 | } | |
362 | ||
363 | return 0; | |
364 | } | |
365 | ||
366 | static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev, | |
367 | struct data_ring *ring) | |
368 | { | |
369 | unsigned int i; | |
370 | ||
371 | if (!ring->entry) | |
372 | return; | |
373 | ||
374 | for (i = 0; i < ring->stats.limit; i++) { | |
375 | usb_kill_urb(ring->entry[i].priv); | |
376 | usb_free_urb(ring->entry[i].priv); | |
377 | if (ring->entry[i].skb) | |
378 | kfree_skb(ring->entry[i].skb); | |
379 | } | |
380 | } | |
381 | ||
382 | int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev) | |
383 | { | |
384 | struct data_ring *ring; | |
385 | struct sk_buff *skb; | |
386 | unsigned int entry_size; | |
387 | unsigned int i; | |
388 | int status; | |
389 | ||
390 | /* | |
391 | * Allocate DMA | |
392 | */ | |
393 | ring_for_each(rt2x00dev, ring) { | |
394 | status = rt2x00usb_alloc_urb(rt2x00dev, ring); | |
395 | if (status) | |
396 | goto exit; | |
397 | } | |
398 | ||
399 | /* | |
400 | * For the RX ring, skb's should be allocated. | |
401 | */ | |
402 | entry_size = rt2x00dev->rx->data_size + rt2x00dev->rx->desc_size; | |
403 | for (i = 0; i < rt2x00dev->rx->stats.limit; i++) { | |
404 | skb = dev_alloc_skb(NET_IP_ALIGN + entry_size); | |
405 | if (!skb) | |
406 | goto exit; | |
407 | ||
408 | skb_reserve(skb, NET_IP_ALIGN); | |
409 | skb_put(skb, entry_size); | |
410 | ||
411 | rt2x00dev->rx->entry[i].skb = skb; | |
412 | } | |
413 | ||
414 | return 0; | |
415 | ||
416 | exit: | |
417 | rt2x00usb_uninitialize(rt2x00dev); | |
418 | ||
419 | return status; | |
420 | } | |
421 | EXPORT_SYMBOL_GPL(rt2x00usb_initialize); | |
422 | ||
423 | void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev) | |
424 | { | |
425 | struct data_ring *ring; | |
426 | ||
427 | ring_for_each(rt2x00dev, ring) | |
428 | rt2x00usb_free_urb(rt2x00dev, ring); | |
429 | } | |
430 | EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize); | |
431 | ||
432 | /* | |
433 | * USB driver handlers. | |
434 | */ | |
435 | static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev) | |
436 | { | |
437 | kfree(rt2x00dev->rf); | |
438 | rt2x00dev->rf = NULL; | |
439 | ||
440 | kfree(rt2x00dev->eeprom); | |
441 | rt2x00dev->eeprom = NULL; | |
442 | ||
443 | kfree(rt2x00dev->csr_cache); | |
444 | rt2x00dev->csr_cache = NULL; | |
445 | } | |
446 | ||
447 | static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev) | |
448 | { | |
449 | rt2x00dev->csr_cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL); | |
450 | if (!rt2x00dev->csr_cache) | |
451 | goto exit; | |
452 | ||
453 | rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL); | |
454 | if (!rt2x00dev->eeprom) | |
455 | goto exit; | |
456 | ||
457 | rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL); | |
458 | if (!rt2x00dev->rf) | |
459 | goto exit; | |
460 | ||
461 | return 0; | |
462 | ||
463 | exit: | |
464 | ERROR_PROBE("Failed to allocate registers.\n"); | |
465 | ||
466 | rt2x00usb_free_reg(rt2x00dev); | |
467 | ||
468 | return -ENOMEM; | |
469 | } | |
470 | ||
471 | int rt2x00usb_probe(struct usb_interface *usb_intf, | |
472 | const struct usb_device_id *id) | |
473 | { | |
474 | struct usb_device *usb_dev = interface_to_usbdev(usb_intf); | |
475 | struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info; | |
476 | struct ieee80211_hw *hw; | |
477 | struct rt2x00_dev *rt2x00dev; | |
478 | int retval; | |
479 | ||
480 | usb_dev = usb_get_dev(usb_dev); | |
481 | ||
482 | hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw); | |
483 | if (!hw) { | |
484 | ERROR_PROBE("Failed to allocate hardware.\n"); | |
485 | retval = -ENOMEM; | |
486 | goto exit_put_device; | |
487 | } | |
488 | ||
489 | usb_set_intfdata(usb_intf, hw); | |
490 | ||
491 | rt2x00dev = hw->priv; | |
492 | rt2x00dev->dev = usb_intf; | |
493 | rt2x00dev->ops = ops; | |
494 | rt2x00dev->hw = hw; | |
495 | ||
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"); |