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