Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1 | /* |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 2 | Copyright (C) 2010 Willow Garage <http://www.willowgarage.com> |
| 3 | Copyright (C) 2009 - 2010 Ivo van Doorn <IvDoorn@gmail.com> |
Gertjan van Wingerde | 9c9a0d1 | 2009-11-08 16:39:55 +0100 | [diff] [blame] | 4 | Copyright (C) 2009 Mattias Nissler <mattias.nissler@gmx.de> |
| 5 | Copyright (C) 2009 Felix Fietkau <nbd@openwrt.org> |
| 6 | Copyright (C) 2009 Xose Vazquez Perez <xose.vazquez@gmail.com> |
| 7 | Copyright (C) 2009 Axel Kollhofer <rain_maker@root-forum.org> |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 8 | <http://rt2x00.serialmonkey.com> |
| 9 | |
| 10 | This program is free software; you can redistribute it and/or modify |
| 11 | it under the terms of the GNU General Public License as published by |
| 12 | the Free Software Foundation; either version 2 of the License, or |
| 13 | (at your option) any later version. |
| 14 | |
| 15 | This program is distributed in the hope that it will be useful, |
| 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | GNU General Public License for more details. |
| 19 | |
| 20 | You should have received a copy of the GNU General Public License |
| 21 | along with this program; if not, write to the |
| 22 | Free Software Foundation, Inc., |
| 23 | 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 24 | */ |
| 25 | |
| 26 | /* |
| 27 | Module: rt2800usb |
| 28 | Abstract: rt2800usb device specific routines. |
| 29 | Supported chipsets: RT2800U. |
| 30 | */ |
| 31 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 32 | #include <linux/delay.h> |
| 33 | #include <linux/etherdevice.h> |
| 34 | #include <linux/init.h> |
| 35 | #include <linux/kernel.h> |
| 36 | #include <linux/module.h> |
| 37 | #include <linux/usb.h> |
| 38 | |
| 39 | #include "rt2x00.h" |
| 40 | #include "rt2x00usb.h" |
Bartlomiej Zolnierkiewicz | 7ef5cc9 | 2009-11-04 18:35:32 +0100 | [diff] [blame] | 41 | #include "rt2800lib.h" |
Bartlomiej Zolnierkiewicz | b54f78a | 2009-11-04 18:35:54 +0100 | [diff] [blame] | 42 | #include "rt2800.h" |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 43 | #include "rt2800usb.h" |
| 44 | |
| 45 | /* |
| 46 | * Allow hardware encryption to be disabled. |
| 47 | */ |
Rusty Russell | eb93992 | 2011-12-19 14:08:01 +0000 | [diff] [blame] | 48 | static bool modparam_nohwcrypt; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 49 | module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO); |
| 50 | MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption."); |
| 51 | |
Gertjan van Wingerde | ad417a5 | 2012-09-03 03:25:51 +0200 | [diff] [blame] | 52 | static bool rt2800usb_hwcrypt_disabled(struct rt2x00_dev *rt2x00dev) |
| 53 | { |
| 54 | return modparam_nohwcrypt; |
| 55 | } |
| 56 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 57 | /* |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 58 | * Queue handlers. |
| 59 | */ |
| 60 | static void rt2800usb_start_queue(struct data_queue *queue) |
| 61 | { |
| 62 | struct rt2x00_dev *rt2x00dev = queue->rt2x00dev; |
| 63 | u32 reg; |
| 64 | |
| 65 | switch (queue->qid) { |
| 66 | case QID_RX: |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 67 | rt2x00usb_register_read(rt2x00dev, MAC_SYS_CTRL, ®); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 68 | rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_RX, 1); |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 69 | rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 70 | break; |
| 71 | case QID_BEACON: |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 72 | rt2x00usb_register_read(rt2x00dev, BCN_TIME_CFG, ®); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 73 | rt2x00_set_field32(®, BCN_TIME_CFG_TSF_TICKING, 1); |
| 74 | rt2x00_set_field32(®, BCN_TIME_CFG_TBTT_ENABLE, 1); |
| 75 | rt2x00_set_field32(®, BCN_TIME_CFG_BEACON_GEN, 1); |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 76 | rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 77 | break; |
| 78 | default: |
| 79 | break; |
| 80 | } |
| 81 | } |
| 82 | |
| 83 | static void rt2800usb_stop_queue(struct data_queue *queue) |
| 84 | { |
| 85 | struct rt2x00_dev *rt2x00dev = queue->rt2x00dev; |
| 86 | u32 reg; |
| 87 | |
| 88 | switch (queue->qid) { |
| 89 | case QID_RX: |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 90 | rt2x00usb_register_read(rt2x00dev, MAC_SYS_CTRL, ®); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 91 | rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_RX, 0); |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 92 | rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 93 | break; |
| 94 | case QID_BEACON: |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 95 | rt2x00usb_register_read(rt2x00dev, BCN_TIME_CFG, ®); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 96 | rt2x00_set_field32(®, BCN_TIME_CFG_TSF_TICKING, 0); |
| 97 | rt2x00_set_field32(®, BCN_TIME_CFG_TBTT_ENABLE, 0); |
| 98 | rt2x00_set_field32(®, BCN_TIME_CFG_BEACON_GEN, 0); |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 99 | rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 100 | break; |
| 101 | default: |
| 102 | break; |
| 103 | } |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 104 | } |
| 105 | |
Johannes Stezenbach | f0187a1 | 2011-04-18 15:30:36 +0200 | [diff] [blame] | 106 | /* |
| 107 | * test if there is an entry in any TX queue for which DMA is done |
| 108 | * but the TX status has not been returned yet |
| 109 | */ |
| 110 | static bool rt2800usb_txstatus_pending(struct rt2x00_dev *rt2x00dev) |
| 111 | { |
| 112 | struct data_queue *queue; |
| 113 | |
| 114 | tx_queue_for_each(rt2x00dev, queue) { |
| 115 | if (rt2x00queue_get_entry(queue, Q_INDEX_DMA_DONE) != |
| 116 | rt2x00queue_get_entry(queue, Q_INDEX_DONE)) |
| 117 | return true; |
| 118 | } |
| 119 | return false; |
| 120 | } |
| 121 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 122 | static inline bool rt2800usb_entry_txstatus_timeout(struct queue_entry *entry) |
| 123 | { |
| 124 | bool tout; |
| 125 | |
| 126 | if (!test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) |
| 127 | return false; |
| 128 | |
| 129 | tout = time_after(jiffies, entry->last_action + msecs_to_jiffies(100)); |
| 130 | if (unlikely(tout)) |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 131 | rt2x00_warn(entry->queue->rt2x00dev, |
| 132 | "TX status timeout for entry %d in queue %d\n", |
| 133 | entry->entry_idx, entry->queue->qid); |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 134 | return tout; |
| 135 | |
| 136 | } |
| 137 | |
| 138 | static bool rt2800usb_txstatus_timeout(struct rt2x00_dev *rt2x00dev) |
| 139 | { |
| 140 | struct data_queue *queue; |
| 141 | struct queue_entry *entry; |
| 142 | |
| 143 | tx_queue_for_each(rt2x00dev, queue) { |
| 144 | entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE); |
| 145 | if (rt2800usb_entry_txstatus_timeout(entry)) |
| 146 | return true; |
| 147 | } |
| 148 | return false; |
| 149 | } |
| 150 | |
Ivo van Doorn | a073fde | 2011-04-30 17:14:23 +0200 | [diff] [blame] | 151 | static bool rt2800usb_tx_sta_fifo_read_completed(struct rt2x00_dev *rt2x00dev, |
Johannes Stezenbach | 0e0d39e | 2011-04-18 15:29:12 +0200 | [diff] [blame] | 152 | int urb_status, u32 tx_status) |
| 153 | { |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 154 | bool valid; |
| 155 | |
Johannes Stezenbach | 0e0d39e | 2011-04-18 15:29:12 +0200 | [diff] [blame] | 156 | if (urb_status) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 157 | rt2x00_warn(rt2x00dev, "TX status read failed %d\n", |
| 158 | urb_status); |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 159 | |
| 160 | goto stop_reading; |
| 161 | } |
| 162 | |
| 163 | valid = rt2x00_get_field32(tx_status, TX_STA_FIFO_VALID); |
| 164 | if (valid) { |
| 165 | if (!kfifo_put(&rt2x00dev->txstatus_fifo, &tx_status)) |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 166 | rt2x00_warn(rt2x00dev, "TX status FIFO overrun\n"); |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 167 | |
| 168 | queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work); |
| 169 | |
| 170 | /* Reschedule urb to read TX status again instantly */ |
| 171 | return true; |
Stanislaw Gruszka | b9fc106 | 2012-03-19 09:39:45 +0100 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | /* Check if there is any entry that timedout waiting on TX status */ |
| 175 | if (rt2800usb_txstatus_timeout(rt2x00dev)) |
| 176 | queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work); |
| 177 | |
| 178 | if (rt2800usb_txstatus_pending(rt2x00dev)) { |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 179 | /* Read register after 250 us */ |
| 180 | hrtimer_start(&rt2x00dev->txstatus_timer, ktime_set(0, 250000), |
| 181 | HRTIMER_MODE_REL); |
Ivo van Doorn | a073fde | 2011-04-30 17:14:23 +0200 | [diff] [blame] | 182 | return false; |
Johannes Stezenbach | 0e0d39e | 2011-04-18 15:29:12 +0200 | [diff] [blame] | 183 | } |
| 184 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 185 | stop_reading: |
| 186 | clear_bit(TX_STATUS_READING, &rt2x00dev->flags); |
| 187 | /* |
| 188 | * There is small race window above, between txstatus pending check and |
| 189 | * clear_bit someone could do rt2x00usb_interrupt_txdone, so recheck |
| 190 | * here again if status reading is needed. |
| 191 | */ |
| 192 | if (rt2800usb_txstatus_pending(rt2x00dev) && |
Stanislaw Gruszka | 4e808a3 | 2012-03-19 15:59:41 +0100 | [diff] [blame] | 193 | !test_and_set_bit(TX_STATUS_READING, &rt2x00dev->flags)) |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 194 | return true; |
| 195 | else |
| 196 | return false; |
| 197 | } |
Ivo van Doorn | a073fde | 2011-04-30 17:14:23 +0200 | [diff] [blame] | 198 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 199 | static void rt2800usb_async_read_tx_status(struct rt2x00_dev *rt2x00dev) |
| 200 | { |
| 201 | |
| 202 | if (test_and_set_bit(TX_STATUS_READING, &rt2x00dev->flags)) |
| 203 | return; |
| 204 | |
| 205 | /* Read TX_STA_FIFO register after 500 us */ |
| 206 | hrtimer_start(&rt2x00dev->txstatus_timer, ktime_set(0, 500000), |
| 207 | HRTIMER_MODE_REL); |
Johannes Stezenbach | 0e0d39e | 2011-04-18 15:29:12 +0200 | [diff] [blame] | 208 | } |
| 209 | |
| 210 | static void rt2800usb_tx_dma_done(struct queue_entry *entry) |
| 211 | { |
| 212 | struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; |
| 213 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 214 | rt2800usb_async_read_tx_status(rt2x00dev); |
Johannes Stezenbach | 0e0d39e | 2011-04-18 15:29:12 +0200 | [diff] [blame] | 215 | } |
| 216 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 217 | static enum hrtimer_restart rt2800usb_tx_sta_fifo_timeout(struct hrtimer *timer) |
Johannes Stezenbach | f0187a1 | 2011-04-18 15:30:36 +0200 | [diff] [blame] | 218 | { |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 219 | struct rt2x00_dev *rt2x00dev = |
| 220 | container_of(timer, struct rt2x00_dev, txstatus_timer); |
Johannes Stezenbach | f0187a1 | 2011-04-18 15:30:36 +0200 | [diff] [blame] | 221 | |
| 222 | rt2x00usb_register_read_async(rt2x00dev, TX_STA_FIFO, |
| 223 | rt2800usb_tx_sta_fifo_read_completed); |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 224 | |
| 225 | return HRTIMER_NORESTART; |
Johannes Stezenbach | f0187a1 | 2011-04-18 15:30:36 +0200 | [diff] [blame] | 226 | } |
| 227 | |
Ivo van Doorn | 5450b7e | 2010-12-13 12:34:22 +0100 | [diff] [blame] | 228 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 229 | * Firmware functions |
| 230 | */ |
| 231 | static char *rt2800usb_get_firmware_name(struct rt2x00_dev *rt2x00dev) |
| 232 | { |
| 233 | return FIRMWARE_RT2870; |
| 234 | } |
| 235 | |
Ivo van Doorn | f31c9a8 | 2010-07-11 12:30:37 +0200 | [diff] [blame] | 236 | static int rt2800usb_write_firmware(struct rt2x00_dev *rt2x00dev, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 237 | const u8 *data, const size_t len) |
| 238 | { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 239 | int status; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 240 | u32 offset; |
| 241 | u32 length; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 242 | |
| 243 | /* |
| 244 | * Check which section of the firmware we need. |
| 245 | */ |
Gertjan van Wingerde | 49e721e | 2010-02-13 20:55:49 +0100 | [diff] [blame] | 246 | if (rt2x00_rt(rt2x00dev, RT2860) || |
| 247 | rt2x00_rt(rt2x00dev, RT2872) || |
| 248 | rt2x00_rt(rt2x00dev, RT3070)) { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 249 | offset = 0; |
| 250 | length = 4096; |
| 251 | } else { |
| 252 | offset = 4096; |
| 253 | length = 4096; |
| 254 | } |
| 255 | |
| 256 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 257 | * Write firmware to device. |
| 258 | */ |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 259 | rt2x00usb_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE, |
| 260 | data + offset, length); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 261 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 262 | rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); |
| 263 | rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 264 | |
| 265 | /* |
| 266 | * Send firmware request to device to load firmware, |
| 267 | * we need to specify a long timeout time. |
| 268 | */ |
| 269 | status = rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, |
| 270 | 0, USB_MODE_FIRMWARE, |
| 271 | REGISTER_TIMEOUT_FIRMWARE); |
| 272 | if (status < 0) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 273 | rt2x00_err(rt2x00dev, "Failed to write Firmware to device\n"); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 274 | return status; |
| 275 | } |
| 276 | |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 277 | msleep(10); |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 278 | rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 279 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 280 | return 0; |
| 281 | } |
| 282 | |
| 283 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 284 | * Device state switch handlers. |
| 285 | */ |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 286 | static int rt2800usb_init_registers(struct rt2x00_dev *rt2x00dev) |
| 287 | { |
| 288 | u32 reg; |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 289 | |
| 290 | /* |
| 291 | * Wait until BBP and RF are ready. |
| 292 | */ |
Ivo van Doorn | 5ffddc4 | 2010-08-30 21:13:08 +0200 | [diff] [blame] | 293 | if (rt2800_wait_csr_ready(rt2x00dev)) |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 294 | return -EBUSY; |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 295 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 296 | rt2x00usb_register_read(rt2x00dev, PBF_SYS_CTRL, ®); |
| 297 | rt2x00usb_register_write(rt2x00dev, PBF_SYS_CTRL, reg & ~0x00002000); |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 298 | |
Stanislaw Gruszka | 2a48e8a | 2012-01-24 14:09:08 +0100 | [diff] [blame] | 299 | reg = 0; |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 300 | rt2x00_set_field32(®, MAC_SYS_CTRL_RESET_CSR, 1); |
| 301 | rt2x00_set_field32(®, MAC_SYS_CTRL_RESET_BBP, 1); |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 302 | rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 303 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 304 | rt2x00usb_register_write(rt2x00dev, USB_DMA_CFG, 0x00000000); |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 305 | |
| 306 | rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, 0, |
| 307 | USB_MODE_RESET, REGISTER_TIMEOUT); |
| 308 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 309 | rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 310 | |
| 311 | return 0; |
| 312 | } |
| 313 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 314 | static int rt2800usb_enable_radio(struct rt2x00_dev *rt2x00dev) |
| 315 | { |
| 316 | u32 reg; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 317 | |
Ivo van Doorn | b9a07ae | 2010-08-23 19:55:22 +0200 | [diff] [blame] | 318 | if (unlikely(rt2800_wait_wpdma_ready(rt2x00dev))) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 319 | return -EIO; |
| 320 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 321 | rt2x00usb_register_read(rt2x00dev, USB_DMA_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 322 | rt2x00_set_field32(®, USB_DMA_CFG_PHY_CLEAR, 0); |
Benoit PAPILLAULT | 9c8427d | 2009-12-04 23:47:05 +0100 | [diff] [blame] | 323 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_EN, 0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 324 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_TIMEOUT, 128); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 325 | /* |
| 326 | * Total room for RX frames in kilobytes, PBF might still exceed |
| 327 | * this limit so reduce the number to prevent errors. |
| 328 | */ |
| 329 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_LIMIT, |
Gabor Juhos | 3a28c8a | 2013-05-01 17:17:32 +0200 | [diff] [blame] | 330 | ((rt2x00dev->rx->limit * DATA_FRAME_SIZE) |
Helmut Schaa | efd2f27 | 2010-11-04 20:37:22 +0100 | [diff] [blame] | 331 | / 1024) - 3); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 332 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_EN, 1); |
| 333 | rt2x00_set_field32(®, USB_DMA_CFG_TX_BULK_EN, 1); |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 334 | rt2x00usb_register_write(rt2x00dev, USB_DMA_CFG, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 335 | |
Ivo van Doorn | b9a07ae | 2010-08-23 19:55:22 +0200 | [diff] [blame] | 336 | return rt2800_enable_radio(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 337 | } |
| 338 | |
| 339 | static void rt2800usb_disable_radio(struct rt2x00_dev *rt2x00dev) |
| 340 | { |
Ivo van Doorn | b9a07ae | 2010-08-23 19:55:22 +0200 | [diff] [blame] | 341 | rt2800_disable_radio(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 342 | rt2x00usb_disable_radio(rt2x00dev); |
| 343 | } |
| 344 | |
| 345 | static int rt2800usb_set_state(struct rt2x00_dev *rt2x00dev, |
| 346 | enum dev_state state) |
| 347 | { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 348 | if (state == STATE_AWAKE) |
Ivo van Doorn | 303c7d6 | 2010-11-04 20:40:46 +0100 | [diff] [blame] | 349 | rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 2); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 350 | else |
Ivo van Doorn | 303c7d6 | 2010-11-04 20:40:46 +0100 | [diff] [blame] | 351 | rt2800_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0xff, 2); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 352 | |
| 353 | return 0; |
| 354 | } |
| 355 | |
| 356 | static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev, |
| 357 | enum dev_state state) |
| 358 | { |
| 359 | int retval = 0; |
| 360 | |
| 361 | switch (state) { |
| 362 | case STATE_RADIO_ON: |
| 363 | /* |
| 364 | * Before the radio can be enabled, the device first has |
| 365 | * to be woken up. After that it needs a bit of time |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 366 | * to be fully awake and then the radio can be enabled. |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 367 | */ |
| 368 | rt2800usb_set_state(rt2x00dev, STATE_AWAKE); |
| 369 | msleep(1); |
| 370 | retval = rt2800usb_enable_radio(rt2x00dev); |
| 371 | break; |
| 372 | case STATE_RADIO_OFF: |
| 373 | /* |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 374 | * After the radio has been disabled, the device should |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 375 | * be put to sleep for powersaving. |
| 376 | */ |
| 377 | rt2800usb_disable_radio(rt2x00dev); |
| 378 | rt2800usb_set_state(rt2x00dev, STATE_SLEEP); |
| 379 | break; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 380 | case STATE_RADIO_IRQ_ON: |
| 381 | case STATE_RADIO_IRQ_OFF: |
| 382 | /* No support, but no error either */ |
| 383 | break; |
| 384 | case STATE_DEEP_SLEEP: |
| 385 | case STATE_SLEEP: |
| 386 | case STATE_STANDBY: |
| 387 | case STATE_AWAKE: |
| 388 | retval = rt2800usb_set_state(rt2x00dev, state); |
| 389 | break; |
| 390 | default: |
| 391 | retval = -ENOTSUPP; |
| 392 | break; |
| 393 | } |
| 394 | |
| 395 | if (unlikely(retval)) |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 396 | rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n", |
| 397 | state, retval); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 398 | |
| 399 | return retval; |
| 400 | } |
| 401 | |
| 402 | /* |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 403 | * Watchdog handlers |
| 404 | */ |
| 405 | static void rt2800usb_watchdog(struct rt2x00_dev *rt2x00dev) |
| 406 | { |
| 407 | unsigned int i; |
| 408 | u32 reg; |
| 409 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 410 | rt2x00usb_register_read(rt2x00dev, TXRXQ_PCNT, ®); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 411 | if (rt2x00_get_field32(reg, TXRXQ_PCNT_TX0Q)) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 412 | rt2x00_warn(rt2x00dev, "TX HW queue 0 timed out, invoke forced kick\n"); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 413 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 414 | rt2x00usb_register_write(rt2x00dev, PBF_CFG, 0xf40012); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 415 | |
| 416 | for (i = 0; i < 10; i++) { |
| 417 | udelay(10); |
| 418 | if (!rt2x00_get_field32(reg, TXRXQ_PCNT_TX0Q)) |
| 419 | break; |
| 420 | } |
| 421 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 422 | rt2x00usb_register_write(rt2x00dev, PBF_CFG, 0xf40006); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 423 | } |
| 424 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 425 | rt2x00usb_register_read(rt2x00dev, TXRXQ_PCNT, ®); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 426 | if (rt2x00_get_field32(reg, TXRXQ_PCNT_TX1Q)) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 427 | rt2x00_warn(rt2x00dev, "TX HW queue 1 timed out, invoke forced kick\n"); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 428 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 429 | rt2x00usb_register_write(rt2x00dev, PBF_CFG, 0xf4000a); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 430 | |
| 431 | for (i = 0; i < 10; i++) { |
| 432 | udelay(10); |
| 433 | if (!rt2x00_get_field32(reg, TXRXQ_PCNT_TX1Q)) |
| 434 | break; |
| 435 | } |
| 436 | |
Ivo van Doorn | 8d0a2dc | 2011-04-18 15:34:22 +0200 | [diff] [blame] | 437 | rt2x00usb_register_write(rt2x00dev, PBF_CFG, 0xf40006); |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 438 | } |
| 439 | |
| 440 | rt2x00usb_watchdog(rt2x00dev); |
| 441 | } |
| 442 | |
| 443 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 444 | * TX descriptor initialization |
| 445 | */ |
Ivo van Doorn | 0c5879b | 2010-08-06 20:47:20 +0200 | [diff] [blame] | 446 | static __le32 *rt2800usb_get_txwi(struct queue_entry *entry) |
Gertjan van Wingerde | 9cf4cb0 | 2010-06-29 21:43:03 +0200 | [diff] [blame] | 447 | { |
Ivo van Doorn | 0c5879b | 2010-08-06 20:47:20 +0200 | [diff] [blame] | 448 | if (entry->queue->qid == QID_BEACON) |
| 449 | return (__le32 *) (entry->skb->data); |
| 450 | else |
| 451 | return (__le32 *) (entry->skb->data + TXINFO_DESC_SIZE); |
Gertjan van Wingerde | 9cf4cb0 | 2010-06-29 21:43:03 +0200 | [diff] [blame] | 452 | } |
| 453 | |
Ivo van Doorn | 9333145 | 2010-08-23 19:53:39 +0200 | [diff] [blame] | 454 | static void rt2800usb_write_tx_desc(struct queue_entry *entry, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 455 | struct txentry_desc *txdesc) |
| 456 | { |
Ivo van Doorn | 9333145 | 2010-08-23 19:53:39 +0200 | [diff] [blame] | 457 | struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); |
| 458 | __le32 *txi = (__le32 *) entry->skb->data; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 459 | u32 word; |
| 460 | |
| 461 | /* |
Gertjan van Wingerde | 59679b9 | 2010-05-08 23:40:21 +0200 | [diff] [blame] | 462 | * Initialize TXINFO descriptor |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 463 | */ |
| 464 | rt2x00_desc_read(txi, 0, &word); |
RA-Jay Hung | b43d63b | 2010-11-13 19:11:46 +0100 | [diff] [blame] | 465 | |
| 466 | /* |
| 467 | * The size of TXINFO_W0_USB_DMA_TX_PKT_LEN is |
| 468 | * TXWI + 802.11 header + L2 pad + payload + pad, |
Jakub Kiciński | 4bcafac | 2011-12-28 01:53:21 +0100 | [diff] [blame] | 469 | * so need to decrease size of TXINFO. |
RA-Jay Hung | b43d63b | 2010-11-13 19:11:46 +0100 | [diff] [blame] | 470 | */ |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 471 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN, |
Jakub Kiciński | 4bcafac | 2011-12-28 01:53:21 +0100 | [diff] [blame] | 472 | roundup(entry->skb->len, 4) - TXINFO_DESC_SIZE); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 473 | rt2x00_set_field32(&word, TXINFO_W0_WIV, |
| 474 | !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc->flags)); |
| 475 | rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2); |
| 476 | rt2x00_set_field32(&word, TXINFO_W0_SW_USE_LAST_ROUND, 0); |
| 477 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_NEXT_VALID, 0); |
| 478 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_BURST, |
| 479 | test_bit(ENTRY_TXD_BURST, &txdesc->flags)); |
| 480 | rt2x00_desc_write(txi, 0, word); |
Gertjan van Wingerde | 85b7a8b | 2010-05-11 23:51:40 +0200 | [diff] [blame] | 481 | |
| 482 | /* |
| 483 | * Register descriptor details in skb frame descriptor. |
| 484 | */ |
Gertjan van Wingerde | 0b8004a | 2010-06-03 10:51:45 +0200 | [diff] [blame] | 485 | skbdesc->flags |= SKBDESC_DESC_IN_SKB; |
Gertjan van Wingerde | 85b7a8b | 2010-05-11 23:51:40 +0200 | [diff] [blame] | 486 | skbdesc->desc = txi; |
Stanislaw Gruszka | f0bda57 | 2013-04-17 14:30:47 +0200 | [diff] [blame] | 487 | skbdesc->desc_len = TXINFO_DESC_SIZE + entry->queue->winfo_size; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 488 | } |
| 489 | |
| 490 | /* |
| 491 | * TX data initialization |
| 492 | */ |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 493 | static int rt2800usb_get_tx_data_len(struct queue_entry *entry) |
| 494 | { |
Jakub Kiciński | 4bcafac | 2011-12-28 01:53:21 +0100 | [diff] [blame] | 495 | /* |
| 496 | * pad(1~3 bytes) is needed after each 802.11 payload. |
| 497 | * USB end pad(4 bytes) is needed at each USB bulk out packet end. |
| 498 | * TX frame format is : |
| 499 | * | TXINFO | TXWI | 802.11 header | L2 pad | payload | pad | USB end pad | |
| 500 | * |<------------- tx_pkt_len ------------->| |
| 501 | */ |
| 502 | |
| 503 | return roundup(entry->skb->len, 4) + 4; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 504 | } |
| 505 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 506 | /* |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 507 | * TX control handlers |
| 508 | */ |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 509 | static enum txdone_entry_desc_flags |
| 510 | rt2800usb_txdone_entry_check(struct queue_entry *entry, u32 reg) |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 511 | { |
| 512 | __le32 *txwi; |
| 513 | u32 word; |
| 514 | int wcid, ack, pid; |
Stanislaw Gruszka | 5f8f718 | 2012-03-14 11:16:20 +0100 | [diff] [blame] | 515 | int tx_wcid, tx_ack, tx_pid, is_agg; |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 516 | |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 517 | /* |
| 518 | * This frames has returned with an IO error, |
| 519 | * so the status report is not intended for this |
| 520 | * frame. |
| 521 | */ |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 522 | if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags)) |
| 523 | return TXDONE_FAILURE; |
| 524 | |
| 525 | wcid = rt2x00_get_field32(reg, TX_STA_FIFO_WCID); |
| 526 | ack = rt2x00_get_field32(reg, TX_STA_FIFO_TX_ACK_REQUIRED); |
| 527 | pid = rt2x00_get_field32(reg, TX_STA_FIFO_PID_TYPE); |
Stanislaw Gruszka | 5f8f718 | 2012-03-14 11:16:20 +0100 | [diff] [blame] | 528 | is_agg = rt2x00_get_field32(reg, TX_STA_FIFO_TX_AGGRE); |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 529 | |
| 530 | /* |
| 531 | * Validate if this TX status report is intended for |
| 532 | * this entry by comparing the WCID/ACK/PID fields. |
| 533 | */ |
| 534 | txwi = rt2800usb_get_txwi(entry); |
| 535 | |
| 536 | rt2x00_desc_read(txwi, 1, &word); |
| 537 | tx_wcid = rt2x00_get_field32(word, TXWI_W1_WIRELESS_CLI_ID); |
| 538 | tx_ack = rt2x00_get_field32(word, TXWI_W1_ACK); |
| 539 | tx_pid = rt2x00_get_field32(word, TXWI_W1_PACKETID); |
| 540 | |
Stanislaw Gruszka | 5f8f718 | 2012-03-14 11:16:20 +0100 | [diff] [blame] | 541 | if (wcid != tx_wcid || ack != tx_ack || (!is_agg && pid != tx_pid)) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 542 | rt2x00_dbg(entry->queue->rt2x00dev, |
| 543 | "TX status report missed for queue %d entry %d\n", |
| 544 | entry->queue->qid, entry->entry_idx); |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 545 | return TXDONE_UNKNOWN; |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 546 | } |
| 547 | |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 548 | return TXDONE_SUCCESS; |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 549 | } |
| 550 | |
| 551 | static void rt2800usb_txdone(struct rt2x00_dev *rt2x00dev) |
| 552 | { |
| 553 | struct data_queue *queue; |
| 554 | struct queue_entry *entry; |
| 555 | u32 reg; |
| 556 | u8 qid; |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 557 | enum txdone_entry_desc_flags done_status; |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 558 | |
| 559 | while (kfifo_get(&rt2x00dev->txstatus_fifo, ®)) { |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 560 | /* |
| 561 | * TX_STA_FIFO_PID_QUEUE is a 2-bit field, thus qid is |
| 562 | * guaranteed to be one of the TX QIDs . |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 563 | */ |
| 564 | qid = rt2x00_get_field32(reg, TX_STA_FIFO_PID_QUEUE); |
| 565 | queue = rt2x00queue_get_tx_queue(rt2x00dev, qid); |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 566 | |
| 567 | if (unlikely(rt2x00queue_empty(queue))) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 568 | rt2x00_warn(rt2x00dev, "Got TX status for an empty queue %u, dropping\n", |
| 569 | qid); |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 570 | break; |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 571 | } |
| 572 | |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 573 | entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE); |
| 574 | |
| 575 | if (unlikely(test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) || |
| 576 | !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 577 | rt2x00_warn(rt2x00dev, "Data pending for entry %u in queue %u\n", |
| 578 | entry->entry_idx, qid); |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 579 | break; |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 580 | } |
| 581 | |
Stanislaw Gruszka | ed61e2b | 2012-03-14 11:16:18 +0100 | [diff] [blame] | 582 | done_status = rt2800usb_txdone_entry_check(entry, reg); |
| 583 | if (likely(done_status == TXDONE_SUCCESS)) |
| 584 | rt2800_txdone_entry(entry, reg, rt2800usb_get_txwi(entry)); |
| 585 | else |
| 586 | rt2x00lib_txdone_noinfo(entry, done_status); |
Gertjan van Wingerde | 8f66bbb | 2011-05-18 20:25:49 +0200 | [diff] [blame] | 587 | } |
| 588 | } |
| 589 | |
Stanislaw Gruszka | 627fdaf | 2012-03-14 11:16:17 +0100 | [diff] [blame] | 590 | static void rt2800usb_txdone_nostatus(struct rt2x00_dev *rt2x00dev) |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 591 | { |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 592 | struct data_queue *queue; |
| 593 | struct queue_entry *entry; |
| 594 | |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 595 | /* |
| 596 | * Process any trailing TX status reports for IO failures, |
| 597 | * we loop until we find the first non-IO error entry. This |
| 598 | * can either be a frame which is free, is being uploaded, |
| 599 | * or has completed the upload but didn't have an entry |
| 600 | * in the TX_STAT_FIFO register yet. |
| 601 | */ |
| 602 | tx_queue_for_each(rt2x00dev, queue) { |
| 603 | while (!rt2x00queue_empty(queue)) { |
| 604 | entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE); |
| 605 | |
Stanislaw Gruszka | 4b1bfb7 | 2011-08-10 15:32:22 +0200 | [diff] [blame] | 606 | if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) || |
| 607 | !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 608 | break; |
Stanislaw Gruszka | 4b1bfb7 | 2011-08-10 15:32:22 +0200 | [diff] [blame] | 609 | |
Johannes Stezenbach | 6e6d693 | 2011-04-18 15:30:01 +0200 | [diff] [blame] | 610 | if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags)) |
| 611 | rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE); |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 612 | else if (rt2800usb_entry_txstatus_timeout(entry)) |
Johannes Stezenbach | 6e6d693 | 2011-04-18 15:30:01 +0200 | [diff] [blame] | 613 | rt2x00lib_txdone_noinfo(entry, TXDONE_UNKNOWN); |
| 614 | else |
| 615 | break; |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 616 | } |
| 617 | } |
Stanislaw Gruszka | 627fdaf | 2012-03-14 11:16:17 +0100 | [diff] [blame] | 618 | } |
| 619 | |
| 620 | static void rt2800usb_work_txdone(struct work_struct *work) |
| 621 | { |
| 622 | struct rt2x00_dev *rt2x00dev = |
| 623 | container_of(work, struct rt2x00_dev, txdone_work); |
| 624 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 625 | while (!kfifo_is_empty(&rt2x00dev->txstatus_fifo) || |
| 626 | rt2800usb_txstatus_timeout(rt2x00dev)) { |
Stanislaw Gruszka | 627fdaf | 2012-03-14 11:16:17 +0100 | [diff] [blame] | 627 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 628 | rt2800usb_txdone(rt2x00dev); |
Johannes Stezenbach | f0187a1 | 2011-04-18 15:30:36 +0200 | [diff] [blame] | 629 | |
Stanislaw Gruszka | f421111 | 2012-03-14 11:16:19 +0100 | [diff] [blame] | 630 | rt2800usb_txdone_nostatus(rt2x00dev); |
| 631 | |
| 632 | /* |
| 633 | * The hw may delay sending the packet after DMA complete |
| 634 | * if the medium is busy, thus the TX_STA_FIFO entry is |
| 635 | * also delayed -> use a timer to retrieve it. |
| 636 | */ |
| 637 | if (rt2800usb_txstatus_pending(rt2x00dev)) |
| 638 | rt2800usb_async_read_tx_status(rt2x00dev); |
| 639 | } |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 640 | } |
| 641 | |
| 642 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 643 | * RX control handlers |
| 644 | */ |
| 645 | static void rt2800usb_fill_rxdone(struct queue_entry *entry, |
| 646 | struct rxdone_entry_desc *rxdesc) |
| 647 | { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 648 | struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 649 | __le32 *rxi = (__le32 *)entry->skb->data; |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 650 | __le32 *rxd; |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 651 | u32 word; |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 652 | int rx_pkt_len; |
| 653 | |
| 654 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 655 | * Copy descriptor to the skbdesc->desc buffer, making it safe from |
| 656 | * moving of frame data in rt2x00usb. |
| 657 | */ |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 658 | memcpy(skbdesc->desc, rxi, skbdesc->desc_len); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 659 | |
| 660 | /* |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 661 | * RX frame format is : |
| 662 | * | RXINFO | RXWI | header | L2 pad | payload | pad | RXD | USB pad | |
| 663 | * |<------------ rx_pkt_len -------------->| |
| 664 | */ |
| 665 | rt2x00_desc_read(rxi, 0, &word); |
| 666 | rx_pkt_len = rt2x00_get_field32(word, RXINFO_W0_USB_DMA_RX_PKT_LEN); |
| 667 | |
| 668 | /* |
| 669 | * Remove the RXINFO structure from the sbk. |
| 670 | */ |
| 671 | skb_pull(entry->skb, RXINFO_DESC_SIZE); |
| 672 | |
| 673 | /* |
Sergei Poselenov | efd5d6b | 2012-09-02 13:14:32 +0400 | [diff] [blame] | 674 | * Check for rx_pkt_len validity. Return if invalid, leaving |
| 675 | * rxdesc->size zeroed out by the upper level. |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 676 | */ |
Sergei Poselenov | efd5d6b | 2012-09-02 13:14:32 +0400 | [diff] [blame] | 677 | if (unlikely(rx_pkt_len == 0 || |
| 678 | rx_pkt_len > entry->queue->data_size)) { |
Joe Perches | ec9c498 | 2013-04-19 08:33:40 -0700 | [diff] [blame] | 679 | rt2x00_err(entry->queue->rt2x00dev, |
| 680 | "Bad frame size %d, forcing to 0\n", rx_pkt_len); |
Sergei Poselenov | efd5d6b | 2012-09-02 13:14:32 +0400 | [diff] [blame] | 681 | return; |
| 682 | } |
| 683 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 684 | rxd = (__le32 *)(entry->skb->data + rx_pkt_len); |
| 685 | |
| 686 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 687 | * It is now safe to read the descriptor on all architectures. |
| 688 | */ |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 689 | rt2x00_desc_read(rxd, 0, &word); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 690 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 691 | if (rt2x00_get_field32(word, RXD_W0_CRC_ERROR)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 692 | rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC; |
| 693 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 694 | rxdesc->cipher_status = rt2x00_get_field32(word, RXD_W0_CIPHER_ERROR); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 695 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 696 | if (rt2x00_get_field32(word, RXD_W0_DECRYPTED)) { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 697 | /* |
| 698 | * Hardware has stripped IV/EIV data from 802.11 frame during |
| 699 | * decryption. Unfortunately the descriptor doesn't contain |
| 700 | * any fields with the EIV/IV data either, so they can't |
| 701 | * be restored by rt2x00lib. |
| 702 | */ |
| 703 | rxdesc->flags |= RX_FLAG_IV_STRIPPED; |
| 704 | |
Gertjan van Wingerde | a45f369 | 2011-01-30 13:22:41 +0100 | [diff] [blame] | 705 | /* |
| 706 | * The hardware has already checked the Michael Mic and has |
| 707 | * stripped it from the frame. Signal this to mac80211. |
| 708 | */ |
| 709 | rxdesc->flags |= RX_FLAG_MMIC_STRIPPED; |
| 710 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 711 | if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS) |
| 712 | rxdesc->flags |= RX_FLAG_DECRYPTED; |
| 713 | else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC) |
| 714 | rxdesc->flags |= RX_FLAG_MMIC_ERROR; |
| 715 | } |
| 716 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 717 | if (rt2x00_get_field32(word, RXD_W0_MY_BSS)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 718 | rxdesc->dev_flags |= RXDONE_MY_BSS; |
| 719 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 720 | if (rt2x00_get_field32(word, RXD_W0_L2PAD)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 721 | rxdesc->dev_flags |= RXDONE_L2PAD; |
| 722 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 723 | /* |
| 724 | * Remove RXD descriptor from end of buffer. |
| 725 | */ |
| 726 | skb_trim(entry->skb, rx_pkt_len); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 727 | |
| 728 | /* |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 729 | * Process the RXWI structure. |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 730 | */ |
Ivo van Doorn | 7486192 | 2010-07-11 12:23:50 +0200 | [diff] [blame] | 731 | rt2800_process_rxwi(entry, rxdesc); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 732 | } |
| 733 | |
| 734 | /* |
| 735 | * Device probe functions. |
| 736 | */ |
Gabor Juhos | a02308e | 2012-12-29 14:51:51 +0100 | [diff] [blame] | 737 | static int rt2800usb_read_eeprom(struct rt2x00_dev *rt2x00dev) |
Bartlomiej Zolnierkiewicz | 7ab7132 | 2009-11-08 14:38:54 +0100 | [diff] [blame] | 738 | { |
Gabor Juhos | a02308e | 2012-12-29 14:51:51 +0100 | [diff] [blame] | 739 | int retval; |
| 740 | |
Bartlomiej Zolnierkiewicz | 40beee5 | 2009-11-08 14:39:55 +0100 | [diff] [blame] | 741 | if (rt2800_efuse_detect(rt2x00dev)) |
Gabor Juhos | a02308e | 2012-12-29 14:51:51 +0100 | [diff] [blame] | 742 | retval = rt2800_read_eeprom_efuse(rt2x00dev); |
Bartlomiej Zolnierkiewicz | 40beee5 | 2009-11-08 14:39:55 +0100 | [diff] [blame] | 743 | else |
Gabor Juhos | a02308e | 2012-12-29 14:51:51 +0100 | [diff] [blame] | 744 | retval = rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom, |
| 745 | EEPROM_SIZE); |
| 746 | |
| 747 | return retval; |
Bartlomiej Zolnierkiewicz | 7ab7132 | 2009-11-08 14:38:54 +0100 | [diff] [blame] | 748 | } |
| 749 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 750 | static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev) |
| 751 | { |
| 752 | int retval; |
| 753 | |
Gertjan van Wingerde | ad417a5 | 2012-09-03 03:25:51 +0200 | [diff] [blame] | 754 | retval = rt2800_probe_hw(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 755 | if (retval) |
| 756 | return retval; |
| 757 | |
| 758 | /* |
Gertjan van Wingerde | ad417a5 | 2012-09-03 03:25:51 +0200 | [diff] [blame] | 759 | * Set txstatus timer function. |
Gertjan van Wingerde | a396e10 | 2012-08-31 19:22:11 +0200 | [diff] [blame] | 760 | */ |
Gertjan van Wingerde | ad417a5 | 2012-09-03 03:25:51 +0200 | [diff] [blame] | 761 | rt2x00dev->txstatus_timer.function = rt2800usb_tx_sta_fifo_timeout; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 762 | |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 763 | /* |
| 764 | * Overwrite TX done handler |
| 765 | */ |
| 766 | PREPARE_WORK(&rt2x00dev->txdone_work, rt2800usb_work_txdone); |
| 767 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 768 | return 0; |
| 769 | } |
| 770 | |
Helmut Schaa | e783619 | 2010-07-11 12:28:54 +0200 | [diff] [blame] | 771 | static const struct ieee80211_ops rt2800usb_mac80211_ops = { |
| 772 | .tx = rt2x00mac_tx, |
| 773 | .start = rt2x00mac_start, |
| 774 | .stop = rt2x00mac_stop, |
| 775 | .add_interface = rt2x00mac_add_interface, |
| 776 | .remove_interface = rt2x00mac_remove_interface, |
| 777 | .config = rt2x00mac_config, |
| 778 | .configure_filter = rt2x00mac_configure_filter, |
| 779 | .set_tim = rt2x00mac_set_tim, |
| 780 | .set_key = rt2x00mac_set_key, |
| 781 | .sw_scan_start = rt2x00mac_sw_scan_start, |
| 782 | .sw_scan_complete = rt2x00mac_sw_scan_complete, |
| 783 | .get_stats = rt2x00mac_get_stats, |
| 784 | .get_tkip_seq = rt2800_get_tkip_seq, |
| 785 | .set_rts_threshold = rt2800_set_rts_threshold, |
Helmut Schaa | a2b1328 | 2011-09-08 14:38:01 +0200 | [diff] [blame] | 786 | .sta_add = rt2x00mac_sta_add, |
| 787 | .sta_remove = rt2x00mac_sta_remove, |
Helmut Schaa | e783619 | 2010-07-11 12:28:54 +0200 | [diff] [blame] | 788 | .bss_info_changed = rt2x00mac_bss_info_changed, |
| 789 | .conf_tx = rt2800_conf_tx, |
| 790 | .get_tsf = rt2800_get_tsf, |
| 791 | .rfkill_poll = rt2x00mac_rfkill_poll, |
| 792 | .ampdu_action = rt2800_ampdu_action, |
Ivo van Doorn | f44df18 | 2010-11-04 20:40:11 +0100 | [diff] [blame] | 793 | .flush = rt2x00mac_flush, |
Helmut Schaa | 977206d | 2010-12-13 12:31:58 +0100 | [diff] [blame] | 794 | .get_survey = rt2800_get_survey, |
Ivo van Doorn | e7dee44 | 2011-04-18 15:34:41 +0200 | [diff] [blame] | 795 | .get_ringparam = rt2x00mac_get_ringparam, |
Gertjan van Wingerde | 5f0dd29 | 2011-07-06 23:00:21 +0200 | [diff] [blame] | 796 | .tx_frames_pending = rt2x00mac_tx_frames_pending, |
Helmut Schaa | e783619 | 2010-07-11 12:28:54 +0200 | [diff] [blame] | 797 | }; |
| 798 | |
Ivo van Doorn | e796643 | 2010-07-11 12:31:23 +0200 | [diff] [blame] | 799 | static const struct rt2800_ops rt2800usb_rt2800_ops = { |
| 800 | .register_read = rt2x00usb_register_read, |
| 801 | .register_read_lock = rt2x00usb_register_read_lock, |
| 802 | .register_write = rt2x00usb_register_write, |
| 803 | .register_write_lock = rt2x00usb_register_write_lock, |
| 804 | .register_multiread = rt2x00usb_register_multiread, |
| 805 | .register_multiwrite = rt2x00usb_register_multiwrite, |
| 806 | .regbusy_read = rt2x00usb_regbusy_read, |
Gertjan van Wingerde | ad417a5 | 2012-09-03 03:25:51 +0200 | [diff] [blame] | 807 | .read_eeprom = rt2800usb_read_eeprom, |
| 808 | .hwcrypt_disabled = rt2800usb_hwcrypt_disabled, |
Ivo van Doorn | e796643 | 2010-07-11 12:31:23 +0200 | [diff] [blame] | 809 | .drv_write_firmware = rt2800usb_write_firmware, |
| 810 | .drv_init_registers = rt2800usb_init_registers, |
Ivo van Doorn | 0c5879b | 2010-08-06 20:47:20 +0200 | [diff] [blame] | 811 | .drv_get_txwi = rt2800usb_get_txwi, |
Ivo van Doorn | e796643 | 2010-07-11 12:31:23 +0200 | [diff] [blame] | 812 | }; |
| 813 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 814 | static const struct rt2x00lib_ops rt2800usb_rt2x00_ops = { |
| 815 | .probe_hw = rt2800usb_probe_hw, |
| 816 | .get_firmware_name = rt2800usb_get_firmware_name, |
Ivo van Doorn | f31c9a8 | 2010-07-11 12:30:37 +0200 | [diff] [blame] | 817 | .check_firmware = rt2800_check_firmware, |
| 818 | .load_firmware = rt2800_load_firmware, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 819 | .initialize = rt2x00usb_initialize, |
| 820 | .uninitialize = rt2x00usb_uninitialize, |
| 821 | .clear_entry = rt2x00usb_clear_entry, |
| 822 | .set_device_state = rt2800usb_set_device_state, |
Bartlomiej Zolnierkiewicz | f445061 | 2009-11-04 18:36:40 +0100 | [diff] [blame] | 823 | .rfkill_poll = rt2800_rfkill_poll, |
| 824 | .link_stats = rt2800_link_stats, |
| 825 | .reset_tuner = rt2800_reset_tuner, |
| 826 | .link_tuner = rt2800_link_tuner, |
Helmut Schaa | 9e33a35 | 2011-03-28 13:33:40 +0200 | [diff] [blame] | 827 | .gain_calibration = rt2800_gain_calibration, |
John Li | 2e9c43d | 2012-02-16 21:40:57 +0800 | [diff] [blame] | 828 | .vco_calibration = rt2800_vco_calibration, |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 829 | .watchdog = rt2800usb_watchdog, |
Ivo van Doorn | dbba306 | 2010-12-13 12:34:54 +0100 | [diff] [blame] | 830 | .start_queue = rt2800usb_start_queue, |
| 831 | .kick_queue = rt2x00usb_kick_queue, |
| 832 | .stop_queue = rt2800usb_stop_queue, |
Ivo van Doorn | 5be6560 | 2010-12-13 12:35:40 +0100 | [diff] [blame] | 833 | .flush_queue = rt2x00usb_flush_queue, |
Johannes Stezenbach | 0e0d39e | 2011-04-18 15:29:12 +0200 | [diff] [blame] | 834 | .tx_dma_done = rt2800usb_tx_dma_done, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 835 | .write_tx_desc = rt2800usb_write_tx_desc, |
Jakub Kiciński | 4bcafac | 2011-12-28 01:53:21 +0100 | [diff] [blame] | 836 | .write_tx_data = rt2800_write_tx_data, |
Gertjan van Wingerde | f0194b2 | 2010-06-03 10:51:53 +0200 | [diff] [blame] | 837 | .write_beacon = rt2800_write_beacon, |
Helmut Schaa | 69cf36a | 2011-01-30 13:16:03 +0100 | [diff] [blame] | 838 | .clear_beacon = rt2800_clear_beacon, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 839 | .get_tx_data_len = rt2800usb_get_tx_data_len, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 840 | .fill_rxdone = rt2800usb_fill_rxdone, |
Bartlomiej Zolnierkiewicz | f445061 | 2009-11-04 18:36:40 +0100 | [diff] [blame] | 841 | .config_shared_key = rt2800_config_shared_key, |
| 842 | .config_pairwise_key = rt2800_config_pairwise_key, |
| 843 | .config_filter = rt2800_config_filter, |
| 844 | .config_intf = rt2800_config_intf, |
| 845 | .config_erp = rt2800_config_erp, |
| 846 | .config_ant = rt2800_config_ant, |
| 847 | .config = rt2800_config, |
Helmut Schaa | a2b1328 | 2011-09-08 14:38:01 +0200 | [diff] [blame] | 848 | .sta_add = rt2800_sta_add, |
| 849 | .sta_remove = rt2800_sta_remove, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 850 | }; |
| 851 | |
Gabor Juhos | d36d13a | 2013-06-04 13:40:43 +0200 | [diff] [blame] | 852 | static void rt2800usb_queue_init(struct data_queue *queue) |
| 853 | { |
| 854 | struct rt2x00_dev *rt2x00dev = queue->rt2x00dev; |
| 855 | unsigned short txwi_size, rxwi_size; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 856 | |
Gabor Juhos | d36d13a | 2013-06-04 13:40:43 +0200 | [diff] [blame] | 857 | if (rt2x00_rt(rt2x00dev, RT5592)) { |
Gabor Juhos | 150cc69 | 2013-06-22 16:31:59 +0200 | [diff] [blame^] | 858 | txwi_size = TXWI_DESC_SIZE_5WORDS; |
| 859 | rxwi_size = RXWI_DESC_SIZE_6WORDS; |
Gabor Juhos | d36d13a | 2013-06-04 13:40:43 +0200 | [diff] [blame] | 860 | } else { |
Gabor Juhos | 150cc69 | 2013-06-22 16:31:59 +0200 | [diff] [blame^] | 861 | txwi_size = TXWI_DESC_SIZE_4WORDS; |
| 862 | rxwi_size = RXWI_DESC_SIZE_4WORDS; |
Gabor Juhos | d36d13a | 2013-06-04 13:40:43 +0200 | [diff] [blame] | 863 | } |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 864 | |
Gabor Juhos | d36d13a | 2013-06-04 13:40:43 +0200 | [diff] [blame] | 865 | switch (queue->qid) { |
| 866 | case QID_RX: |
| 867 | queue->limit = 128; |
| 868 | queue->data_size = AGGREGATION_SIZE; |
| 869 | queue->desc_size = RXINFO_DESC_SIZE; |
| 870 | queue->winfo_size = rxwi_size; |
| 871 | queue->priv_size = sizeof(struct queue_entry_priv_usb); |
| 872 | break; |
| 873 | |
| 874 | case QID_AC_VO: |
| 875 | case QID_AC_VI: |
| 876 | case QID_AC_BE: |
| 877 | case QID_AC_BK: |
| 878 | queue->limit = 16; |
| 879 | queue->data_size = AGGREGATION_SIZE; |
| 880 | queue->desc_size = TXINFO_DESC_SIZE; |
| 881 | queue->winfo_size = txwi_size; |
| 882 | queue->priv_size = sizeof(struct queue_entry_priv_usb); |
| 883 | break; |
| 884 | |
| 885 | case QID_BEACON: |
| 886 | queue->limit = 8; |
| 887 | queue->data_size = MGMT_FRAME_SIZE; |
| 888 | queue->desc_size = TXINFO_DESC_SIZE; |
| 889 | queue->winfo_size = txwi_size; |
| 890 | queue->priv_size = sizeof(struct queue_entry_priv_usb); |
| 891 | break; |
| 892 | |
| 893 | case QID_ATIM: |
| 894 | /* fallthrough */ |
| 895 | default: |
| 896 | BUG(); |
| 897 | break; |
| 898 | } |
| 899 | } |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 900 | |
| 901 | static const struct rt2x00_ops rt2800usb_ops = { |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 902 | .name = KBUILD_MODNAME, |
Gertjan van Wingerde | 3a1c012 | 2012-02-06 23:45:07 +0100 | [diff] [blame] | 903 | .drv_data_size = sizeof(struct rt2800_drv_data), |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 904 | .max_ap_intf = 8, |
| 905 | .eeprom_size = EEPROM_SIZE, |
| 906 | .rf_size = RF_SIZE, |
| 907 | .tx_queues = NUM_TX_QUEUES, |
Gabor Juhos | d36d13a | 2013-06-04 13:40:43 +0200 | [diff] [blame] | 908 | .queue_init = rt2800usb_queue_init, |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 909 | .lib = &rt2800usb_rt2x00_ops, |
Ivo van Doorn | e796643 | 2010-07-11 12:31:23 +0200 | [diff] [blame] | 910 | .drv = &rt2800usb_rt2800_ops, |
Helmut Schaa | e783619 | 2010-07-11 12:28:54 +0200 | [diff] [blame] | 911 | .hw = &rt2800usb_mac80211_ops, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 912 | #ifdef CONFIG_RT2X00_LIB_DEBUGFS |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 913 | .debugfs = &rt2800_rt2x00debug, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 914 | #endif /* CONFIG_RT2X00_LIB_DEBUGFS */ |
| 915 | }; |
| 916 | |
| 917 | /* |
| 918 | * rt2800usb module information. |
| 919 | */ |
| 920 | static struct usb_device_id rt2800usb_device_table[] = { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 921 | /* Abocom */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 922 | { USB_DEVICE(0x07b8, 0x2870) }, |
| 923 | { USB_DEVICE(0x07b8, 0x2770) }, |
| 924 | { USB_DEVICE(0x07b8, 0x3070) }, |
| 925 | { USB_DEVICE(0x07b8, 0x3071) }, |
| 926 | { USB_DEVICE(0x07b8, 0x3072) }, |
| 927 | { USB_DEVICE(0x1482, 0x3c09) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 928 | /* AirTies */ |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 929 | { USB_DEVICE(0x1eda, 0x2012) }, |
Xose Vazquez Perez | 63b3764 | 2012-04-17 01:50:32 +0200 | [diff] [blame] | 930 | { USB_DEVICE(0x1eda, 0x2210) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 931 | { USB_DEVICE(0x1eda, 0x2310) }, |
Xose Vazquez Perez | e895833 | 2010-04-19 11:54:16 +0200 | [diff] [blame] | 932 | /* Allwin */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 933 | { USB_DEVICE(0x8516, 0x2070) }, |
| 934 | { USB_DEVICE(0x8516, 0x2770) }, |
| 935 | { USB_DEVICE(0x8516, 0x2870) }, |
| 936 | { USB_DEVICE(0x8516, 0x3070) }, |
| 937 | { USB_DEVICE(0x8516, 0x3071) }, |
| 938 | { USB_DEVICE(0x8516, 0x3072) }, |
Mark Davis | b3ba44c6 | 2011-04-12 00:19:10 -0400 | [diff] [blame] | 939 | /* Alpha Networks */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 940 | { USB_DEVICE(0x14b2, 0x3c06) }, |
| 941 | { USB_DEVICE(0x14b2, 0x3c07) }, |
| 942 | { USB_DEVICE(0x14b2, 0x3c09) }, |
| 943 | { USB_DEVICE(0x14b2, 0x3c12) }, |
| 944 | { USB_DEVICE(0x14b2, 0x3c23) }, |
| 945 | { USB_DEVICE(0x14b2, 0x3c25) }, |
| 946 | { USB_DEVICE(0x14b2, 0x3c27) }, |
| 947 | { USB_DEVICE(0x14b2, 0x3c28) }, |
| 948 | { USB_DEVICE(0x14b2, 0x3c2c) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 949 | /* Amit */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 950 | { USB_DEVICE(0x15c5, 0x0008) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 951 | /* Askey */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 952 | { USB_DEVICE(0x1690, 0x0740) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 953 | /* ASUS */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 954 | { USB_DEVICE(0x0b05, 0x1731) }, |
| 955 | { USB_DEVICE(0x0b05, 0x1732) }, |
| 956 | { USB_DEVICE(0x0b05, 0x1742) }, |
| 957 | { USB_DEVICE(0x0b05, 0x1784) }, |
| 958 | { USB_DEVICE(0x1761, 0x0b05) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 959 | /* AzureWave */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 960 | { USB_DEVICE(0x13d3, 0x3247) }, |
| 961 | { USB_DEVICE(0x13d3, 0x3273) }, |
| 962 | { USB_DEVICE(0x13d3, 0x3305) }, |
| 963 | { USB_DEVICE(0x13d3, 0x3307) }, |
| 964 | { USB_DEVICE(0x13d3, 0x3321) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 965 | /* Belkin */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 966 | { USB_DEVICE(0x050d, 0x8053) }, |
| 967 | { USB_DEVICE(0x050d, 0x805c) }, |
| 968 | { USB_DEVICE(0x050d, 0x815c) }, |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 969 | { USB_DEVICE(0x050d, 0x825a) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 970 | { USB_DEVICE(0x050d, 0x825b) }, |
| 971 | { USB_DEVICE(0x050d, 0x935a) }, |
| 972 | { USB_DEVICE(0x050d, 0x935b) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 973 | /* Buffalo */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 974 | { USB_DEVICE(0x0411, 0x00e8) }, |
Gertjan van Wingerde | c18b780 | 2011-11-12 19:10:43 +0100 | [diff] [blame] | 975 | { USB_DEVICE(0x0411, 0x0158) }, |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 976 | { USB_DEVICE(0x0411, 0x015d) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 977 | { USB_DEVICE(0x0411, 0x016f) }, |
| 978 | { USB_DEVICE(0x0411, 0x01a2) }, |
Jeongdo Son | a769f95 | 2012-06-15 02:28:01 +0900 | [diff] [blame] | 979 | { USB_DEVICE(0x0411, 0x01ee) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 980 | /* Corega */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 981 | { USB_DEVICE(0x07aa, 0x002f) }, |
| 982 | { USB_DEVICE(0x07aa, 0x003c) }, |
| 983 | { USB_DEVICE(0x07aa, 0x003f) }, |
| 984 | { USB_DEVICE(0x18c5, 0x0012) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 985 | /* D-Link */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 986 | { USB_DEVICE(0x07d1, 0x3c09) }, |
| 987 | { USB_DEVICE(0x07d1, 0x3c0a) }, |
| 988 | { USB_DEVICE(0x07d1, 0x3c0d) }, |
| 989 | { USB_DEVICE(0x07d1, 0x3c0e) }, |
| 990 | { USB_DEVICE(0x07d1, 0x3c0f) }, |
| 991 | { USB_DEVICE(0x07d1, 0x3c11) }, |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 992 | { USB_DEVICE(0x07d1, 0x3c13) }, |
| 993 | { USB_DEVICE(0x07d1, 0x3c15) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 994 | { USB_DEVICE(0x07d1, 0x3c16) }, |
Xose Vazquez Perez | cd435d5 | 2013-01-30 17:14:13 +0100 | [diff] [blame] | 995 | { USB_DEVICE(0x07d1, 0x3c17) }, |
Gertjan van Wingerde | d42a179 | 2012-02-11 21:58:09 +0100 | [diff] [blame] | 996 | { USB_DEVICE(0x2001, 0x3c1b) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 997 | /* Draytek */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 998 | { USB_DEVICE(0x07fa, 0x7712) }, |
Anthony Bourguignon | 276b02e | 2011-08-05 07:46:32 +0200 | [diff] [blame] | 999 | /* DVICO */ |
| 1000 | { USB_DEVICE(0x0fe9, 0xb307) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1001 | /* Edimax */ |
Xose Vazquez Perez | e828b9f | 2012-04-17 16:28:05 +0200 | [diff] [blame] | 1002 | { USB_DEVICE(0x7392, 0x4085) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1003 | { USB_DEVICE(0x7392, 0x7711) }, |
| 1004 | { USB_DEVICE(0x7392, 0x7717) }, |
| 1005 | { USB_DEVICE(0x7392, 0x7718) }, |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 1006 | { USB_DEVICE(0x7392, 0x7722) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1007 | /* Encore */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1008 | { USB_DEVICE(0x203d, 0x1480) }, |
| 1009 | { USB_DEVICE(0x203d, 0x14a9) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1010 | /* EnGenius */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1011 | { USB_DEVICE(0x1740, 0x9701) }, |
| 1012 | { USB_DEVICE(0x1740, 0x9702) }, |
| 1013 | { USB_DEVICE(0x1740, 0x9703) }, |
| 1014 | { USB_DEVICE(0x1740, 0x9705) }, |
| 1015 | { USB_DEVICE(0x1740, 0x9706) }, |
| 1016 | { USB_DEVICE(0x1740, 0x9707) }, |
| 1017 | { USB_DEVICE(0x1740, 0x9708) }, |
| 1018 | { USB_DEVICE(0x1740, 0x9709) }, |
Mark Davis | b3ba44c6 | 2011-04-12 00:19:10 -0400 | [diff] [blame] | 1019 | /* Gemtek */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1020 | { USB_DEVICE(0x15a9, 0x0012) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1021 | /* Gigabyte */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1022 | { USB_DEVICE(0x1044, 0x800b) }, |
| 1023 | { USB_DEVICE(0x1044, 0x800d) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1024 | /* Hawking */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1025 | { USB_DEVICE(0x0e66, 0x0001) }, |
| 1026 | { USB_DEVICE(0x0e66, 0x0003) }, |
| 1027 | { USB_DEVICE(0x0e66, 0x0009) }, |
| 1028 | { USB_DEVICE(0x0e66, 0x000b) }, |
| 1029 | { USB_DEVICE(0x0e66, 0x0013) }, |
| 1030 | { USB_DEVICE(0x0e66, 0x0017) }, |
| 1031 | { USB_DEVICE(0x0e66, 0x0018) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1032 | /* I-O DATA */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1033 | { USB_DEVICE(0x04bb, 0x0945) }, |
| 1034 | { USB_DEVICE(0x04bb, 0x0947) }, |
| 1035 | { USB_DEVICE(0x04bb, 0x0948) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1036 | /* Linksys */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1037 | { USB_DEVICE(0x13b1, 0x0031) }, |
| 1038 | { USB_DEVICE(0x1737, 0x0070) }, |
| 1039 | { USB_DEVICE(0x1737, 0x0071) }, |
Larry Finger | 3f81f8f | 2011-12-27 12:22:51 -0600 | [diff] [blame] | 1040 | { USB_DEVICE(0x1737, 0x0077) }, |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 1041 | { USB_DEVICE(0x1737, 0x0078) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1042 | /* Logitec */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1043 | { USB_DEVICE(0x0789, 0x0162) }, |
| 1044 | { USB_DEVICE(0x0789, 0x0163) }, |
| 1045 | { USB_DEVICE(0x0789, 0x0164) }, |
| 1046 | { USB_DEVICE(0x0789, 0x0166) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1047 | /* Motorola */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1048 | { USB_DEVICE(0x100d, 0x9031) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 1049 | /* MSI */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1050 | { USB_DEVICE(0x0db0, 0x3820) }, |
| 1051 | { USB_DEVICE(0x0db0, 0x3821) }, |
| 1052 | { USB_DEVICE(0x0db0, 0x3822) }, |
| 1053 | { USB_DEVICE(0x0db0, 0x3870) }, |
| 1054 | { USB_DEVICE(0x0db0, 0x3871) }, |
| 1055 | { USB_DEVICE(0x0db0, 0x6899) }, |
| 1056 | { USB_DEVICE(0x0db0, 0x821a) }, |
| 1057 | { USB_DEVICE(0x0db0, 0x822a) }, |
| 1058 | { USB_DEVICE(0x0db0, 0x822b) }, |
| 1059 | { USB_DEVICE(0x0db0, 0x822c) }, |
| 1060 | { USB_DEVICE(0x0db0, 0x870a) }, |
| 1061 | { USB_DEVICE(0x0db0, 0x871a) }, |
| 1062 | { USB_DEVICE(0x0db0, 0x871b) }, |
| 1063 | { USB_DEVICE(0x0db0, 0x871c) }, |
| 1064 | { USB_DEVICE(0x0db0, 0x899a) }, |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 1065 | /* Ovislink */ |
| 1066 | { USB_DEVICE(0x1b75, 0x3071) }, |
| 1067 | { USB_DEVICE(0x1b75, 0x3072) }, |
Xose Vazquez Perez | fc3f148 | 2010-03-28 15:52:43 +0200 | [diff] [blame] | 1068 | /* Para */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1069 | { USB_DEVICE(0x20b8, 0x8888) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1070 | /* Pegatron */ |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 1071 | { USB_DEVICE(0x1d4d, 0x0002) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1072 | { USB_DEVICE(0x1d4d, 0x000c) }, |
| 1073 | { USB_DEVICE(0x1d4d, 0x000e) }, |
| 1074 | { USB_DEVICE(0x1d4d, 0x0011) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1075 | /* Philips */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1076 | { USB_DEVICE(0x0471, 0x200f) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1077 | /* Planex */ |
Xose Vazquez Perez | e828b9f | 2012-04-17 16:28:05 +0200 | [diff] [blame] | 1078 | { USB_DEVICE(0x2019, 0x5201) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1079 | { USB_DEVICE(0x2019, 0xab25) }, |
| 1080 | { USB_DEVICE(0x2019, 0xed06) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1081 | /* Quanta */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1082 | { USB_DEVICE(0x1a32, 0x0304) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1083 | /* Ralink */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1084 | { USB_DEVICE(0x148f, 0x2070) }, |
| 1085 | { USB_DEVICE(0x148f, 0x2770) }, |
| 1086 | { USB_DEVICE(0x148f, 0x2870) }, |
| 1087 | { USB_DEVICE(0x148f, 0x3070) }, |
| 1088 | { USB_DEVICE(0x148f, 0x3071) }, |
| 1089 | { USB_DEVICE(0x148f, 0x3072) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1090 | /* Samsung */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1091 | { USB_DEVICE(0x04e8, 0x2018) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1092 | /* Siemens */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1093 | { USB_DEVICE(0x129b, 0x1828) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1094 | /* Sitecom */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1095 | { USB_DEVICE(0x0df6, 0x0017) }, |
| 1096 | { USB_DEVICE(0x0df6, 0x002b) }, |
| 1097 | { USB_DEVICE(0x0df6, 0x002c) }, |
| 1098 | { USB_DEVICE(0x0df6, 0x002d) }, |
| 1099 | { USB_DEVICE(0x0df6, 0x0039) }, |
| 1100 | { USB_DEVICE(0x0df6, 0x003b) }, |
| 1101 | { USB_DEVICE(0x0df6, 0x003d) }, |
| 1102 | { USB_DEVICE(0x0df6, 0x003e) }, |
| 1103 | { USB_DEVICE(0x0df6, 0x003f) }, |
| 1104 | { USB_DEVICE(0x0df6, 0x0040) }, |
| 1105 | { USB_DEVICE(0x0df6, 0x0042) }, |
| 1106 | { USB_DEVICE(0x0df6, 0x0047) }, |
| 1107 | { USB_DEVICE(0x0df6, 0x0048) }, |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1108 | { USB_DEVICE(0x0df6, 0x0051) }, |
| 1109 | { USB_DEVICE(0x0df6, 0x005f) }, |
Gertjan van Wingerde | acb5612 | 2011-07-06 22:59:19 +0200 | [diff] [blame] | 1110 | { USB_DEVICE(0x0df6, 0x0060) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1111 | /* SMC */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1112 | { USB_DEVICE(0x083a, 0x6618) }, |
| 1113 | { USB_DEVICE(0x083a, 0x7511) }, |
| 1114 | { USB_DEVICE(0x083a, 0x7512) }, |
| 1115 | { USB_DEVICE(0x083a, 0x7522) }, |
| 1116 | { USB_DEVICE(0x083a, 0x8522) }, |
| 1117 | { USB_DEVICE(0x083a, 0xa618) }, |
| 1118 | { USB_DEVICE(0x083a, 0xa701) }, |
| 1119 | { USB_DEVICE(0x083a, 0xa702) }, |
| 1120 | { USB_DEVICE(0x083a, 0xa703) }, |
| 1121 | { USB_DEVICE(0x083a, 0xb522) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1122 | /* Sparklan */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1123 | { USB_DEVICE(0x15a9, 0x0006) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1124 | /* Sweex */ |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 1125 | { USB_DEVICE(0x177f, 0x0153) }, |
Xose Vazquez Perez | 12b6639 | 2013-02-02 03:33:44 +0100 | [diff] [blame] | 1126 | { USB_DEVICE(0x177f, 0x0164) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1127 | { USB_DEVICE(0x177f, 0x0302) }, |
Gertjan van Wingerde | bc93eda | 2011-12-28 01:53:18 +0100 | [diff] [blame] | 1128 | { USB_DEVICE(0x177f, 0x0313) }, |
Jaume Delclòs | 36f318b | 2012-11-02 23:35:20 +0100 | [diff] [blame] | 1129 | { USB_DEVICE(0x177f, 0x0323) }, |
Xose Vazquez Perez | 12b6639 | 2013-02-02 03:33:44 +0100 | [diff] [blame] | 1130 | { USB_DEVICE(0x177f, 0x0324) }, |
Mark Davis | b3ba44c6 | 2011-04-12 00:19:10 -0400 | [diff] [blame] | 1131 | /* U-Media */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1132 | { USB_DEVICE(0x157e, 0x300e) }, |
| 1133 | { USB_DEVICE(0x157e, 0x3013) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1134 | /* ZCOM */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1135 | { USB_DEVICE(0x0cde, 0x0022) }, |
| 1136 | { USB_DEVICE(0x0cde, 0x0025) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1137 | /* Zinwell */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1138 | { USB_DEVICE(0x5a57, 0x0280) }, |
| 1139 | { USB_DEVICE(0x5a57, 0x0282) }, |
| 1140 | { USB_DEVICE(0x5a57, 0x0283) }, |
| 1141 | { USB_DEVICE(0x5a57, 0x5257) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 1142 | /* Zyxel */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1143 | { USB_DEVICE(0x0586, 0x3416) }, |
| 1144 | { USB_DEVICE(0x0586, 0x3418) }, |
Xose Vazquez Perez | cd435d5 | 2013-01-30 17:14:13 +0100 | [diff] [blame] | 1145 | { USB_DEVICE(0x0586, 0x341a) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1146 | { USB_DEVICE(0x0586, 0x341e) }, |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1147 | { USB_DEVICE(0x0586, 0x343e) }, |
Gertjan van Wingerde | f93bc9b | 2010-11-13 19:09:50 +0100 | [diff] [blame] | 1148 | #ifdef CONFIG_RT2800USB_RT33XX |
Eduardo Bacchi Kienetz | 43bf8c2 | 2011-07-10 17:05:14 +0200 | [diff] [blame] | 1149 | /* Belkin */ |
| 1150 | { USB_DEVICE(0x050d, 0x945b) }, |
Albert Pool | 8fd9d05 | 2012-05-14 18:08:32 +0200 | [diff] [blame] | 1151 | /* D-Link */ |
| 1152 | { USB_DEVICE(0x2001, 0x3c17) }, |
Xose Vazquez Perez | 63b3764 | 2012-04-17 01:50:32 +0200 | [diff] [blame] | 1153 | /* Panasonic */ |
| 1154 | { USB_DEVICE(0x083a, 0xb511) }, |
| 1155 | /* Philips */ |
| 1156 | { USB_DEVICE(0x0471, 0x20dd) }, |
Gertjan van Wingerde | f93bc9b | 2010-11-13 19:09:50 +0100 | [diff] [blame] | 1157 | /* Ralink */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1158 | { USB_DEVICE(0x148f, 0x3370) }, |
| 1159 | { USB_DEVICE(0x148f, 0x8070) }, |
Gertjan van Wingerde | f93bc9b | 2010-11-13 19:09:50 +0100 | [diff] [blame] | 1160 | /* Sitecom */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1161 | { USB_DEVICE(0x0df6, 0x0050) }, |
Xose Vazquez Perez | 12b6639 | 2013-02-02 03:33:44 +0100 | [diff] [blame] | 1162 | /* Sweex */ |
| 1163 | { USB_DEVICE(0x177f, 0x0163) }, |
| 1164 | { USB_DEVICE(0x177f, 0x0165) }, |
Gertjan van Wingerde | f93bc9b | 2010-11-13 19:09:50 +0100 | [diff] [blame] | 1165 | #endif |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1166 | #ifdef CONFIG_RT2800USB_RT35XX |
Xose Vazquez Perez | e895833 | 2010-04-19 11:54:16 +0200 | [diff] [blame] | 1167 | /* Allwin */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1168 | { USB_DEVICE(0x8516, 0x3572) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1169 | /* Askey */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1170 | { USB_DEVICE(0x1690, 0x0744) }, |
Xose Vazquez Perez | e828b9f | 2012-04-17 16:28:05 +0200 | [diff] [blame] | 1171 | { USB_DEVICE(0x1690, 0x0761) }, |
Xose Vazquez Perez | 63b3764 | 2012-04-17 01:50:32 +0200 | [diff] [blame] | 1172 | { USB_DEVICE(0x1690, 0x0764) }, |
Gertjan van Wingerde | 177ef83 | 2012-08-31 19:22:09 +0200 | [diff] [blame] | 1173 | /* ASUS */ |
| 1174 | { USB_DEVICE(0x0b05, 0x179d) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1175 | /* Cisco */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1176 | { USB_DEVICE(0x167b, 0x4001) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1177 | /* EnGenius */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1178 | { USB_DEVICE(0x1740, 0x9801) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1179 | /* I-O DATA */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1180 | { USB_DEVICE(0x04bb, 0x0944) }, |
Mark Davis | b3ba44c6 | 2011-04-12 00:19:10 -0400 | [diff] [blame] | 1181 | /* Linksys */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1182 | { USB_DEVICE(0x13b1, 0x002f) }, |
| 1183 | { USB_DEVICE(0x1737, 0x0079) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1184 | /* Ralink */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1185 | { USB_DEVICE(0x148f, 0x3572) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1186 | /* Sitecom */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1187 | { USB_DEVICE(0x0df6, 0x0041) }, |
Gertjan van Wingerde | acb5612 | 2011-07-06 22:59:19 +0200 | [diff] [blame] | 1188 | { USB_DEVICE(0x0df6, 0x0062) }, |
Xose Vazquez Perez | 63b3764 | 2012-04-17 01:50:32 +0200 | [diff] [blame] | 1189 | { USB_DEVICE(0x0df6, 0x0065) }, |
| 1190 | { USB_DEVICE(0x0df6, 0x0066) }, |
| 1191 | { USB_DEVICE(0x0df6, 0x0068) }, |
Xose Vazquez Perez | 8d4ca61 | 2011-03-27 20:33:06 +0200 | [diff] [blame] | 1192 | /* Toshiba */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1193 | { USB_DEVICE(0x0930, 0x0a07) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1194 | /* Zinwell */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1195 | { USB_DEVICE(0x5a57, 0x0284) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1196 | #endif |
Gertjan van Wingerde | aca355b | 2011-05-04 21:41:36 +0200 | [diff] [blame] | 1197 | #ifdef CONFIG_RT2800USB_RT53XX |
John Li | 2ed7188 | 2012-02-17 17:33:06 +0800 | [diff] [blame] | 1198 | /* Arcadyan */ |
| 1199 | { USB_DEVICE(0x043e, 0x7a12) }, |
Xose Vazquez Perez | cd435d5 | 2013-01-30 17:14:13 +0100 | [diff] [blame] | 1200 | { USB_DEVICE(0x043e, 0x7a32) }, |
Gertjan van Wingerde | aca355b | 2011-05-04 21:41:36 +0200 | [diff] [blame] | 1201 | /* Azurewave */ |
| 1202 | { USB_DEVICE(0x13d3, 0x3329) }, |
| 1203 | { USB_DEVICE(0x13d3, 0x3365) }, |
Xose Vazquez Perez | 63b3764 | 2012-04-17 01:50:32 +0200 | [diff] [blame] | 1204 | /* D-Link */ |
| 1205 | { USB_DEVICE(0x2001, 0x3c15) }, |
| 1206 | { USB_DEVICE(0x2001, 0x3c19) }, |
| 1207 | { USB_DEVICE(0x2001, 0x3c1c) }, |
| 1208 | { USB_DEVICE(0x2001, 0x3c1d) }, |
John W. Linville | fe8e410 | 2012-12-11 15:55:02 -0500 | [diff] [blame] | 1209 | { USB_DEVICE(0x2001, 0x3c1e) }, |
John Li | 2ed7188 | 2012-02-17 17:33:06 +0800 | [diff] [blame] | 1210 | /* LG innotek */ |
| 1211 | { USB_DEVICE(0x043e, 0x7a22) }, |
Xose Vazquez Perez | cd435d5 | 2013-01-30 17:14:13 +0100 | [diff] [blame] | 1212 | { USB_DEVICE(0x043e, 0x7a42) }, |
John Li | 2ed7188 | 2012-02-17 17:33:06 +0800 | [diff] [blame] | 1213 | /* Panasonic */ |
| 1214 | { USB_DEVICE(0x04da, 0x1801) }, |
| 1215 | { USB_DEVICE(0x04da, 0x1800) }, |
Xose Vazquez Perez | cd435d5 | 2013-01-30 17:14:13 +0100 | [diff] [blame] | 1216 | { USB_DEVICE(0x04da, 0x23f6) }, |
John Li | 2ed7188 | 2012-02-17 17:33:06 +0800 | [diff] [blame] | 1217 | /* Philips */ |
| 1218 | { USB_DEVICE(0x0471, 0x2104) }, |
Xose Vazquez Perez | cd435d5 | 2013-01-30 17:14:13 +0100 | [diff] [blame] | 1219 | { USB_DEVICE(0x0471, 0x2126) }, |
| 1220 | { USB_DEVICE(0x0471, 0x2180) }, |
| 1221 | { USB_DEVICE(0x0471, 0x2181) }, |
| 1222 | { USB_DEVICE(0x0471, 0x2182) }, |
Gertjan van Wingerde | aca355b | 2011-05-04 21:41:36 +0200 | [diff] [blame] | 1223 | /* Ralink */ |
| 1224 | { USB_DEVICE(0x148f, 0x5370) }, |
| 1225 | { USB_DEVICE(0x148f, 0x5372) }, |
| 1226 | #endif |
Stanislaw Gruszka | b8863f8 | 2013-03-16 19:19:30 +0100 | [diff] [blame] | 1227 | #ifdef CONFIG_RT2800USB_RT55XX |
Stanislaw Gruszka | 856a850 | 2013-03-16 19:19:53 +0100 | [diff] [blame] | 1228 | /* Arcadyan */ |
Gabor Juhos | 7ce0bad | 2013-06-06 09:36:20 +0200 | [diff] [blame] | 1229 | { USB_DEVICE(0x043e, 0x7a32) }, |
Stanislaw Gruszka | 856a850 | 2013-03-16 19:19:53 +0100 | [diff] [blame] | 1230 | /* AVM GmbH */ |
Gabor Juhos | 7ce0bad | 2013-06-06 09:36:20 +0200 | [diff] [blame] | 1231 | { USB_DEVICE(0x057c, 0x8501) }, |
Stanislaw Gruszka | 856a850 | 2013-03-16 19:19:53 +0100 | [diff] [blame] | 1232 | /* D-Link DWA-160-B2 */ |
Gabor Juhos | 7ce0bad | 2013-06-06 09:36:20 +0200 | [diff] [blame] | 1233 | { USB_DEVICE(0x2001, 0x3c1a) }, |
Stanislaw Gruszka | 856a850 | 2013-03-16 19:19:53 +0100 | [diff] [blame] | 1234 | /* Proware */ |
Gabor Juhos | 7ce0bad | 2013-06-06 09:36:20 +0200 | [diff] [blame] | 1235 | { USB_DEVICE(0x043e, 0x7a13) }, |
Stanislaw Gruszka | 856a850 | 2013-03-16 19:19:53 +0100 | [diff] [blame] | 1236 | /* Ralink */ |
Gabor Juhos | 7ce0bad | 2013-06-06 09:36:20 +0200 | [diff] [blame] | 1237 | { USB_DEVICE(0x148f, 0x5572) }, |
Stanislaw Gruszka | b8863f8 | 2013-03-16 19:19:30 +0100 | [diff] [blame] | 1238 | #endif |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1239 | #ifdef CONFIG_RT2800USB_UNKNOWN |
| 1240 | /* |
| 1241 | * Unclear what kind of devices these are (they aren't supported by the |
Xose Vazquez Perez | 12ef116 | 2010-05-03 13:11:38 +0200 | [diff] [blame] | 1242 | * vendor linux driver). |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1243 | */ |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1244 | /* Abocom */ |
| 1245 | { USB_DEVICE(0x07b8, 0x3073) }, |
| 1246 | { USB_DEVICE(0x07b8, 0x3074) }, |
Mark Davis | b3ba44c6 | 2011-04-12 00:19:10 -0400 | [diff] [blame] | 1247 | /* Alpha Networks */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1248 | { USB_DEVICE(0x14b2, 0x3c08) }, |
| 1249 | { USB_DEVICE(0x14b2, 0x3c11) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1250 | /* Amigo */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1251 | { USB_DEVICE(0x0e0b, 0x9031) }, |
| 1252 | { USB_DEVICE(0x0e0b, 0x9041) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1253 | /* ASUS */ |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1254 | { USB_DEVICE(0x0b05, 0x166a) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1255 | { USB_DEVICE(0x0b05, 0x1760) }, |
| 1256 | { USB_DEVICE(0x0b05, 0x1761) }, |
| 1257 | { USB_DEVICE(0x0b05, 0x1790) }, |
Xose Vazquez Perez | d9d76a0 | 2013-02-09 04:14:35 +0100 | [diff] [blame] | 1258 | { USB_DEVICE(0x0b05, 0x17a7) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1259 | /* AzureWave */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1260 | { USB_DEVICE(0x13d3, 0x3262) }, |
| 1261 | { USB_DEVICE(0x13d3, 0x3284) }, |
| 1262 | { USB_DEVICE(0x13d3, 0x3322) }, |
Xose Vazquez Perez | d9d76a0 | 2013-02-09 04:14:35 +0100 | [diff] [blame] | 1263 | { USB_DEVICE(0x13d3, 0x3340) }, |
| 1264 | { USB_DEVICE(0x13d3, 0x3399) }, |
| 1265 | { USB_DEVICE(0x13d3, 0x3400) }, |
| 1266 | { USB_DEVICE(0x13d3, 0x3401) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1267 | /* Belkin */ |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1268 | { USB_DEVICE(0x050d, 0x1003) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1269 | /* Buffalo */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1270 | { USB_DEVICE(0x0411, 0x012e) }, |
| 1271 | { USB_DEVICE(0x0411, 0x0148) }, |
| 1272 | { USB_DEVICE(0x0411, 0x0150) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1273 | /* Corega */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1274 | { USB_DEVICE(0x07aa, 0x0041) }, |
| 1275 | { USB_DEVICE(0x07aa, 0x0042) }, |
| 1276 | { USB_DEVICE(0x18c5, 0x0008) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1277 | /* D-Link */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1278 | { USB_DEVICE(0x07d1, 0x3c0b) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1279 | /* Encore */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1280 | { USB_DEVICE(0x203d, 0x14a1) }, |
Xose Vazquez Perez | d9d76a0 | 2013-02-09 04:14:35 +0100 | [diff] [blame] | 1281 | /* EnGenius */ |
| 1282 | { USB_DEVICE(0x1740, 0x0600) }, |
| 1283 | { USB_DEVICE(0x1740, 0x0602) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1284 | /* Gemtek */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1285 | { USB_DEVICE(0x15a9, 0x0010) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1286 | /* Gigabyte */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1287 | { USB_DEVICE(0x1044, 0x800c) }, |
Xose Vazquez Perez | d9d76a0 | 2013-02-09 04:14:35 +0100 | [diff] [blame] | 1288 | /* Hercules */ |
| 1289 | { USB_DEVICE(0x06f8, 0xe036) }, |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1290 | /* Huawei */ |
| 1291 | { USB_DEVICE(0x148f, 0xf101) }, |
| 1292 | /* I-O DATA */ |
| 1293 | { USB_DEVICE(0x04bb, 0x094b) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1294 | /* LevelOne */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1295 | { USB_DEVICE(0x1740, 0x0605) }, |
| 1296 | { USB_DEVICE(0x1740, 0x0615) }, |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1297 | /* Logitec */ |
| 1298 | { USB_DEVICE(0x0789, 0x0168) }, |
| 1299 | { USB_DEVICE(0x0789, 0x0169) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1300 | /* Motorola */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1301 | { USB_DEVICE(0x100d, 0x9032) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1302 | /* Pegatron */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1303 | { USB_DEVICE(0x05a6, 0x0101) }, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1304 | { USB_DEVICE(0x1d4d, 0x0010) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1305 | /* Planex */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1306 | { USB_DEVICE(0x2019, 0xab24) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1307 | /* Qcom */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1308 | { USB_DEVICE(0x18e8, 0x6259) }, |
Gertjan van Wingerde | 87a3b89 | 2011-04-18 15:32:33 +0200 | [diff] [blame] | 1309 | /* RadioShack */ |
| 1310 | { USB_DEVICE(0x08b9, 0x1197) }, |
| 1311 | /* Sitecom */ |
| 1312 | { USB_DEVICE(0x0df6, 0x003c) }, |
| 1313 | { USB_DEVICE(0x0df6, 0x004a) }, |
| 1314 | { USB_DEVICE(0x0df6, 0x004d) }, |
| 1315 | { USB_DEVICE(0x0df6, 0x0053) }, |
Xose Vazquez Perez | d9d76a0 | 2013-02-09 04:14:35 +0100 | [diff] [blame] | 1316 | { USB_DEVICE(0x0df6, 0x0069) }, |
| 1317 | { USB_DEVICE(0x0df6, 0x006f) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1318 | /* SMC */ |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1319 | { USB_DEVICE(0x083a, 0xa512) }, |
| 1320 | { USB_DEVICE(0x083a, 0xc522) }, |
| 1321 | { USB_DEVICE(0x083a, 0xd522) }, |
| 1322 | { USB_DEVICE(0x083a, 0xf511) }, |
Xose Vazquez Perez | d9d76a0 | 2013-02-09 04:14:35 +0100 | [diff] [blame] | 1323 | /* Sweex */ |
| 1324 | { USB_DEVICE(0x177f, 0x0254) }, |
| 1325 | /* TP-LINK */ |
| 1326 | { USB_DEVICE(0xf201, 0x5370) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 1327 | #endif |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1328 | { 0, } |
| 1329 | }; |
| 1330 | |
| 1331 | MODULE_AUTHOR(DRV_PROJECT); |
| 1332 | MODULE_VERSION(DRV_VERSION); |
| 1333 | MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver."); |
| 1334 | MODULE_SUPPORTED_DEVICE("Ralink RT2870 USB chipset based cards"); |
| 1335 | MODULE_DEVICE_TABLE(usb, rt2800usb_device_table); |
| 1336 | MODULE_FIRMWARE(FIRMWARE_RT2870); |
| 1337 | MODULE_LICENSE("GPL"); |
| 1338 | |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1339 | static int rt2800usb_probe(struct usb_interface *usb_intf, |
| 1340 | const struct usb_device_id *id) |
| 1341 | { |
| 1342 | return rt2x00usb_probe(usb_intf, &rt2800usb_ops); |
| 1343 | } |
| 1344 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1345 | static struct usb_driver rt2800usb_driver = { |
| 1346 | .name = KBUILD_MODNAME, |
| 1347 | .id_table = rt2800usb_device_table, |
Gertjan van Wingerde | e01ae27 | 2011-04-18 15:32:13 +0200 | [diff] [blame] | 1348 | .probe = rt2800usb_probe, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1349 | .disconnect = rt2x00usb_disconnect, |
| 1350 | .suspend = rt2x00usb_suspend, |
| 1351 | .resume = rt2x00usb_resume, |
Stanislaw Gruszka | 761ce8c | 2012-10-16 14:34:12 +0200 | [diff] [blame] | 1352 | .reset_resume = rt2x00usb_resume, |
Sarah Sharp | e1f12eb | 2012-04-23 10:08:51 -0700 | [diff] [blame] | 1353 | .disable_hub_initiated_lpm = 1, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1354 | }; |
| 1355 | |
Greg Kroah-Hartman | d632eb1 | 2011-11-18 09:44:20 -0800 | [diff] [blame] | 1356 | module_usb_driver(rt2800usb_driver); |