blob: f72b3d07a42d1037e25827ab5005d222fcbd8eae [file] [log] [blame]
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001/*
Ivo van Doorn811aa9c2008-02-03 15:42:53 +01002 Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
Ivo van Doorn95ea3622007-09-25 17:57:13 -07003 <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
Ivo van Doorn95ea3622007-09-25 17:57:13 -070026#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/usb.h>
Adam Baker3d823462007-10-27 13:43:29 +020029#include <linux/bug.h>
Ivo van Doorn95ea3622007-09-25 17:57:13 -070030
31#include "rt2x00.h"
32#include "rt2x00usb.h"
33
34/*
35 * Interfacing with the HW.
36 */
Adam Baker0e14f6d2007-10-27 13:41:25 +020037int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn95ea3622007-09-25 17:57:13 -070038 const u8 request, const u8 requesttype,
39 const u16 offset, const u16 value,
40 void *buffer, const u16 buffer_length,
Ivo van Doorne9136552007-09-25 20:54:20 +020041 const int timeout)
Ivo van Doorn95ea3622007-09-25 17:57:13 -070042{
Ivo van Doorn181d6902008-02-05 16:42:23 -050043 struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070044 int status;
45 unsigned int i;
46 unsigned int pipe =
47 (requesttype == USB_VENDOR_REQUEST_IN) ?
48 usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0);
49
Adam Baker3d823462007-10-27 13:43:29 +020050
Ivo van Doorn95ea3622007-09-25 17:57:13 -070051 for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
52 status = usb_control_msg(usb_dev, pipe, request, requesttype,
53 value, offset, buffer, buffer_length,
54 timeout);
55 if (status >= 0)
56 return 0;
57
58 /*
Ivo van Doorne9136552007-09-25 20:54:20 +020059 * Check for errors
Ivo van Doorn95ea3622007-09-25 17:57:13 -070060 * -ENODEV: Device has disappeared, no point continuing.
Ivo van Doorne9136552007-09-25 20:54:20 +020061 * All other errors: Try again.
Ivo van Doorn95ea3622007-09-25 17:57:13 -070062 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -070063 else if (status == -ENODEV)
64 break;
65 }
66
67 ERROR(rt2x00dev,
68 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
69 request, offset, status);
70
71 return status;
72}
73EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request);
74
Adam Baker3d823462007-10-27 13:43:29 +020075int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev,
76 const u8 request, const u8 requesttype,
77 const u16 offset, void *buffer,
78 const u16 buffer_length, const int timeout)
Ivo van Doorn95ea3622007-09-25 17:57:13 -070079{
80 int status;
81
Adam Baker3d823462007-10-27 13:43:29 +020082 BUG_ON(!mutex_is_locked(&rt2x00dev->usb_cache_mutex));
83
Ivo van Doorn95ea3622007-09-25 17:57:13 -070084 /*
85 * Check for Cache availability.
86 */
Ivo van Doorn21795092008-02-10 22:49:13 +010087 if (unlikely(!rt2x00dev->csr.cache || buffer_length > CSR_CACHE_SIZE)) {
Ivo van Doorn95ea3622007-09-25 17:57:13 -070088 ERROR(rt2x00dev, "CSR cache not available.\n");
89 return -ENOMEM;
90 }
91
92 if (requesttype == USB_VENDOR_REQUEST_OUT)
Ivo van Doorn21795092008-02-10 22:49:13 +010093 memcpy(rt2x00dev->csr.cache, buffer, buffer_length);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070094
95 status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype,
Ivo van Doorn21795092008-02-10 22:49:13 +010096 offset, 0, rt2x00dev->csr.cache,
Ivo van Doorn95ea3622007-09-25 17:57:13 -070097 buffer_length, timeout);
98
99 if (!status && requesttype == USB_VENDOR_REQUEST_IN)
Ivo van Doorn21795092008-02-10 22:49:13 +0100100 memcpy(buffer, rt2x00dev->csr.cache, buffer_length);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700101
102 return status;
103}
Adam Baker3d823462007-10-27 13:43:29 +0200104EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock);
105
106int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev,
107 const u8 request, const u8 requesttype,
108 const u16 offset, void *buffer,
109 const u16 buffer_length, const int timeout)
110{
111 int status;
112
113 mutex_lock(&rt2x00dev->usb_cache_mutex);
114
115 status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
116 requesttype, offset, buffer,
117 buffer_length, timeout);
118
119 mutex_unlock(&rt2x00dev->usb_cache_mutex);
120
121 return status;
122}
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700123EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
124
125/*
126 * TX data handlers.
127 */
128static void rt2x00usb_interrupt_txdone(struct urb *urb)
129{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500130 struct queue_entry *entry = (struct queue_entry *)urb->context;
131 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
132 struct queue_entry_priv_usb_tx *priv_tx = entry->priv_data;
133 struct txdone_entry_desc txdesc;
Ivo van Doorn4bd7c452008-01-24 00:48:03 -0800134 __le32 *txd = (__le32 *)entry->skb->data;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700135 u32 word;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700136
137 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
Ivo van Doorn181d6902008-02-05 16:42:23 -0500138 !__test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700139 return;
140
141 rt2x00_desc_read(txd, 0, &word);
142
143 /*
144 * Remove the descriptor data from the buffer.
145 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500146 skb_pull(entry->skb, entry->queue->desc_size);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700147
148 /*
149 * Obtain the status about this packet.
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200150 * Note that when the status is 0 it does not mean the
151 * frame was send out correctly. It only means the frame
152 * was succesfully pushed to the hardware, we have no
153 * way to determine the transmission status right now.
154 * (Only indirectly by looking at the failed TX counters
155 * in the register).
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700156 */
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200157 if (!urb->status)
158 __set_bit(TXDONE_UNKNOWN, &txdesc.flags);
159 else
160 __set_bit(TXDONE_FAILURE, &txdesc.flags);
Ivo van Doorn181d6902008-02-05 16:42:23 -0500161 txdesc.retry = 0;
162 txdesc.control = &priv_tx->control;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700163
Ivo van Doorn181d6902008-02-05 16:42:23 -0500164 rt2x00lib_txdone(entry, &txdesc);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700165
166 /*
167 * Make this entry available for reuse.
168 */
169 entry->flags = 0;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500170 rt2x00queue_index_inc(entry->queue, Q_INDEX_DONE);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700171
172 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500173 * If the data queue was full before the txdone handler
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700174 * we must make sure the packet queue in the mac80211 stack
175 * is reenabled when the txdone handler has finished.
176 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500177 if (!rt2x00queue_full(entry->queue))
178 ieee80211_wake_queue(rt2x00dev->hw, priv_tx->control.queue);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700179}
180
181int rt2x00usb_write_tx_data(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn181d6902008-02-05 16:42:23 -0500182 struct data_queue *queue, struct sk_buff *skb,
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700183 struct ieee80211_tx_control *control)
184{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500185 struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev);
186 struct queue_entry *entry = rt2x00queue_get_entry(queue, Q_INDEX);
187 struct queue_entry_priv_usb_tx *priv_tx = entry->priv_data;
188 struct skb_frame_desc *skbdesc;
Ivo van Doorndd9fa2d2007-10-06 14:15:46 +0200189 u32 length;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700190
Ivo van Doorn181d6902008-02-05 16:42:23 -0500191 if (rt2x00queue_full(queue))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700192 return -EINVAL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700193
Ivo van Doorn181d6902008-02-05 16:42:23 -0500194 if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags)) {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700195 ERROR(rt2x00dev,
196 "Arrived at non-free entry in the non-full queue %d.\n"
197 "Please file bug report to %s.\n",
Ivo van Doorne58c6ac2008-04-21 19:00:47 +0200198 entry->queue->qid, DRV_PROJECT);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700199 return -EINVAL;
200 }
201
202 /*
203 * Add the descriptor in front of the skb.
204 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500205 skb_push(skb, queue->desc_size);
206 memset(skb->data, 0, queue->desc_size);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700207
Ivo van Doorn08992f72008-01-24 01:56:25 -0800208 /*
209 * Fill in skb descriptor
210 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500211 skbdesc = get_skb_frame_desc(skb);
Ivo van Doorn181d6902008-02-05 16:42:23 -0500212 skbdesc->data = skb->data + queue->desc_size;
Ivo van Doorn647d0ca2008-02-10 22:51:21 +0100213 skbdesc->data_len = skb->len - queue->desc_size;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500214 skbdesc->desc = skb->data;
215 skbdesc->desc_len = queue->desc_size;
216 skbdesc->entry = entry;
Ivo van Doorn08992f72008-01-24 01:56:25 -0800217
Mattias Nissler92f5ac62008-03-09 22:38:54 +0100218 memcpy(&priv_tx->control, control, sizeof(priv_tx->control));
Ivo van Doorn08992f72008-01-24 01:56:25 -0800219 rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700220
221 /*
Ivo van Doorndd9fa2d2007-10-06 14:15:46 +0200222 * USB devices cannot blindly pass the skb->len as the
223 * length of the data to usb_fill_bulk_urb. Pass the skb
224 * to the driver to determine what the length should be.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700225 */
Ivo van Doornb242e892007-11-15 23:41:31 +0100226 length = rt2x00dev->ops->lib->get_tx_data_len(rt2x00dev, skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700227
Ivo van Doorndd9fa2d2007-10-06 14:15:46 +0200228 /*
229 * Initialize URB and send the frame to the device.
230 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500231 __set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
232 usb_fill_bulk_urb(priv_tx->urb, usb_dev, usb_sndbulkpipe(usb_dev, 1),
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700233 skb->data, length, rt2x00usb_interrupt_txdone, entry);
Ivo van Doorn181d6902008-02-05 16:42:23 -0500234 usb_submit_urb(priv_tx->urb, GFP_ATOMIC);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700235
Ivo van Doorn181d6902008-02-05 16:42:23 -0500236 rt2x00queue_index_inc(queue, Q_INDEX);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700237
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700238 return 0;
239}
240EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data);
241
242/*
243 * RX data handlers.
244 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500245static struct sk_buff* rt2x00usb_alloc_rxskb(struct data_queue *queue)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700246{
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700247 struct sk_buff *skb;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500248 unsigned int frame_size;
Ivo van Doorn70a96102008-05-10 13:43:38 +0200249 unsigned int reserved_size;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700250
251 /*
Ivo van Doorn70a96102008-05-10 13:43:38 +0200252 * The frame size includes descriptor size, because the
253 * hardware directly receive the frame into the skbuffer.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700254 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500255 frame_size = queue->data_size + queue->desc_size;
Ivo van Doorn70a96102008-05-10 13:43:38 +0200256
257 /*
258 * For the allocation we should keep a few things in mind:
259 * 1) 4byte alignment of 802.11 payload
260 *
261 * For (1) we need at most 4 bytes to guarentee the correct
262 * alignment. We are going to optimize the fact that the chance
263 * that the 802.11 header_size % 4 == 2 is much bigger then
264 * anything else. However since we need to move the frame up
265 * to 3 bytes to the front, which means we need to preallocate
266 * 6 bytes.
267 */
268 reserved_size = 6;
269
270 /*
271 * Allocate skbuffer.
272 */
273 skb = dev_alloc_skb(frame_size + reserved_size);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700274 if (!skb)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500275 return NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700276
Ivo van Doorn70a96102008-05-10 13:43:38 +0200277 skb_reserve(skb, reserved_size);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700278 skb_put(skb, frame_size);
279
Ivo van Doorn181d6902008-02-05 16:42:23 -0500280 return skb;
281}
Ivo van Doornc5d0dc52008-01-06 23:40:27 +0100282
Ivo van Doorn181d6902008-02-05 16:42:23 -0500283static void rt2x00usb_interrupt_rxdone(struct urb *urb)
284{
285 struct queue_entry *entry = (struct queue_entry *)urb->context;
286 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
287 struct sk_buff *skb;
288 struct skb_frame_desc *skbdesc;
289 struct rxdone_entry_desc rxdesc;
Ivo van Doorn70a96102008-05-10 13:43:38 +0200290 unsigned int header_size;
291 unsigned int align;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500292
293 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
294 !test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
295 return;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700296
297 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500298 * Check if the received data is simply too small
299 * to be actually valid, or if the urb is signaling
300 * a problem.
Ivo van Doorn08992f72008-01-24 01:56:25 -0800301 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500302 if (urb->actual_length < entry->queue->desc_size || urb->status)
303 goto skip_entry;
304
305 /*
306 * Fill in skb descriptor
307 */
308 skbdesc = get_skb_frame_desc(entry->skb);
309 memset(skbdesc, 0, sizeof(*skbdesc));
310 skbdesc->entry = entry;
311
312 memset(&rxdesc, 0, sizeof(rxdesc));
313 rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
314
Ivo van Doorn70a96102008-05-10 13:43:38 +0200315 header_size = ieee80211_get_hdrlen_from_skb(entry->skb);
316
Ivo van Doorn181d6902008-02-05 16:42:23 -0500317 /*
Ivo van Doornf855c102008-03-09 22:38:18 +0100318 * The data behind the ieee80211 header must be
Ivo van Doorn70a96102008-05-10 13:43:38 +0200319 * aligned on a 4 byte boundary. We already reserved
320 * 2 bytes for header_size % 4 == 2 optimization.
321 * To determine the number of bytes which the data
322 * should be moved to the left, we must add these
323 * 2 bytes to the header_size.
Ivo van Doornf855c102008-03-09 22:38:18 +0100324 */
Ivo van Doorn70a96102008-05-10 13:43:38 +0200325 align = (header_size + 2) % 4;
326
327 if (align) {
328 skb_push(entry->skb, align);
329 /* Move entire frame in 1 command */
330 memmove(entry->skb->data, entry->skb->data + align,
331 rxdesc.size);
Ivo van Doornf855c102008-03-09 22:38:18 +0100332 }
333
Ivo van Doorn70a96102008-05-10 13:43:38 +0200334 /* Update data pointers, trim buffer to correct size */
335 skbdesc->data = entry->skb->data;
336 skb_trim(entry->skb, rxdesc.size);
337
Ivo van Doornf855c102008-03-09 22:38:18 +0100338 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500339 * Allocate a new sk buffer to replace the current one.
340 * If allocation fails, we should drop the current frame
341 * so we can recycle the existing sk buffer for the new frame.
342 */
343 skb = rt2x00usb_alloc_rxskb(entry->queue);
344 if (!skb)
345 goto skip_entry;
Ivo van Doorn08992f72008-01-24 01:56:25 -0800346
347 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700348 * Send the frame to rt2x00lib for further processing.
349 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500350 rt2x00lib_rxdone(entry, &rxdesc);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700351
352 /*
353 * Replace current entry's skb with the newly allocated one,
354 * and reinitialize the urb.
355 */
356 entry->skb = skb;
357 urb->transfer_buffer = entry->skb->data;
358 urb->transfer_buffer_length = entry->skb->len;
359
360skip_entry:
Ivo van Doorn181d6902008-02-05 16:42:23 -0500361 if (test_bit(DEVICE_ENABLED_RADIO, &entry->queue->rt2x00dev->flags)) {
362 __set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700363 usb_submit_urb(urb, GFP_ATOMIC);
364 }
365
Ivo van Doorn181d6902008-02-05 16:42:23 -0500366 rt2x00queue_index_inc(entry->queue, Q_INDEX);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700367}
368
369/*
370 * Radio handlers
371 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700372void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
373{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500374 struct queue_entry_priv_usb_rx *priv_rx;
375 struct queue_entry_priv_usb_tx *priv_tx;
Ivo van Doorn330e3f92008-02-10 22:52:36 +0100376 struct queue_entry_priv_usb_bcn *priv_bcn;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500377 struct data_queue *queue;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700378 unsigned int i;
379
Ivo van Doornbd394a72008-04-21 19:01:58 +0200380 rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700381 REGISTER_TIMEOUT);
382
383 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500384 * Cancel all queues.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700385 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500386 for (i = 0; i < rt2x00dev->rx->limit; i++) {
387 priv_rx = rt2x00dev->rx->entries[i].priv_data;
388 usb_kill_urb(priv_rx->urb);
389 }
390
Ivo van Doorn330e3f92008-02-10 22:52:36 +0100391 tx_queue_for_each(rt2x00dev, queue) {
Ivo van Doorn181d6902008-02-05 16:42:23 -0500392 for (i = 0; i < queue->limit; i++) {
393 priv_tx = queue->entries[i].priv_data;
394 usb_kill_urb(priv_tx->urb);
395 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700396 }
Ivo van Doorn330e3f92008-02-10 22:52:36 +0100397
398 for (i = 0; i < rt2x00dev->bcn->limit; i++) {
399 priv_bcn = rt2x00dev->bcn->entries[i].priv_data;
400 usb_kill_urb(priv_bcn->urb);
401
402 if (priv_bcn->guardian_urb)
403 usb_kill_urb(priv_bcn->guardian_urb);
404 }
405
406 if (!test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags))
407 return;
408
409 for (i = 0; i < rt2x00dev->bcn[1].limit; i++) {
410 priv_tx = rt2x00dev->bcn[1].entries[i].priv_data;
411 usb_kill_urb(priv_tx->urb);
412 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700413}
414EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
415
416/*
417 * Device initialization handlers.
418 */
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100419void rt2x00usb_init_rxentry(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn181d6902008-02-05 16:42:23 -0500420 struct queue_entry *entry)
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100421{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500422 struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev);
423 struct queue_entry_priv_usb_rx *priv_rx = entry->priv_data;
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100424
Ivo van Doorn181d6902008-02-05 16:42:23 -0500425 usb_fill_bulk_urb(priv_rx->urb, usb_dev,
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100426 usb_rcvbulkpipe(usb_dev, 1),
427 entry->skb->data, entry->skb->len,
428 rt2x00usb_interrupt_rxdone, entry);
429
Ivo van Doorn181d6902008-02-05 16:42:23 -0500430 __set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
431 usb_submit_urb(priv_rx->urb, GFP_ATOMIC);
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100432}
433EXPORT_SYMBOL_GPL(rt2x00usb_init_rxentry);
434
435void rt2x00usb_init_txentry(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn181d6902008-02-05 16:42:23 -0500436 struct queue_entry *entry)
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100437{
438 entry->flags = 0;
439}
440EXPORT_SYMBOL_GPL(rt2x00usb_init_txentry);
441
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700442static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn181d6902008-02-05 16:42:23 -0500443 struct data_queue *queue)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700444{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500445 struct queue_entry_priv_usb_rx *priv_rx;
446 struct queue_entry_priv_usb_tx *priv_tx;
447 struct queue_entry_priv_usb_bcn *priv_bcn;
448 struct urb *urb;
449 unsigned int guardian =
450 test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700451 unsigned int i;
452
453 /*
454 * Allocate the URB's
455 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500456 for (i = 0; i < queue->limit; i++) {
457 urb = usb_alloc_urb(0, GFP_KERNEL);
458 if (!urb)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700459 return -ENOMEM;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500460
461 if (queue->qid == QID_RX) {
462 priv_rx = queue->entries[i].priv_data;
463 priv_rx->urb = urb;
464 } else if (queue->qid == QID_MGMT && guardian) {
465 priv_bcn = queue->entries[i].priv_data;
466 priv_bcn->urb = urb;
467
468 urb = usb_alloc_urb(0, GFP_KERNEL);
469 if (!urb)
470 return -ENOMEM;
471
472 priv_bcn->guardian_urb = urb;
473 } else {
474 priv_tx = queue->entries[i].priv_data;
475 priv_tx->urb = urb;
476 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700477 }
478
479 return 0;
480}
481
482static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn181d6902008-02-05 16:42:23 -0500483 struct data_queue *queue)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700484{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500485 struct queue_entry_priv_usb_rx *priv_rx;
486 struct queue_entry_priv_usb_tx *priv_tx;
487 struct queue_entry_priv_usb_bcn *priv_bcn;
488 struct urb *urb;
489 unsigned int guardian =
490 test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700491 unsigned int i;
492
Ivo van Doorn181d6902008-02-05 16:42:23 -0500493 if (!queue->entries)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700494 return;
495
Ivo van Doorn181d6902008-02-05 16:42:23 -0500496 for (i = 0; i < queue->limit; i++) {
497 if (queue->qid == QID_RX) {
498 priv_rx = queue->entries[i].priv_data;
499 urb = priv_rx->urb;
500 } else if (queue->qid == QID_MGMT && guardian) {
501 priv_bcn = queue->entries[i].priv_data;
502
503 usb_kill_urb(priv_bcn->guardian_urb);
504 usb_free_urb(priv_bcn->guardian_urb);
505
506 urb = priv_bcn->urb;
507 } else {
508 priv_tx = queue->entries[i].priv_data;
509 urb = priv_tx->urb;
510 }
511
512 usb_kill_urb(urb);
513 usb_free_urb(urb);
514 if (queue->entries[i].skb)
515 kfree_skb(queue->entries[i].skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700516 }
517}
518
519int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
520{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500521 struct data_queue *queue;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700522 struct sk_buff *skb;
523 unsigned int entry_size;
524 unsigned int i;
Andrew Morton73738002008-01-16 02:58:24 -0800525 int uninitialized_var(status);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700526
527 /*
528 * Allocate DMA
529 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500530 queue_for_each(rt2x00dev, queue) {
531 status = rt2x00usb_alloc_urb(rt2x00dev, queue);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700532 if (status)
533 goto exit;
534 }
535
536 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500537 * For the RX queue, skb's should be allocated.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700538 */
539 entry_size = rt2x00dev->rx->data_size + rt2x00dev->rx->desc_size;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500540 for (i = 0; i < rt2x00dev->rx->limit; i++) {
541 skb = rt2x00usb_alloc_rxskb(rt2x00dev->rx);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700542 if (!skb)
543 goto exit;
544
Ivo van Doorn181d6902008-02-05 16:42:23 -0500545 rt2x00dev->rx->entries[i].skb = skb;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700546 }
547
548 return 0;
549
550exit:
551 rt2x00usb_uninitialize(rt2x00dev);
552
553 return status;
554}
555EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
556
557void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
558{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500559 struct data_queue *queue;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700560
Ivo van Doorn181d6902008-02-05 16:42:23 -0500561 queue_for_each(rt2x00dev, queue)
562 rt2x00usb_free_urb(rt2x00dev, queue);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700563}
564EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
565
566/*
567 * USB driver handlers.
568 */
569static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev)
570{
571 kfree(rt2x00dev->rf);
572 rt2x00dev->rf = NULL;
573
574 kfree(rt2x00dev->eeprom);
575 rt2x00dev->eeprom = NULL;
576
Ivo van Doorn21795092008-02-10 22:49:13 +0100577 kfree(rt2x00dev->csr.cache);
578 rt2x00dev->csr.cache = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700579}
580
581static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
582{
Ivo van Doorn21795092008-02-10 22:49:13 +0100583 rt2x00dev->csr.cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL);
584 if (!rt2x00dev->csr.cache)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700585 goto exit;
586
587 rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
588 if (!rt2x00dev->eeprom)
589 goto exit;
590
591 rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
592 if (!rt2x00dev->rf)
593 goto exit;
594
595 return 0;
596
597exit:
598 ERROR_PROBE("Failed to allocate registers.\n");
599
600 rt2x00usb_free_reg(rt2x00dev);
601
602 return -ENOMEM;
603}
604
605int rt2x00usb_probe(struct usb_interface *usb_intf,
606 const struct usb_device_id *id)
607{
608 struct usb_device *usb_dev = interface_to_usbdev(usb_intf);
609 struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info;
610 struct ieee80211_hw *hw;
611 struct rt2x00_dev *rt2x00dev;
612 int retval;
613
614 usb_dev = usb_get_dev(usb_dev);
615
616 hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
617 if (!hw) {
618 ERROR_PROBE("Failed to allocate hardware.\n");
619 retval = -ENOMEM;
620 goto exit_put_device;
621 }
622
623 usb_set_intfdata(usb_intf, hw);
624
625 rt2x00dev = hw->priv;
626 rt2x00dev->dev = usb_intf;
627 rt2x00dev->ops = ops;
628 rt2x00dev->hw = hw;
Adam Baker3d823462007-10-27 13:43:29 +0200629 mutex_init(&rt2x00dev->usb_cache_mutex);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700630
Ivo van Doornb242e892007-11-15 23:41:31 +0100631 rt2x00dev->usb_maxpacket =
632 usb_maxpacket(usb_dev, usb_sndbulkpipe(usb_dev, 1), 1);
633 if (!rt2x00dev->usb_maxpacket)
634 rt2x00dev->usb_maxpacket = 1;
635
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700636 retval = rt2x00usb_alloc_reg(rt2x00dev);
637 if (retval)
638 goto exit_free_device;
639
640 retval = rt2x00lib_probe_dev(rt2x00dev);
641 if (retval)
642 goto exit_free_reg;
643
644 return 0;
645
646exit_free_reg:
647 rt2x00usb_free_reg(rt2x00dev);
648
649exit_free_device:
650 ieee80211_free_hw(hw);
651
652exit_put_device:
653 usb_put_dev(usb_dev);
654
655 usb_set_intfdata(usb_intf, NULL);
656
657 return retval;
658}
659EXPORT_SYMBOL_GPL(rt2x00usb_probe);
660
661void rt2x00usb_disconnect(struct usb_interface *usb_intf)
662{
663 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
664 struct rt2x00_dev *rt2x00dev = hw->priv;
665
666 /*
667 * Free all allocated data.
668 */
669 rt2x00lib_remove_dev(rt2x00dev);
670 rt2x00usb_free_reg(rt2x00dev);
671 ieee80211_free_hw(hw);
672
673 /*
674 * Free the USB device data.
675 */
676 usb_set_intfdata(usb_intf, NULL);
677 usb_put_dev(interface_to_usbdev(usb_intf));
678}
679EXPORT_SYMBOL_GPL(rt2x00usb_disconnect);
680
681#ifdef CONFIG_PM
682int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
683{
684 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
685 struct rt2x00_dev *rt2x00dev = hw->priv;
686 int retval;
687
688 retval = rt2x00lib_suspend(rt2x00dev, state);
689 if (retval)
690 return retval;
691
692 rt2x00usb_free_reg(rt2x00dev);
693
694 /*
695 * Decrease usbdev refcount.
696 */
697 usb_put_dev(interface_to_usbdev(usb_intf));
698
699 return 0;
700}
701EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
702
703int rt2x00usb_resume(struct usb_interface *usb_intf)
704{
705 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
706 struct rt2x00_dev *rt2x00dev = hw->priv;
707 int retval;
708
709 usb_get_dev(interface_to_usbdev(usb_intf));
710
711 retval = rt2x00usb_alloc_reg(rt2x00dev);
712 if (retval)
713 return retval;
714
715 retval = rt2x00lib_resume(rt2x00dev);
716 if (retval)
717 goto exit_free_reg;
718
719 return 0;
720
721exit_free_reg:
722 rt2x00usb_free_reg(rt2x00dev);
723
724 return retval;
725}
726EXPORT_SYMBOL_GPL(rt2x00usb_resume);
727#endif /* CONFIG_PM */
728
729/*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500730 * rt2x00usb module information.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700731 */
732MODULE_AUTHOR(DRV_PROJECT);
733MODULE_VERSION(DRV_VERSION);
Ivo van Doorn181d6902008-02-05 16:42:23 -0500734MODULE_DESCRIPTION("rt2x00 usb library");
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700735MODULE_LICENSE("GPL");