2 Copyright (C) 2004 - 2007 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.
27 * Set enviroment defines for rt2x00.h
29 #define DRV_NAME "rt2x00usb"
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/usb.h>
36 #include "rt2x00usb.h"
39 * Interfacing with the HW.
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,
47 struct usb_device *usb_dev =
48 interface_to_usbdev(rt2x00dev_usb(rt2x00dev));
52 (requesttype == USB_VENDOR_REQUEST_IN) ?
53 usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0);
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 * -ETIMEDOUT: We need a bit more time to complete.
65 * -ENODEV: Device has disappeared, no point continuing.
67 if (status == -ETIMEDOUT)
69 else if (status == -ENODEV)
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_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)
89 * Check for Cache availability.
91 if (unlikely(!rt2x00dev->csr_cache || buffer_length > CSR_CACHE_SIZE)) {
92 ERROR(rt2x00dev, "CSR cache not available.\n");
96 if (requesttype == USB_VENDOR_REQUEST_OUT)
97 memcpy(rt2x00dev->csr_cache, buffer, buffer_length);
99 status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype,
100 offset, 0, rt2x00dev->csr_cache,
101 buffer_length, timeout);
103 if (!status && requesttype == USB_VENDOR_REQUEST_IN)
104 memcpy(buffer, rt2x00dev->csr_cache, buffer_length);
108 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
113 static void rt2x00usb_interrupt_txdone(struct urb *urb)
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;
122 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
123 !__test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags))
126 rt2x00_desc_read(txd, 0, &word);
129 * Remove the descriptor data from the buffer.
131 skb_pull(entry->skb, ring->desc_size);
134 * Obtain the status about this packet.
136 tx_status = !urb->status ? TX_SUCCESS : TX_FAIL_RETRY;
138 rt2x00lib_txdone(entry, tx_status, 0);
141 * Make this entry available for reuse.
144 rt2x00_ring_index_done_inc(entry->ring);
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.
151 if (!rt2x00_ring_full(ring))
152 ieee80211_wake_queue(rt2x00dev->hw,
153 entry->tx_status.control.queue);
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)
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;
166 if (rt2x00_ring_full(ring)) {
167 ieee80211_stop_queue(rt2x00dev->hw, control->queue);
171 if (test_bit(ENTRY_OWNER_NIC, &entry->flags)) {
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);
181 * Add the descriptor in front of the skb.
183 skb_push(skb, rt2x00dev->hw->extra_tx_headroom);
184 memset(skb->data, 0x00, rt2x00dev->hw->extra_tx_headroom);
186 rt2x00lib_write_tx_desc(rt2x00dev, (struct data_desc *)skb->data,
187 ieee80211hdr, length, control);
188 memcpy(&entry->tx_status.control, control, sizeof(*control));
192 * Length passed to usb_fill_urb cannot be an odd number,
193 * so add 1 byte to make it even.
195 length += rt2x00dev->hw->extra_tx_headroom;
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);
205 rt2x00_ring_index_inc(ring);
207 if (rt2x00_ring_full(ring))
208 ieee80211_stop_queue(rt2x00dev->hw, control->queue);
212 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data);
217 static void rt2x00usb_interrupt_rxdone(struct urb *urb)
219 struct data_entry *entry = (struct data_entry *)urb->context;
220 struct data_ring *ring = entry->ring;
221 struct rt2x00_dev *rt2x00dev = ring->rt2x00dev;
230 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
231 !test_and_clear_bit(ENTRY_OWNER_NIC, &entry->flags))
235 * Check if the received data is simply too small
236 * to be actually valid, or if the urb is signaling
239 if (urb->actual_length < entry->ring->desc_size || urb->status)
242 retval = rt2x00dev->ops->lib->fill_rxdone(entry, &signal, &rssi,
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.
252 frame_size = entry->ring->data_size + entry->ring->desc_size;
253 skb = dev_alloc_skb(frame_size + NET_IP_ALIGN);
257 skb_reserve(skb, NET_IP_ALIGN);
258 skb_put(skb, frame_size);
261 * Trim the skb_buffer to only contain the valid
262 * frame data (so ignore the device's descriptor).
264 skb_trim(entry->skb, size);
267 * Send the frame to rt2x00lib for further processing.
269 rt2x00lib_rxdone(entry, entry->skb, signal, rssi, ofdm);
272 * Replace current entry's skb with the newly allocated one,
273 * and reinitialize the urb.
276 urb->transfer_buffer = entry->skb->data;
277 urb->transfer_buffer_length = entry->skb->len;
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);
285 rt2x00_ring_index_inc(ring);
291 void rt2x00usb_enable_radio(struct rt2x00_dev *rt2x00dev)
293 struct usb_device *usb_dev =
294 interface_to_usbdev(rt2x00dev_usb(rt2x00dev));
295 struct data_ring *ring;
296 struct data_entry *entry;
300 * Initialize the TX rings
302 txringall_for_each(rt2x00dev, ring) {
303 for (i = 0; i < ring->stats.limit; i++)
304 ring->entry[i].flags = 0;
306 rt2x00_ring_index_clear(ring);
310 * Initialize and start the RX ring.
312 rt2x00_ring_index_clear(rt2x00dev->rx);
314 for (i = 0; i < rt2x00dev->rx->stats.limit; i++) {
315 entry = &rt2x00dev->rx->entry[i];
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);
322 __set_bit(ENTRY_OWNER_NIC, &entry->flags);
323 usb_submit_urb(entry->priv, GFP_ATOMIC);
326 EXPORT_SYMBOL_GPL(rt2x00usb_enable_radio);
328 void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
330 struct data_ring *ring;
333 rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0x0000, 0x0000,
339 ring_for_each(rt2x00dev, ring) {
340 for (i = 0; i < ring->stats.limit; i++)
341 usb_kill_urb(ring->entry[i].priv);
344 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
347 * Device initialization handlers.
349 static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
350 struct data_ring *ring)
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)
366 static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
367 struct data_ring *ring)
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);
382 int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
384 struct data_ring *ring;
386 unsigned int entry_size;
393 ring_for_each(rt2x00dev, ring) {
394 status = rt2x00usb_alloc_urb(rt2x00dev, ring);
400 * For the RX ring, skb's should be allocated.
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);
408 skb_reserve(skb, NET_IP_ALIGN);
409 skb_put(skb, entry_size);
411 rt2x00dev->rx->entry[i].skb = skb;
417 rt2x00usb_uninitialize(rt2x00dev);
421 EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
423 void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
425 struct data_ring *ring;
427 ring_for_each(rt2x00dev, ring)
428 rt2x00usb_free_urb(rt2x00dev, ring);
430 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
433 * USB driver handlers.
435 static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev)
437 kfree(rt2x00dev->rf);
438 rt2x00dev->rf = NULL;
440 kfree(rt2x00dev->eeprom);
441 rt2x00dev->eeprom = NULL;
443 kfree(rt2x00dev->csr_cache);
444 rt2x00dev->csr_cache = NULL;
447 static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
449 rt2x00dev->csr_cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL);
450 if (!rt2x00dev->csr_cache)
453 rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
454 if (!rt2x00dev->eeprom)
457 rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
464 ERROR_PROBE("Failed to allocate registers.\n");
466 rt2x00usb_free_reg(rt2x00dev);
471 int rt2x00usb_probe(struct usb_interface *usb_intf,
472 const struct usb_device_id *id)
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;
480 usb_dev = usb_get_dev(usb_dev);
482 hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
484 ERROR_PROBE("Failed to allocate hardware.\n");
486 goto exit_put_device;
489 usb_set_intfdata(usb_intf, hw);
491 rt2x00dev = hw->priv;
492 rt2x00dev->dev = usb_intf;
493 rt2x00dev->ops = ops;
496 retval = rt2x00usb_alloc_reg(rt2x00dev);
498 goto exit_free_device;
500 retval = rt2x00lib_probe_dev(rt2x00dev);
507 rt2x00usb_free_reg(rt2x00dev);
510 ieee80211_free_hw(hw);
513 usb_put_dev(usb_dev);
515 usb_set_intfdata(usb_intf, NULL);
519 EXPORT_SYMBOL_GPL(rt2x00usb_probe);
521 void rt2x00usb_disconnect(struct usb_interface *usb_intf)
523 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
524 struct rt2x00_dev *rt2x00dev = hw->priv;
527 * Free all allocated data.
529 rt2x00lib_remove_dev(rt2x00dev);
530 rt2x00usb_free_reg(rt2x00dev);
531 ieee80211_free_hw(hw);
534 * Free the USB device data.
536 usb_set_intfdata(usb_intf, NULL);
537 usb_put_dev(interface_to_usbdev(usb_intf));
539 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect);
542 int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
544 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
545 struct rt2x00_dev *rt2x00dev = hw->priv;
548 retval = rt2x00lib_suspend(rt2x00dev, state);
552 rt2x00usb_free_reg(rt2x00dev);
555 * Decrease usbdev refcount.
557 usb_put_dev(interface_to_usbdev(usb_intf));
561 EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
563 int rt2x00usb_resume(struct usb_interface *usb_intf)
565 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
566 struct rt2x00_dev *rt2x00dev = hw->priv;
569 usb_get_dev(interface_to_usbdev(usb_intf));
571 retval = rt2x00usb_alloc_reg(rt2x00dev);
575 retval = rt2x00lib_resume(rt2x00dev);
582 rt2x00usb_free_reg(rt2x00dev);
586 EXPORT_SYMBOL_GPL(rt2x00usb_resume);
587 #endif /* CONFIG_PM */
590 * rt2x00pci module information.
592 MODULE_AUTHOR(DRV_PROJECT);
593 MODULE_VERSION(DRV_VERSION);
594 MODULE_DESCRIPTION("rt2x00 library");
595 MODULE_LICENSE("GPL");