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 | */ |
Mark Einon | 144b80b | 2010-11-06 15:45:41 +0100 | [diff] [blame] | 48 | static int 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 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 52 | /* |
| 53 | * Firmware functions |
| 54 | */ |
| 55 | static char *rt2800usb_get_firmware_name(struct rt2x00_dev *rt2x00dev) |
| 56 | { |
| 57 | return FIRMWARE_RT2870; |
| 58 | } |
| 59 | |
Ivo van Doorn | f31c9a8 | 2010-07-11 12:30:37 +0200 | [diff] [blame] | 60 | static int rt2800usb_write_firmware(struct rt2x00_dev *rt2x00dev, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 61 | const u8 *data, const size_t len) |
| 62 | { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 63 | int status; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 64 | u32 offset; |
| 65 | u32 length; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 66 | |
| 67 | /* |
| 68 | * Check which section of the firmware we need. |
| 69 | */ |
Gertjan van Wingerde | 49e721e | 2010-02-13 20:55:49 +0100 | [diff] [blame] | 70 | if (rt2x00_rt(rt2x00dev, RT2860) || |
| 71 | rt2x00_rt(rt2x00dev, RT2872) || |
| 72 | rt2x00_rt(rt2x00dev, RT3070)) { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 73 | offset = 0; |
| 74 | length = 4096; |
| 75 | } else { |
| 76 | offset = 4096; |
| 77 | length = 4096; |
| 78 | } |
| 79 | |
| 80 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 81 | * Write firmware to device. |
| 82 | */ |
Gertjan van Wingerde | 96b61ba | 2010-06-03 10:51:51 +0200 | [diff] [blame] | 83 | rt2800_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE, |
| 84 | data + offset, length); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 85 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 86 | rt2800_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); |
| 87 | rt2800_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 88 | |
| 89 | /* |
| 90 | * Send firmware request to device to load firmware, |
| 91 | * we need to specify a long timeout time. |
| 92 | */ |
| 93 | status = rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, |
| 94 | 0, USB_MODE_FIRMWARE, |
| 95 | REGISTER_TIMEOUT_FIRMWARE); |
| 96 | if (status < 0) { |
| 97 | ERROR(rt2x00dev, "Failed to write Firmware to device.\n"); |
| 98 | return status; |
| 99 | } |
| 100 | |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 101 | msleep(10); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 102 | rt2800_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 103 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 104 | return 0; |
| 105 | } |
| 106 | |
| 107 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 108 | * Device state switch handlers. |
| 109 | */ |
| 110 | static void rt2800usb_toggle_rx(struct rt2x00_dev *rt2x00dev, |
| 111 | enum dev_state state) |
| 112 | { |
| 113 | u32 reg; |
| 114 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 115 | rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 116 | rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_RX, |
Ivo van Doorn | ea175ee | 2010-11-06 15:48:43 +0100 | [diff] [blame] | 117 | (state == STATE_RADIO_RX_ON)); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 118 | rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 119 | } |
| 120 | |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 121 | static int rt2800usb_init_registers(struct rt2x00_dev *rt2x00dev) |
| 122 | { |
| 123 | u32 reg; |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 124 | |
| 125 | /* |
| 126 | * Wait until BBP and RF are ready. |
| 127 | */ |
Ivo van Doorn | 5ffddc4 | 2010-08-30 21:13:08 +0200 | [diff] [blame] | 128 | if (rt2800_wait_csr_ready(rt2x00dev)) |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 129 | return -EBUSY; |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 130 | |
| 131 | rt2800_register_read(rt2x00dev, PBF_SYS_CTRL, ®); |
| 132 | rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, reg & ~0x00002000); |
| 133 | |
Ivo van Doorn | e054087 | 2010-08-30 21:14:38 +0200 | [diff] [blame] | 134 | rt2800_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000003); |
| 135 | |
Gertjan van Wingerde | e3a896b | 2010-06-03 10:52:04 +0200 | [diff] [blame] | 136 | rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); |
| 137 | rt2x00_set_field32(®, MAC_SYS_CTRL_RESET_CSR, 1); |
| 138 | rt2x00_set_field32(®, MAC_SYS_CTRL_RESET_BBP, 1); |
| 139 | rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
| 140 | |
| 141 | rt2800_register_write(rt2x00dev, USB_DMA_CFG, 0x00000000); |
| 142 | |
| 143 | rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, 0, |
| 144 | USB_MODE_RESET, REGISTER_TIMEOUT); |
| 145 | |
| 146 | rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); |
| 147 | |
| 148 | return 0; |
| 149 | } |
| 150 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 151 | static int rt2800usb_enable_radio(struct rt2x00_dev *rt2x00dev) |
| 152 | { |
| 153 | u32 reg; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 154 | |
Ivo van Doorn | b9a07ae | 2010-08-23 19:55:22 +0200 | [diff] [blame] | 155 | if (unlikely(rt2800_wait_wpdma_ready(rt2x00dev))) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 156 | return -EIO; |
| 157 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 158 | rt2800_register_read(rt2x00dev, USB_DMA_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 159 | rt2x00_set_field32(®, USB_DMA_CFG_PHY_CLEAR, 0); |
Benoit PAPILLAULT | 9c8427d | 2009-12-04 23:47:05 +0100 | [diff] [blame] | 160 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_EN, 0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 161 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_TIMEOUT, 128); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 162 | /* |
| 163 | * Total room for RX frames in kilobytes, PBF might still exceed |
| 164 | * this limit so reduce the number to prevent errors. |
| 165 | */ |
| 166 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_LIMIT, |
Helmut Schaa | efd2f27 | 2010-11-04 20:37:22 +0100 | [diff] [blame] | 167 | ((rt2x00dev->ops->rx->entry_num * DATA_FRAME_SIZE) |
| 168 | / 1024) - 3); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 169 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_EN, 1); |
| 170 | rt2x00_set_field32(®, USB_DMA_CFG_TX_BULK_EN, 1); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 171 | rt2800_register_write(rt2x00dev, USB_DMA_CFG, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 172 | |
Ivo van Doorn | b9a07ae | 2010-08-23 19:55:22 +0200 | [diff] [blame] | 173 | return rt2800_enable_radio(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | static void rt2800usb_disable_radio(struct rt2x00_dev *rt2x00dev) |
| 177 | { |
Ivo van Doorn | b9a07ae | 2010-08-23 19:55:22 +0200 | [diff] [blame] | 178 | rt2800_disable_radio(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 179 | rt2x00usb_disable_radio(rt2x00dev); |
| 180 | } |
| 181 | |
| 182 | static int rt2800usb_set_state(struct rt2x00_dev *rt2x00dev, |
| 183 | enum dev_state state) |
| 184 | { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 185 | if (state == STATE_AWAKE) |
Ivo van Doorn | 303c7d6 | 2010-11-04 20:40:46 +0100 | [diff] [blame] | 186 | rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 2); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 187 | else |
Ivo van Doorn | 303c7d6 | 2010-11-04 20:40:46 +0100 | [diff] [blame] | 188 | rt2800_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0xff, 2); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 189 | |
| 190 | return 0; |
| 191 | } |
| 192 | |
| 193 | static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev, |
| 194 | enum dev_state state) |
| 195 | { |
| 196 | int retval = 0; |
| 197 | |
| 198 | switch (state) { |
| 199 | case STATE_RADIO_ON: |
| 200 | /* |
| 201 | * Before the radio can be enabled, the device first has |
| 202 | * to be woken up. After that it needs a bit of time |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 203 | * to be fully awake and then the radio can be enabled. |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 204 | */ |
| 205 | rt2800usb_set_state(rt2x00dev, STATE_AWAKE); |
| 206 | msleep(1); |
| 207 | retval = rt2800usb_enable_radio(rt2x00dev); |
| 208 | break; |
| 209 | case STATE_RADIO_OFF: |
| 210 | /* |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 211 | * After the radio has been disabled, the device should |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 212 | * be put to sleep for powersaving. |
| 213 | */ |
| 214 | rt2800usb_disable_radio(rt2x00dev); |
| 215 | rt2800usb_set_state(rt2x00dev, STATE_SLEEP); |
| 216 | break; |
| 217 | case STATE_RADIO_RX_ON: |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 218 | case STATE_RADIO_RX_OFF: |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 219 | rt2800usb_toggle_rx(rt2x00dev, state); |
| 220 | break; |
| 221 | case STATE_RADIO_IRQ_ON: |
Helmut Schaa | 78e256c | 2010-07-11 12:26:48 +0200 | [diff] [blame] | 222 | case STATE_RADIO_IRQ_ON_ISR: |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 223 | case STATE_RADIO_IRQ_OFF: |
Helmut Schaa | 78e256c | 2010-07-11 12:26:48 +0200 | [diff] [blame] | 224 | case STATE_RADIO_IRQ_OFF_ISR: |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 225 | /* No support, but no error either */ |
| 226 | break; |
| 227 | case STATE_DEEP_SLEEP: |
| 228 | case STATE_SLEEP: |
| 229 | case STATE_STANDBY: |
| 230 | case STATE_AWAKE: |
| 231 | retval = rt2800usb_set_state(rt2x00dev, state); |
| 232 | break; |
| 233 | default: |
| 234 | retval = -ENOTSUPP; |
| 235 | break; |
| 236 | } |
| 237 | |
| 238 | if (unlikely(retval)) |
| 239 | ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n", |
| 240 | state, retval); |
| 241 | |
| 242 | return retval; |
| 243 | } |
| 244 | |
| 245 | /* |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 246 | * Watchdog handlers |
| 247 | */ |
| 248 | static void rt2800usb_watchdog(struct rt2x00_dev *rt2x00dev) |
| 249 | { |
| 250 | unsigned int i; |
| 251 | u32 reg; |
| 252 | |
| 253 | rt2800_register_read(rt2x00dev, TXRXQ_PCNT, ®); |
| 254 | if (rt2x00_get_field32(reg, TXRXQ_PCNT_TX0Q)) { |
| 255 | WARNING(rt2x00dev, "TX HW queue 0 timed out," |
| 256 | " invoke forced kick"); |
| 257 | |
| 258 | rt2800_register_write(rt2x00dev, PBF_CFG, 0xf40012); |
| 259 | |
| 260 | for (i = 0; i < 10; i++) { |
| 261 | udelay(10); |
| 262 | if (!rt2x00_get_field32(reg, TXRXQ_PCNT_TX0Q)) |
| 263 | break; |
| 264 | } |
| 265 | |
| 266 | rt2800_register_write(rt2x00dev, PBF_CFG, 0xf40006); |
| 267 | } |
| 268 | |
| 269 | rt2800_register_read(rt2x00dev, TXRXQ_PCNT, ®); |
| 270 | if (rt2x00_get_field32(reg, TXRXQ_PCNT_TX1Q)) { |
| 271 | WARNING(rt2x00dev, "TX HW queue 1 timed out," |
| 272 | " invoke forced kick"); |
| 273 | |
| 274 | rt2800_register_write(rt2x00dev, PBF_CFG, 0xf4000a); |
| 275 | |
| 276 | for (i = 0; i < 10; i++) { |
| 277 | udelay(10); |
| 278 | if (!rt2x00_get_field32(reg, TXRXQ_PCNT_TX1Q)) |
| 279 | break; |
| 280 | } |
| 281 | |
| 282 | rt2800_register_write(rt2x00dev, PBF_CFG, 0xf40006); |
| 283 | } |
| 284 | |
| 285 | rt2x00usb_watchdog(rt2x00dev); |
| 286 | } |
| 287 | |
| 288 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 289 | * TX descriptor initialization |
| 290 | */ |
Ivo van Doorn | 0c5879b | 2010-08-06 20:47:20 +0200 | [diff] [blame] | 291 | static __le32 *rt2800usb_get_txwi(struct queue_entry *entry) |
Gertjan van Wingerde | 9cf4cb0 | 2010-06-29 21:43:03 +0200 | [diff] [blame] | 292 | { |
Ivo van Doorn | 0c5879b | 2010-08-06 20:47:20 +0200 | [diff] [blame] | 293 | if (entry->queue->qid == QID_BEACON) |
| 294 | return (__le32 *) (entry->skb->data); |
| 295 | else |
| 296 | return (__le32 *) (entry->skb->data + TXINFO_DESC_SIZE); |
Gertjan van Wingerde | 9cf4cb0 | 2010-06-29 21:43:03 +0200 | [diff] [blame] | 297 | } |
| 298 | |
Ivo van Doorn | 9333145 | 2010-08-23 19:53:39 +0200 | [diff] [blame] | 299 | static void rt2800usb_write_tx_desc(struct queue_entry *entry, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 300 | struct txentry_desc *txdesc) |
| 301 | { |
Ivo van Doorn | 9333145 | 2010-08-23 19:53:39 +0200 | [diff] [blame] | 302 | struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); |
| 303 | __le32 *txi = (__le32 *) entry->skb->data; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 304 | u32 word; |
| 305 | |
| 306 | /* |
Gertjan van Wingerde | 59679b9 | 2010-05-08 23:40:21 +0200 | [diff] [blame] | 307 | * Initialize TXINFO descriptor |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 308 | */ |
| 309 | rt2x00_desc_read(txi, 0, &word); |
RA-Jay Hung | b43d63b | 2010-11-13 19:11:46 +0100 | [diff] [blame] | 310 | |
| 311 | /* |
| 312 | * The size of TXINFO_W0_USB_DMA_TX_PKT_LEN is |
| 313 | * TXWI + 802.11 header + L2 pad + payload + pad, |
| 314 | * so need to decrease size of TXINFO and USB end pad. |
| 315 | */ |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 316 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN, |
RA-Jay Hung | b43d63b | 2010-11-13 19:11:46 +0100 | [diff] [blame] | 317 | entry->skb->len - TXINFO_DESC_SIZE - 4); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 318 | rt2x00_set_field32(&word, TXINFO_W0_WIV, |
| 319 | !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc->flags)); |
| 320 | rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2); |
| 321 | rt2x00_set_field32(&word, TXINFO_W0_SW_USE_LAST_ROUND, 0); |
| 322 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_NEXT_VALID, 0); |
| 323 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_BURST, |
| 324 | test_bit(ENTRY_TXD_BURST, &txdesc->flags)); |
| 325 | rt2x00_desc_write(txi, 0, word); |
Gertjan van Wingerde | 85b7a8b | 2010-05-11 23:51:40 +0200 | [diff] [blame] | 326 | |
| 327 | /* |
| 328 | * Register descriptor details in skb frame descriptor. |
| 329 | */ |
Gertjan van Wingerde | 0b8004a | 2010-06-03 10:51:45 +0200 | [diff] [blame] | 330 | skbdesc->flags |= SKBDESC_DESC_IN_SKB; |
Gertjan van Wingerde | 85b7a8b | 2010-05-11 23:51:40 +0200 | [diff] [blame] | 331 | skbdesc->desc = txi; |
| 332 | skbdesc->desc_len = TXINFO_DESC_SIZE + TXWI_DESC_SIZE; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 333 | } |
| 334 | |
RA-Jay Hung | b43d63b | 2010-11-13 19:11:46 +0100 | [diff] [blame] | 335 | static void rt2800usb_write_tx_data(struct queue_entry *entry, |
| 336 | struct txentry_desc *txdesc) |
| 337 | { |
| 338 | u8 padding_len; |
| 339 | |
| 340 | /* |
| 341 | * pad(1~3 bytes) is added after each 802.11 payload. |
| 342 | * USB end pad(4 bytes) is added at each USB bulk out packet end. |
| 343 | * TX frame format is : |
| 344 | * | TXINFO | TXWI | 802.11 header | L2 pad | payload | pad | USB end pad | |
| 345 | * |<------------- tx_pkt_len ------------->| |
| 346 | */ |
| 347 | rt2800_write_tx_data(entry, txdesc); |
| 348 | padding_len = roundup(entry->skb->len + 4, 4) - entry->skb->len; |
| 349 | memset(skb_put(entry->skb, padding_len), 0, padding_len); |
| 350 | } |
| 351 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 352 | /* |
| 353 | * TX data initialization |
| 354 | */ |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 355 | static int rt2800usb_get_tx_data_len(struct queue_entry *entry) |
| 356 | { |
RA-Jay Hung | b43d63b | 2010-11-13 19:11:46 +0100 | [diff] [blame] | 357 | return entry->skb->len; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 358 | } |
| 359 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 360 | /* |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 361 | * TX control handlers |
| 362 | */ |
| 363 | static void rt2800usb_work_txdone(struct work_struct *work) |
| 364 | { |
| 365 | struct rt2x00_dev *rt2x00dev = |
| 366 | container_of(work, struct rt2x00_dev, txdone_work); |
| 367 | struct data_queue *queue; |
| 368 | struct queue_entry *entry; |
| 369 | |
| 370 | rt2800_txdone(rt2x00dev); |
| 371 | |
| 372 | /* |
| 373 | * Process any trailing TX status reports for IO failures, |
| 374 | * we loop until we find the first non-IO error entry. This |
| 375 | * can either be a frame which is free, is being uploaded, |
| 376 | * or has completed the upload but didn't have an entry |
| 377 | * in the TX_STAT_FIFO register yet. |
| 378 | */ |
| 379 | tx_queue_for_each(rt2x00dev, queue) { |
| 380 | while (!rt2x00queue_empty(queue)) { |
| 381 | entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE); |
| 382 | |
| 383 | if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) || |
| 384 | !test_bit(ENTRY_DATA_IO_FAILED, &entry->flags)) |
| 385 | break; |
| 386 | |
| 387 | rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE); |
| 388 | } |
| 389 | } |
| 390 | } |
| 391 | |
Ivo van Doorn | 0e3afe5 | 2010-08-30 21:14:56 +0200 | [diff] [blame] | 392 | static void rt2800usb_kill_tx_queue(struct data_queue *queue) |
| 393 | { |
| 394 | if (queue->qid == QID_BEACON) |
| 395 | rt2x00usb_register_write(queue->rt2x00dev, BCN_TIME_CFG, 0); |
| 396 | |
| 397 | rt2x00usb_kill_tx_queue(queue); |
| 398 | } |
| 399 | |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 400 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 401 | * RX control handlers |
| 402 | */ |
| 403 | static void rt2800usb_fill_rxdone(struct queue_entry *entry, |
| 404 | struct rxdone_entry_desc *rxdesc) |
| 405 | { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 406 | struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 407 | __le32 *rxi = (__le32 *)entry->skb->data; |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 408 | __le32 *rxd; |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 409 | u32 word; |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 410 | int rx_pkt_len; |
| 411 | |
| 412 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 413 | * Copy descriptor to the skbdesc->desc buffer, making it safe from |
| 414 | * moving of frame data in rt2x00usb. |
| 415 | */ |
Benoit Papillault | 5de42f9 | 2009-12-04 23:47:06 +0100 | [diff] [blame] | 416 | memcpy(skbdesc->desc, rxi, skbdesc->desc_len); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 417 | |
| 418 | /* |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 419 | * RX frame format is : |
| 420 | * | RXINFO | RXWI | header | L2 pad | payload | pad | RXD | USB pad | |
| 421 | * |<------------ rx_pkt_len -------------->| |
| 422 | */ |
| 423 | rt2x00_desc_read(rxi, 0, &word); |
| 424 | rx_pkt_len = rt2x00_get_field32(word, RXINFO_W0_USB_DMA_RX_PKT_LEN); |
| 425 | |
| 426 | /* |
| 427 | * Remove the RXINFO structure from the sbk. |
| 428 | */ |
| 429 | skb_pull(entry->skb, RXINFO_DESC_SIZE); |
| 430 | |
| 431 | /* |
| 432 | * FIXME: we need to check for rx_pkt_len validity |
| 433 | */ |
| 434 | rxd = (__le32 *)(entry->skb->data + rx_pkt_len); |
| 435 | |
| 436 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 437 | * It is now safe to read the descriptor on all architectures. |
| 438 | */ |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 439 | rt2x00_desc_read(rxd, 0, &word); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 440 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 441 | if (rt2x00_get_field32(word, RXD_W0_CRC_ERROR)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 442 | rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC; |
| 443 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 444 | rxdesc->cipher_status = rt2x00_get_field32(word, RXD_W0_CIPHER_ERROR); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 445 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 446 | if (rt2x00_get_field32(word, RXD_W0_DECRYPTED)) { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 447 | /* |
| 448 | * Hardware has stripped IV/EIV data from 802.11 frame during |
| 449 | * decryption. Unfortunately the descriptor doesn't contain |
| 450 | * any fields with the EIV/IV data either, so they can't |
| 451 | * be restored by rt2x00lib. |
| 452 | */ |
| 453 | rxdesc->flags |= RX_FLAG_IV_STRIPPED; |
| 454 | |
| 455 | if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS) |
| 456 | rxdesc->flags |= RX_FLAG_DECRYPTED; |
| 457 | else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC) |
| 458 | rxdesc->flags |= RX_FLAG_MMIC_ERROR; |
| 459 | } |
| 460 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 461 | if (rt2x00_get_field32(word, RXD_W0_MY_BSS)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 462 | rxdesc->dev_flags |= RXDONE_MY_BSS; |
| 463 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 464 | if (rt2x00_get_field32(word, RXD_W0_L2PAD)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 465 | rxdesc->dev_flags |= RXDONE_L2PAD; |
| 466 | |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 467 | /* |
| 468 | * Remove RXD descriptor from end of buffer. |
| 469 | */ |
| 470 | skb_trim(entry->skb, rx_pkt_len); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 471 | |
| 472 | /* |
Gertjan van Wingerde | 2de64dd | 2010-05-08 23:40:22 +0200 | [diff] [blame] | 473 | * Process the RXWI structure. |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 474 | */ |
Ivo van Doorn | 7486192 | 2010-07-11 12:23:50 +0200 | [diff] [blame] | 475 | rt2800_process_rxwi(entry, rxdesc); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 476 | } |
| 477 | |
| 478 | /* |
| 479 | * Device probe functions. |
| 480 | */ |
Bartlomiej Zolnierkiewicz | 7ab7132 | 2009-11-08 14:38:54 +0100 | [diff] [blame] | 481 | static int rt2800usb_validate_eeprom(struct rt2x00_dev *rt2x00dev) |
| 482 | { |
Bartlomiej Zolnierkiewicz | 40beee5 | 2009-11-08 14:39:55 +0100 | [diff] [blame] | 483 | if (rt2800_efuse_detect(rt2x00dev)) |
| 484 | rt2800_read_eeprom_efuse(rt2x00dev); |
| 485 | else |
| 486 | rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom, |
| 487 | EEPROM_SIZE); |
Bartlomiej Zolnierkiewicz | 7ab7132 | 2009-11-08 14:38:54 +0100 | [diff] [blame] | 488 | |
| 489 | return rt2800_validate_eeprom(rt2x00dev); |
| 490 | } |
| 491 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 492 | static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev) |
| 493 | { |
| 494 | int retval; |
| 495 | |
| 496 | /* |
| 497 | * Allocate eeprom data. |
| 498 | */ |
| 499 | retval = rt2800usb_validate_eeprom(rt2x00dev); |
| 500 | if (retval) |
| 501 | return retval; |
| 502 | |
Bartlomiej Zolnierkiewicz | 38bd7b8 | 2009-11-08 14:39:01 +0100 | [diff] [blame] | 503 | retval = rt2800_init_eeprom(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 504 | if (retval) |
| 505 | return retval; |
| 506 | |
| 507 | /* |
| 508 | * Initialize hw specifications. |
| 509 | */ |
Bartlomiej Zolnierkiewicz | 4da2933f | 2009-11-08 14:39:32 +0100 | [diff] [blame] | 510 | retval = rt2800_probe_hw_mode(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 511 | if (retval) |
| 512 | return retval; |
| 513 | |
| 514 | /* |
Igor Perminov | 1afcfd54 | 2009-08-08 23:55:55 +0200 | [diff] [blame] | 515 | * This device has multiple filters for control frames |
| 516 | * and has a separate filter for PS Poll frames. |
| 517 | */ |
| 518 | __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags); |
| 519 | __set_bit(DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, &rt2x00dev->flags); |
| 520 | |
| 521 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 522 | * This device requires firmware. |
| 523 | */ |
| 524 | __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 525 | __set_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags); |
| 526 | if (!modparam_nohwcrypt) |
| 527 | __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags); |
Ivo van Doorn | 27df2a9 | 2010-07-11 12:24:22 +0200 | [diff] [blame] | 528 | __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags); |
Ivo van Doorn | c965c74 | 2010-07-11 12:25:46 +0200 | [diff] [blame] | 529 | __set_bit(DRIVER_SUPPORT_WATCHDOG, &rt2x00dev->flags); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 530 | |
| 531 | /* |
| 532 | * Set the rssi offset. |
| 533 | */ |
| 534 | rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET; |
| 535 | |
Ivo van Doorn | 96481b2 | 2010-08-06 20:47:57 +0200 | [diff] [blame] | 536 | /* |
| 537 | * Overwrite TX done handler |
| 538 | */ |
| 539 | PREPARE_WORK(&rt2x00dev->txdone_work, rt2800usb_work_txdone); |
| 540 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 541 | return 0; |
| 542 | } |
| 543 | |
Helmut Schaa | e783619 | 2010-07-11 12:28:54 +0200 | [diff] [blame] | 544 | static const struct ieee80211_ops rt2800usb_mac80211_ops = { |
| 545 | .tx = rt2x00mac_tx, |
| 546 | .start = rt2x00mac_start, |
| 547 | .stop = rt2x00mac_stop, |
| 548 | .add_interface = rt2x00mac_add_interface, |
| 549 | .remove_interface = rt2x00mac_remove_interface, |
| 550 | .config = rt2x00mac_config, |
| 551 | .configure_filter = rt2x00mac_configure_filter, |
| 552 | .set_tim = rt2x00mac_set_tim, |
| 553 | .set_key = rt2x00mac_set_key, |
| 554 | .sw_scan_start = rt2x00mac_sw_scan_start, |
| 555 | .sw_scan_complete = rt2x00mac_sw_scan_complete, |
| 556 | .get_stats = rt2x00mac_get_stats, |
| 557 | .get_tkip_seq = rt2800_get_tkip_seq, |
| 558 | .set_rts_threshold = rt2800_set_rts_threshold, |
| 559 | .bss_info_changed = rt2x00mac_bss_info_changed, |
| 560 | .conf_tx = rt2800_conf_tx, |
| 561 | .get_tsf = rt2800_get_tsf, |
| 562 | .rfkill_poll = rt2x00mac_rfkill_poll, |
| 563 | .ampdu_action = rt2800_ampdu_action, |
Ivo van Doorn | f44df18 | 2010-11-04 20:40:11 +0100 | [diff] [blame] | 564 | .flush = rt2x00mac_flush, |
Helmut Schaa | 977206d | 2010-12-13 12:31:58 +0100 | [diff] [blame^] | 565 | .get_survey = rt2800_get_survey, |
Helmut Schaa | e783619 | 2010-07-11 12:28:54 +0200 | [diff] [blame] | 566 | }; |
| 567 | |
Ivo van Doorn | e796643 | 2010-07-11 12:31:23 +0200 | [diff] [blame] | 568 | static const struct rt2800_ops rt2800usb_rt2800_ops = { |
| 569 | .register_read = rt2x00usb_register_read, |
| 570 | .register_read_lock = rt2x00usb_register_read_lock, |
| 571 | .register_write = rt2x00usb_register_write, |
| 572 | .register_write_lock = rt2x00usb_register_write_lock, |
| 573 | .register_multiread = rt2x00usb_register_multiread, |
| 574 | .register_multiwrite = rt2x00usb_register_multiwrite, |
| 575 | .regbusy_read = rt2x00usb_regbusy_read, |
| 576 | .drv_write_firmware = rt2800usb_write_firmware, |
| 577 | .drv_init_registers = rt2800usb_init_registers, |
Ivo van Doorn | 0c5879b | 2010-08-06 20:47:20 +0200 | [diff] [blame] | 578 | .drv_get_txwi = rt2800usb_get_txwi, |
Ivo van Doorn | e796643 | 2010-07-11 12:31:23 +0200 | [diff] [blame] | 579 | }; |
| 580 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 581 | static const struct rt2x00lib_ops rt2800usb_rt2x00_ops = { |
| 582 | .probe_hw = rt2800usb_probe_hw, |
| 583 | .get_firmware_name = rt2800usb_get_firmware_name, |
Ivo van Doorn | f31c9a8 | 2010-07-11 12:30:37 +0200 | [diff] [blame] | 584 | .check_firmware = rt2800_check_firmware, |
| 585 | .load_firmware = rt2800_load_firmware, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 586 | .initialize = rt2x00usb_initialize, |
| 587 | .uninitialize = rt2x00usb_uninitialize, |
| 588 | .clear_entry = rt2x00usb_clear_entry, |
| 589 | .set_device_state = rt2800usb_set_device_state, |
Bartlomiej Zolnierkiewicz | f445061 | 2009-11-04 18:36:40 +0100 | [diff] [blame] | 590 | .rfkill_poll = rt2800_rfkill_poll, |
| 591 | .link_stats = rt2800_link_stats, |
| 592 | .reset_tuner = rt2800_reset_tuner, |
| 593 | .link_tuner = rt2800_link_tuner, |
Ivo van Doorn | 8c5765f | 2010-11-06 15:49:01 +0100 | [diff] [blame] | 594 | .watchdog = rt2800usb_watchdog, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 595 | .write_tx_desc = rt2800usb_write_tx_desc, |
RA-Jay Hung | b43d63b | 2010-11-13 19:11:46 +0100 | [diff] [blame] | 596 | .write_tx_data = rt2800usb_write_tx_data, |
Gertjan van Wingerde | f0194b2 | 2010-06-03 10:51:53 +0200 | [diff] [blame] | 597 | .write_beacon = rt2800_write_beacon, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 598 | .get_tx_data_len = rt2800usb_get_tx_data_len, |
Gertjan van Wingerde | d61cb26 | 2010-05-08 23:40:24 +0200 | [diff] [blame] | 599 | .kick_tx_queue = rt2x00usb_kick_tx_queue, |
Ivo van Doorn | 0e3afe5 | 2010-08-30 21:14:56 +0200 | [diff] [blame] | 600 | .kill_tx_queue = rt2800usb_kill_tx_queue, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 601 | .fill_rxdone = rt2800usb_fill_rxdone, |
Bartlomiej Zolnierkiewicz | f445061 | 2009-11-04 18:36:40 +0100 | [diff] [blame] | 602 | .config_shared_key = rt2800_config_shared_key, |
| 603 | .config_pairwise_key = rt2800_config_pairwise_key, |
| 604 | .config_filter = rt2800_config_filter, |
| 605 | .config_intf = rt2800_config_intf, |
| 606 | .config_erp = rt2800_config_erp, |
| 607 | .config_ant = rt2800_config_ant, |
| 608 | .config = rt2800_config, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 609 | }; |
| 610 | |
| 611 | static const struct data_queue_desc rt2800usb_queue_rx = { |
Helmut Schaa | efd2f27 | 2010-11-04 20:37:22 +0100 | [diff] [blame] | 612 | .entry_num = 128, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 613 | .data_size = AGGREGATION_SIZE, |
Bartlomiej Zolnierkiewicz | d42c8d8 | 2009-11-04 18:35:47 +0100 | [diff] [blame] | 614 | .desc_size = RXINFO_DESC_SIZE + RXWI_DESC_SIZE, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 615 | .priv_size = sizeof(struct queue_entry_priv_usb), |
| 616 | }; |
| 617 | |
| 618 | static const struct data_queue_desc rt2800usb_queue_tx = { |
Helmut Schaa | efd2f27 | 2010-11-04 20:37:22 +0100 | [diff] [blame] | 619 | .entry_num = 64, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 620 | .data_size = AGGREGATION_SIZE, |
| 621 | .desc_size = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, |
| 622 | .priv_size = sizeof(struct queue_entry_priv_usb), |
| 623 | }; |
| 624 | |
| 625 | static const struct data_queue_desc rt2800usb_queue_bcn = { |
Helmut Schaa | efd2f27 | 2010-11-04 20:37:22 +0100 | [diff] [blame] | 626 | .entry_num = 8, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 627 | .data_size = MGMT_FRAME_SIZE, |
| 628 | .desc_size = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, |
| 629 | .priv_size = sizeof(struct queue_entry_priv_usb), |
| 630 | }; |
| 631 | |
| 632 | static const struct rt2x00_ops rt2800usb_ops = { |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 633 | .name = KBUILD_MODNAME, |
| 634 | .max_sta_intf = 1, |
| 635 | .max_ap_intf = 8, |
| 636 | .eeprom_size = EEPROM_SIZE, |
| 637 | .rf_size = RF_SIZE, |
| 638 | .tx_queues = NUM_TX_QUEUES, |
Gertjan van Wingerde | e6218cc | 2009-11-23 22:44:52 +0100 | [diff] [blame] | 639 | .extra_tx_headroom = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 640 | .rx = &rt2800usb_queue_rx, |
| 641 | .tx = &rt2800usb_queue_tx, |
| 642 | .bcn = &rt2800usb_queue_bcn, |
| 643 | .lib = &rt2800usb_rt2x00_ops, |
Ivo van Doorn | e796643 | 2010-07-11 12:31:23 +0200 | [diff] [blame] | 644 | .drv = &rt2800usb_rt2800_ops, |
Helmut Schaa | e783619 | 2010-07-11 12:28:54 +0200 | [diff] [blame] | 645 | .hw = &rt2800usb_mac80211_ops, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 646 | #ifdef CONFIG_RT2X00_LIB_DEBUGFS |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 647 | .debugfs = &rt2800_rt2x00debug, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 648 | #endif /* CONFIG_RT2X00_LIB_DEBUGFS */ |
| 649 | }; |
| 650 | |
| 651 | /* |
| 652 | * rt2800usb module information. |
| 653 | */ |
| 654 | static struct usb_device_id rt2800usb_device_table[] = { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 655 | /* Abocom */ |
| 656 | { USB_DEVICE(0x07b8, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 657 | { USB_DEVICE(0x07b8, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 658 | { USB_DEVICE(0x07b8, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 659 | { USB_DEVICE(0x07b8, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 660 | { USB_DEVICE(0x07b8, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 661 | { USB_DEVICE(0x1482, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 662 | /* AirTies */ |
| 663 | { USB_DEVICE(0x1eda, 0x2310), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | e895833 | 2010-04-19 11:54:16 +0200 | [diff] [blame] | 664 | /* Allwin */ |
| 665 | { USB_DEVICE(0x8516, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 666 | { USB_DEVICE(0x8516, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 667 | { USB_DEVICE(0x8516, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 668 | { USB_DEVICE(0x8516, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 669 | { USB_DEVICE(0x8516, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 670 | { USB_DEVICE(0x8516, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 671 | /* Amit */ |
| 672 | { USB_DEVICE(0x15c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 673 | /* Askey */ |
| 674 | { USB_DEVICE(0x1690, 0x0740), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 675 | /* ASUS */ |
| 676 | { USB_DEVICE(0x0b05, 0x1731), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 677 | { USB_DEVICE(0x0b05, 0x1732), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 678 | { USB_DEVICE(0x0b05, 0x1742), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 679 | { USB_DEVICE(0x0b05, 0x1784), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 680 | /* AzureWave */ |
| 681 | { USB_DEVICE(0x13d3, 0x3247), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 682 | { USB_DEVICE(0x13d3, 0x3273), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 683 | { USB_DEVICE(0x13d3, 0x3305), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 684 | { USB_DEVICE(0x13d3, 0x3307), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 685 | { USB_DEVICE(0x13d3, 0x3321), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 686 | /* Belkin */ |
| 687 | { USB_DEVICE(0x050d, 0x8053), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 688 | { USB_DEVICE(0x050d, 0x805c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 689 | { USB_DEVICE(0x050d, 0x815c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 690 | /* Buffalo */ |
| 691 | { USB_DEVICE(0x0411, 0x00e8), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 692 | /* Conceptronic */ |
| 693 | { USB_DEVICE(0x14b2, 0x3c06), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 694 | { USB_DEVICE(0x14b2, 0x3c07), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 695 | { USB_DEVICE(0x14b2, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 696 | { USB_DEVICE(0x14b2, 0x3c12), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 697 | { USB_DEVICE(0x14b2, 0x3c23), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 698 | { USB_DEVICE(0x14b2, 0x3c25), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 699 | { USB_DEVICE(0x14b2, 0x3c27), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 700 | { USB_DEVICE(0x14b2, 0x3c28), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 701 | /* Corega */ |
| 702 | { USB_DEVICE(0x07aa, 0x002f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 703 | { USB_DEVICE(0x07aa, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 704 | { USB_DEVICE(0x07aa, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 705 | { USB_DEVICE(0x18c5, 0x0012), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 706 | /* D-Link */ |
| 707 | { USB_DEVICE(0x07d1, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 708 | { USB_DEVICE(0x07d1, 0x3c0a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 709 | { USB_DEVICE(0x07d1, 0x3c0d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 710 | { USB_DEVICE(0x07d1, 0x3c0e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 711 | { USB_DEVICE(0x07d1, 0x3c0f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 712 | { USB_DEVICE(0x07d1, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 713 | { USB_DEVICE(0x07d1, 0x3c16), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 714 | /* Draytek */ |
| 715 | { USB_DEVICE(0x07fa, 0x7712), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 716 | /* Edimax */ |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 717 | { USB_DEVICE(0x7392, 0x7711), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 718 | { USB_DEVICE(0x7392, 0x7717), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 719 | { USB_DEVICE(0x7392, 0x7718), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 720 | /* Encore */ |
| 721 | { USB_DEVICE(0x203d, 0x1480), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 722 | { USB_DEVICE(0x203d, 0x14a9), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 723 | /* EnGenius */ |
Xose Vazquez Perez | a6bc03a | 2010-05-10 11:35:36 +0200 | [diff] [blame] | 724 | { USB_DEVICE(0x1740, 0x9701), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 725 | { USB_DEVICE(0x1740, 0x9702), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 726 | { USB_DEVICE(0x1740, 0x9703), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 727 | { USB_DEVICE(0x1740, 0x9705), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 728 | { USB_DEVICE(0x1740, 0x9706), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 729 | { USB_DEVICE(0x1740, 0x9707), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 730 | { USB_DEVICE(0x1740, 0x9708), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 731 | { USB_DEVICE(0x1740, 0x9709), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 732 | /* Gigabyte */ |
| 733 | { USB_DEVICE(0x1044, 0x800b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 734 | { USB_DEVICE(0x1044, 0x800d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 735 | /* Hawking */ |
| 736 | { USB_DEVICE(0x0e66, 0x0001), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 737 | { USB_DEVICE(0x0e66, 0x0003), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2fddd88 | 2010-04-15 13:25:49 +0200 | [diff] [blame] | 738 | { USB_DEVICE(0x0e66, 0x0009), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 739 | { USB_DEVICE(0x0e66, 0x000b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 740 | { USB_DEVICE(0x0e66, 0x0013), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 741 | { USB_DEVICE(0x0e66, 0x0017), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 742 | { USB_DEVICE(0x0e66, 0x0018), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 743 | /* I-O DATA */ |
| 744 | { USB_DEVICE(0x04bb, 0x0945), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 745 | { USB_DEVICE(0x04bb, 0x0947), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 746 | { USB_DEVICE(0x04bb, 0x0948), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 747 | /* Linksys */ |
| 748 | { USB_DEVICE(0x1737, 0x0070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 749 | { USB_DEVICE(0x1737, 0x0071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 750 | /* Logitec */ |
| 751 | { USB_DEVICE(0x0789, 0x0162), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 752 | { USB_DEVICE(0x0789, 0x0163), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 753 | { USB_DEVICE(0x0789, 0x0164), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 754 | { USB_DEVICE(0x0789, 0x0166), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 755 | /* Motorola */ |
| 756 | { USB_DEVICE(0x100d, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 757 | /* MSI */ |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 758 | { USB_DEVICE(0x0db0, 0x3820), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | fc3f148 | 2010-03-28 15:52:43 +0200 | [diff] [blame] | 759 | { USB_DEVICE(0x0db0, 0x3821), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 760 | { USB_DEVICE(0x0db0, 0x3822), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 761 | { USB_DEVICE(0x0db0, 0x3870), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 762 | { USB_DEVICE(0x0db0, 0x3871), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 763 | { USB_DEVICE(0x0db0, 0x6899), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | fc3f148 | 2010-03-28 15:52:43 +0200 | [diff] [blame] | 764 | { USB_DEVICE(0x0db0, 0x821a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 765 | { USB_DEVICE(0x0db0, 0x822a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | f01a022 | 2010-03-28 20:02:41 +0200 | [diff] [blame] | 766 | { USB_DEVICE(0x0db0, 0x822b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 767 | { USB_DEVICE(0x0db0, 0x822c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | fc3f148 | 2010-03-28 15:52:43 +0200 | [diff] [blame] | 768 | { USB_DEVICE(0x0db0, 0x870a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 769 | { USB_DEVICE(0x0db0, 0x871a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | f01a022 | 2010-03-28 20:02:41 +0200 | [diff] [blame] | 770 | { USB_DEVICE(0x0db0, 0x871b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 771 | { USB_DEVICE(0x0db0, 0x871c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | fc3f148 | 2010-03-28 15:52:43 +0200 | [diff] [blame] | 772 | { USB_DEVICE(0x0db0, 0x899a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 773 | /* Para */ |
| 774 | { USB_DEVICE(0x20b8, 0x8888), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 775 | /* Pegatron */ |
| 776 | { USB_DEVICE(0x1d4d, 0x000c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 777 | { USB_DEVICE(0x1d4d, 0x000e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 778 | /* Philips */ |
| 779 | { USB_DEVICE(0x0471, 0x200f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 780 | /* Planex */ |
| 781 | { USB_DEVICE(0x2019, 0xab25), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 782 | { USB_DEVICE(0x2019, 0xed06), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 783 | /* Quanta */ |
| 784 | { USB_DEVICE(0x1a32, 0x0304), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 785 | /* Ralink */ |
| 786 | { USB_DEVICE(0x148f, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 787 | { USB_DEVICE(0x148f, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 788 | { USB_DEVICE(0x148f, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 789 | { USB_DEVICE(0x148f, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 790 | { USB_DEVICE(0x148f, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 791 | { USB_DEVICE(0x148f, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 792 | /* Samsung */ |
| 793 | { USB_DEVICE(0x04e8, 0x2018), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 794 | /* Siemens */ |
| 795 | { USB_DEVICE(0x129b, 0x1828), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 796 | /* Sitecom */ |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 797 | { USB_DEVICE(0x0df6, 0x0017), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 798 | { USB_DEVICE(0x0df6, 0x002b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 799 | { USB_DEVICE(0x0df6, 0x002c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 800 | { USB_DEVICE(0x0df6, 0x002d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 801 | { USB_DEVICE(0x0df6, 0x0039), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 802 | { USB_DEVICE(0x0df6, 0x003b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 803 | { USB_DEVICE(0x0df6, 0x003d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 804 | { USB_DEVICE(0x0df6, 0x003e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 805 | { USB_DEVICE(0x0df6, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | a5e944f | 2010-04-14 12:16:00 +0200 | [diff] [blame] | 806 | { USB_DEVICE(0x0df6, 0x0040), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 807 | { USB_DEVICE(0x0df6, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | fc3f148 | 2010-03-28 15:52:43 +0200 | [diff] [blame] | 808 | { USB_DEVICE(0x0df6, 0x0047), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 809 | { USB_DEVICE(0x0df6, 0x0048), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 810 | /* SMC */ |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 811 | { USB_DEVICE(0x083a, 0x6618), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 812 | { USB_DEVICE(0x083a, 0x7511), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 813 | { USB_DEVICE(0x083a, 0x7512), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 814 | { USB_DEVICE(0x083a, 0x7522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 815 | { USB_DEVICE(0x083a, 0x8522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 816 | { USB_DEVICE(0x083a, 0xa618), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | fc3f148 | 2010-03-28 15:52:43 +0200 | [diff] [blame] | 817 | { USB_DEVICE(0x083a, 0xa701), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 818 | { USB_DEVICE(0x083a, 0xa702), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | f01a022 | 2010-03-28 20:02:41 +0200 | [diff] [blame] | 819 | { USB_DEVICE(0x083a, 0xa703), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 820 | { USB_DEVICE(0x083a, 0xb522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 821 | /* Sparklan */ |
| 822 | { USB_DEVICE(0x15a9, 0x0006), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 823 | /* Sweex */ |
| 824 | { USB_DEVICE(0x177f, 0x0302), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 825 | /* U-Media*/ |
| 826 | { USB_DEVICE(0x157e, 0x300e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 827 | /* ZCOM */ |
| 828 | { USB_DEVICE(0x0cde, 0x0022), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 829 | { USB_DEVICE(0x0cde, 0x0025), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 830 | /* Zinwell */ |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 831 | { USB_DEVICE(0x5a57, 0x0280), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 832 | { USB_DEVICE(0x5a57, 0x0282), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 833 | { USB_DEVICE(0x5a57, 0x0283), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 834 | { USB_DEVICE(0x5a57, 0x5257), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | a6a8d66e | 2010-11-13 19:10:31 +0100 | [diff] [blame] | 835 | /* Zyxel */ |
| 836 | { USB_DEVICE(0x0586, 0x3416), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | f93bc9b | 2010-11-13 19:09:50 +0100 | [diff] [blame] | 837 | #ifdef CONFIG_RT2800USB_RT33XX |
| 838 | /* Ralink */ |
| 839 | { USB_DEVICE(0x148f, 0x3370), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 840 | { USB_DEVICE(0x148f, 0x8070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 841 | /* Sitecom */ |
| 842 | { USB_DEVICE(0x0df6, 0x0050), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 843 | #endif |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 844 | #ifdef CONFIG_RT2800USB_RT35XX |
Xose Vazquez Perez | e895833 | 2010-04-19 11:54:16 +0200 | [diff] [blame] | 845 | /* Allwin */ |
| 846 | { USB_DEVICE(0x8516, 0x3572), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 847 | /* Askey */ |
| 848 | { USB_DEVICE(0x1690, 0x0744), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 849 | /* Cisco */ |
| 850 | { USB_DEVICE(0x167b, 0x4001), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 851 | /* EnGenius */ |
| 852 | { USB_DEVICE(0x1740, 0x9801), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 853 | /* I-O DATA */ |
| 854 | { USB_DEVICE(0x04bb, 0x0944), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 855 | /* Ralink */ |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 856 | { USB_DEVICE(0x148f, 0x3572), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 857 | /* Sitecom */ |
| 858 | { USB_DEVICE(0x0df6, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 859 | /* Zinwell */ |
| 860 | { USB_DEVICE(0x5a57, 0x0284), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 861 | #endif |
| 862 | #ifdef CONFIG_RT2800USB_UNKNOWN |
| 863 | /* |
| 864 | * 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] | 865 | * vendor linux driver). |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 866 | */ |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 867 | /* Amigo */ |
| 868 | { USB_DEVICE(0x0e0b, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 869 | { USB_DEVICE(0x0e0b, 0x9041), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 870 | /* ASUS */ |
| 871 | { USB_DEVICE(0x0b05, 0x1760), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 872 | { USB_DEVICE(0x0b05, 0x1761), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 873 | { USB_DEVICE(0x0b05, 0x1790), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 874 | { USB_DEVICE(0x1761, 0x0b05), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 875 | /* AzureWave */ |
| 876 | { USB_DEVICE(0x13d3, 0x3262), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 877 | { USB_DEVICE(0x13d3, 0x3284), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 12ef116 | 2010-05-03 13:11:38 +0200 | [diff] [blame] | 878 | { USB_DEVICE(0x13d3, 0x3322), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 879 | /* Belkin */ |
| 880 | { USB_DEVICE(0x050d, 0x825a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 881 | /* Buffalo */ |
| 882 | { USB_DEVICE(0x0411, 0x012e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 883 | { USB_DEVICE(0x0411, 0x0148), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 884 | { USB_DEVICE(0x0411, 0x0150), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 885 | { USB_DEVICE(0x0411, 0x015d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 886 | /* Conceptronic */ |
| 887 | { USB_DEVICE(0x14b2, 0x3c08), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 888 | { USB_DEVICE(0x14b2, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 889 | /* Corega */ |
| 890 | { USB_DEVICE(0x07aa, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 891 | { USB_DEVICE(0x07aa, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 892 | { USB_DEVICE(0x18c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 893 | /* D-Link */ |
| 894 | { USB_DEVICE(0x07d1, 0x3c0b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 895 | { USB_DEVICE(0x07d1, 0x3c13), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 896 | { USB_DEVICE(0x07d1, 0x3c15), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 12ef116 | 2010-05-03 13:11:38 +0200 | [diff] [blame] | 897 | { USB_DEVICE(0x07d1, 0x3c17), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 898 | /* Encore */ |
| 899 | { USB_DEVICE(0x203d, 0x14a1), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 900 | /* Gemtek */ |
| 901 | { USB_DEVICE(0x15a9, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 902 | /* Gigabyte */ |
| 903 | { USB_DEVICE(0x1044, 0x800c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 904 | /* LevelOne */ |
| 905 | { USB_DEVICE(0x1740, 0x0605), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 906 | { USB_DEVICE(0x1740, 0x0615), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 907 | /* Linksys */ |
| 908 | { USB_DEVICE(0x1737, 0x0077), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 909 | { USB_DEVICE(0x1737, 0x0078), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 910 | { USB_DEVICE(0x1737, 0x0079), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 911 | /* Motorola */ |
| 912 | { USB_DEVICE(0x100d, 0x9032), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 913 | /* Ovislink */ |
Xose Vazquez Perez | 12ef116 | 2010-05-03 13:11:38 +0200 | [diff] [blame] | 914 | { USB_DEVICE(0x1b75, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 915 | { USB_DEVICE(0x1b75, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 916 | /* Pegatron */ |
| 917 | { USB_DEVICE(0x05a6, 0x0101), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 918 | { USB_DEVICE(0x1d4d, 0x0002), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 919 | { USB_DEVICE(0x1d4d, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 12ef116 | 2010-05-03 13:11:38 +0200 | [diff] [blame] | 920 | { USB_DEVICE(0x1d4d, 0x0011), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 921 | /* Planex */ |
| 922 | { USB_DEVICE(0x2019, 0xab24), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 923 | /* Qcom */ |
| 924 | { USB_DEVICE(0x18e8, 0x6259), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 925 | /* SMC */ |
| 926 | { USB_DEVICE(0x083a, 0xa512), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 927 | { USB_DEVICE(0x083a, 0xc522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 928 | { USB_DEVICE(0x083a, 0xd522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 12ef116 | 2010-05-03 13:11:38 +0200 | [diff] [blame] | 929 | { USB_DEVICE(0x083a, 0xf511), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 930 | /* Sweex */ |
| 931 | { USB_DEVICE(0x177f, 0x0153), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 932 | { USB_DEVICE(0x177f, 0x0313), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 933 | /* Zyxel */ |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 934 | { USB_DEVICE(0x0586, 0x341a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | de1ebdc | 2010-02-14 12:52:05 +0100 | [diff] [blame] | 935 | #endif |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 936 | { 0, } |
| 937 | }; |
| 938 | |
| 939 | MODULE_AUTHOR(DRV_PROJECT); |
| 940 | MODULE_VERSION(DRV_VERSION); |
| 941 | MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver."); |
| 942 | MODULE_SUPPORTED_DEVICE("Ralink RT2870 USB chipset based cards"); |
| 943 | MODULE_DEVICE_TABLE(usb, rt2800usb_device_table); |
| 944 | MODULE_FIRMWARE(FIRMWARE_RT2870); |
| 945 | MODULE_LICENSE("GPL"); |
| 946 | |
| 947 | static struct usb_driver rt2800usb_driver = { |
| 948 | .name = KBUILD_MODNAME, |
| 949 | .id_table = rt2800usb_device_table, |
| 950 | .probe = rt2x00usb_probe, |
| 951 | .disconnect = rt2x00usb_disconnect, |
| 952 | .suspend = rt2x00usb_suspend, |
| 953 | .resume = rt2x00usb_resume, |
| 954 | }; |
| 955 | |
| 956 | static int __init rt2800usb_init(void) |
| 957 | { |
| 958 | return usb_register(&rt2800usb_driver); |
| 959 | } |
| 960 | |
| 961 | static void __exit rt2800usb_exit(void) |
| 962 | { |
| 963 | usb_deregister(&rt2800usb_driver); |
| 964 | } |
| 965 | |
| 966 | module_init(rt2800usb_init); |
| 967 | module_exit(rt2800usb_exit); |