Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1 | /* |
Gertjan van Wingerde | 9c9a0d1 | 2009-11-08 16:39:55 +0100 | [diff] [blame] | 2 | Copyright (C) 2009 Ivo van Doorn <IvDoorn@gmail.com> |
| 3 | Copyright (C) 2009 Mattias Nissler <mattias.nissler@gmx.de> |
| 4 | Copyright (C) 2009 Felix Fietkau <nbd@openwrt.org> |
| 5 | Copyright (C) 2009 Xose Vazquez Perez <xose.vazquez@gmail.com> |
| 6 | Copyright (C) 2009 Axel Kollhofer <rain_maker@root-forum.org> |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 7 | <http://rt2x00.serialmonkey.com> |
| 8 | |
| 9 | This program is free software; you can redistribute it and/or modify |
| 10 | it under the terms of the GNU General Public License as published by |
| 11 | the Free Software Foundation; either version 2 of the License, or |
| 12 | (at your option) any later version. |
| 13 | |
| 14 | This program is distributed in the hope that it will be useful, |
| 15 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | GNU General Public License for more details. |
| 18 | |
| 19 | You should have received a copy of the GNU General Public License |
| 20 | along with this program; if not, write to the |
| 21 | Free Software Foundation, Inc., |
| 22 | 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 23 | */ |
| 24 | |
| 25 | /* |
| 26 | Module: rt2800usb |
| 27 | Abstract: rt2800usb device specific routines. |
| 28 | Supported chipsets: RT2800U. |
| 29 | */ |
| 30 | |
| 31 | #include <linux/crc-ccitt.h> |
| 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 | */ |
| 48 | static int modparam_nohwcrypt = 1; |
| 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 | |
| 60 | static bool rt2800usb_check_crc(const u8 *data, const size_t len) |
| 61 | { |
| 62 | u16 fw_crc; |
| 63 | u16 crc; |
| 64 | |
| 65 | /* |
| 66 | * The last 2 bytes in the firmware array are the crc checksum itself, |
| 67 | * this means that we should never pass those 2 bytes to the crc |
| 68 | * algorithm. |
| 69 | */ |
| 70 | fw_crc = (data[len - 2] << 8 | data[len - 1]); |
| 71 | |
| 72 | /* |
| 73 | * Use the crc ccitt algorithm. |
| 74 | * This will return the same value as the legacy driver which |
| 75 | * used bit ordering reversion on the both the firmware bytes |
| 76 | * before input input as well as on the final output. |
| 77 | * Obviously using crc ccitt directly is much more efficient. |
| 78 | */ |
| 79 | crc = crc_ccitt(~0, data, len - 2); |
| 80 | |
| 81 | /* |
| 82 | * There is a small difference between the crc-itu-t + bitrev and |
| 83 | * the crc-ccitt crc calculation. In the latter method the 2 bytes |
| 84 | * will be swapped, use swab16 to convert the crc to the correct |
| 85 | * value. |
| 86 | */ |
| 87 | crc = swab16(crc); |
| 88 | |
| 89 | return fw_crc == crc; |
| 90 | } |
| 91 | |
| 92 | static int rt2800usb_check_firmware(struct rt2x00_dev *rt2x00dev, |
| 93 | const u8 *data, const size_t len) |
| 94 | { |
| 95 | u16 chipset = (rt2x00_rev(&rt2x00dev->chip) >> 16) & 0xffff; |
| 96 | size_t offset = 0; |
| 97 | |
| 98 | /* |
| 99 | * Firmware files: |
| 100 | * There are 2 variations of the rt2870 firmware. |
| 101 | * a) size: 4kb |
| 102 | * b) size: 8kb |
Daniel Mack | 3ad2f3fb | 2010-02-03 08:01:28 +0800 | [diff] [blame^] | 103 | * Note that (b) contains 2 separate firmware blobs of 4k |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 104 | * within the file. The first blob is the same firmware as (a), |
| 105 | * but the second blob is for the additional chipsets. |
| 106 | */ |
| 107 | if (len != 4096 && len != 8192) |
| 108 | return FW_BAD_LENGTH; |
| 109 | |
| 110 | /* |
| 111 | * Check if we need the upper 4kb firmware data or not. |
| 112 | */ |
| 113 | if ((len == 4096) && |
| 114 | (chipset != 0x2860) && |
| 115 | (chipset != 0x2872) && |
| 116 | (chipset != 0x3070)) |
| 117 | return FW_BAD_VERSION; |
| 118 | |
| 119 | /* |
| 120 | * 8kb firmware files must be checked as if it were |
Daniel Mack | 3ad2f3fb | 2010-02-03 08:01:28 +0800 | [diff] [blame^] | 121 | * 2 separate firmware files. |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 122 | */ |
| 123 | while (offset < len) { |
| 124 | if (!rt2800usb_check_crc(data + offset, 4096)) |
| 125 | return FW_BAD_CRC; |
| 126 | |
| 127 | offset += 4096; |
| 128 | } |
| 129 | |
| 130 | return FW_OK; |
| 131 | } |
| 132 | |
| 133 | static int rt2800usb_load_firmware(struct rt2x00_dev *rt2x00dev, |
| 134 | const u8 *data, const size_t len) |
| 135 | { |
| 136 | unsigned int i; |
| 137 | int status; |
| 138 | u32 reg; |
| 139 | u32 offset; |
| 140 | u32 length; |
| 141 | u16 chipset = (rt2x00_rev(&rt2x00dev->chip) >> 16) & 0xffff; |
| 142 | |
| 143 | /* |
| 144 | * Check which section of the firmware we need. |
| 145 | */ |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 146 | if ((chipset == 0x2860) || |
| 147 | (chipset == 0x2872) || |
| 148 | (chipset == 0x3070)) { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 149 | offset = 0; |
| 150 | length = 4096; |
| 151 | } else { |
| 152 | offset = 4096; |
| 153 | length = 4096; |
| 154 | } |
| 155 | |
| 156 | /* |
| 157 | * Wait for stable hardware. |
| 158 | */ |
| 159 | for (i = 0; i < REGISTER_BUSY_COUNT; i++) { |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 160 | rt2800_register_read(rt2x00dev, MAC_CSR0, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 161 | if (reg && reg != ~0) |
| 162 | break; |
| 163 | msleep(1); |
| 164 | } |
| 165 | |
| 166 | if (i == REGISTER_BUSY_COUNT) { |
| 167 | ERROR(rt2x00dev, "Unstable hardware.\n"); |
| 168 | return -EBUSY; |
| 169 | } |
| 170 | |
| 171 | /* |
| 172 | * Write firmware to device. |
| 173 | */ |
| 174 | rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, |
| 175 | USB_VENDOR_REQUEST_OUT, |
| 176 | FIRMWARE_IMAGE_BASE, |
| 177 | data + offset, length, |
| 178 | REGISTER_TIMEOUT32(length)); |
| 179 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 180 | rt2800_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); |
| 181 | rt2800_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 182 | |
| 183 | /* |
| 184 | * Send firmware request to device to load firmware, |
| 185 | * we need to specify a long timeout time. |
| 186 | */ |
| 187 | status = rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, |
| 188 | 0, USB_MODE_FIRMWARE, |
| 189 | REGISTER_TIMEOUT_FIRMWARE); |
| 190 | if (status < 0) { |
| 191 | ERROR(rt2x00dev, "Failed to write Firmware to device.\n"); |
| 192 | return status; |
| 193 | } |
| 194 | |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 195 | msleep(10); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 196 | rt2800_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 197 | |
| 198 | /* |
| 199 | * Send signal to firmware during boot time. |
| 200 | */ |
Bartlomiej Zolnierkiewicz | 4f2c532 | 2009-11-04 18:34:32 +0100 | [diff] [blame] | 201 | rt2800_mcu_request(rt2x00dev, MCU_BOOT_SIGNAL, 0xff, 0, 0); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 202 | |
| 203 | if ((chipset == 0x3070) || |
| 204 | (chipset == 0x3071) || |
| 205 | (chipset == 0x3572)) { |
| 206 | udelay(200); |
Bartlomiej Zolnierkiewicz | 4f2c532 | 2009-11-04 18:34:32 +0100 | [diff] [blame] | 207 | rt2800_mcu_request(rt2x00dev, MCU_CURRENT, 0, 0, 0); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 208 | udelay(10); |
| 209 | } |
| 210 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 211 | /* |
| 212 | * Wait for device to stabilize. |
| 213 | */ |
| 214 | for (i = 0; i < REGISTER_BUSY_COUNT; i++) { |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 215 | rt2800_register_read(rt2x00dev, PBF_SYS_CTRL, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 216 | if (rt2x00_get_field32(reg, PBF_SYS_CTRL_READY)) |
| 217 | break; |
| 218 | msleep(1); |
| 219 | } |
| 220 | |
| 221 | if (i == REGISTER_BUSY_COUNT) { |
| 222 | ERROR(rt2x00dev, "PBF system register not ready.\n"); |
| 223 | return -EBUSY; |
| 224 | } |
| 225 | |
| 226 | /* |
| 227 | * Initialize firmware. |
| 228 | */ |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 229 | rt2800_register_write(rt2x00dev, H2M_BBP_AGENT, 0); |
| 230 | rt2800_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 231 | msleep(1); |
| 232 | |
| 233 | return 0; |
| 234 | } |
| 235 | |
| 236 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 237 | * Device state switch handlers. |
| 238 | */ |
| 239 | static void rt2800usb_toggle_rx(struct rt2x00_dev *rt2x00dev, |
| 240 | enum dev_state state) |
| 241 | { |
| 242 | u32 reg; |
| 243 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 244 | rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 245 | rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_RX, |
| 246 | (state == STATE_RADIO_RX_ON) || |
| 247 | (state == STATE_RADIO_RX_ON_LINK)); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 248 | rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | static int rt2800usb_wait_wpdma_ready(struct rt2x00_dev *rt2x00dev) |
| 252 | { |
| 253 | unsigned int i; |
| 254 | u32 reg; |
| 255 | |
| 256 | for (i = 0; i < REGISTER_BUSY_COUNT; i++) { |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 257 | rt2800_register_read(rt2x00dev, WPDMA_GLO_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 258 | if (!rt2x00_get_field32(reg, WPDMA_GLO_CFG_TX_DMA_BUSY) && |
| 259 | !rt2x00_get_field32(reg, WPDMA_GLO_CFG_RX_DMA_BUSY)) |
| 260 | return 0; |
| 261 | |
| 262 | msleep(1); |
| 263 | } |
| 264 | |
| 265 | ERROR(rt2x00dev, "WPDMA TX/RX busy, aborting.\n"); |
| 266 | return -EACCES; |
| 267 | } |
| 268 | |
| 269 | static int rt2800usb_enable_radio(struct rt2x00_dev *rt2x00dev) |
| 270 | { |
| 271 | u32 reg; |
| 272 | u16 word; |
| 273 | |
| 274 | /* |
| 275 | * Initialize all registers. |
| 276 | */ |
| 277 | if (unlikely(rt2800usb_wait_wpdma_ready(rt2x00dev) || |
Bartlomiej Zolnierkiewicz | fcf5154 | 2009-11-04 18:36:57 +0100 | [diff] [blame] | 278 | rt2800_init_registers(rt2x00dev) || |
| 279 | rt2800_init_bbp(rt2x00dev) || |
| 280 | rt2800_init_rfcsr(rt2x00dev))) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 281 | return -EIO; |
| 282 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 283 | rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 284 | rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_TX, 1); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 285 | rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 286 | |
| 287 | udelay(50); |
| 288 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 289 | rt2800_register_read(rt2x00dev, WPDMA_GLO_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 290 | rt2x00_set_field32(®, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1); |
| 291 | rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_RX_DMA, 1); |
| 292 | rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_TX_DMA, 1); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 293 | rt2800_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 294 | |
| 295 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 296 | rt2800_register_read(rt2x00dev, USB_DMA_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 297 | rt2x00_set_field32(®, USB_DMA_CFG_PHY_CLEAR, 0); |
| 298 | /* Don't use bulk in aggregation when working with USB 1.1 */ |
| 299 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_EN, |
| 300 | (rt2x00dev->rx->usb_maxpacket == 512)); |
| 301 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_TIMEOUT, 128); |
Ivo van Doorn | 15e4692 | 2009-04-28 20:14:58 +0200 | [diff] [blame] | 302 | /* |
| 303 | * Total room for RX frames in kilobytes, PBF might still exceed |
| 304 | * this limit so reduce the number to prevent errors. |
| 305 | */ |
| 306 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_LIMIT, |
| 307 | ((RX_ENTRIES * DATA_FRAME_SIZE) / 1024) - 3); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 308 | rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_EN, 1); |
| 309 | rt2x00_set_field32(®, USB_DMA_CFG_TX_BULK_EN, 1); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 310 | rt2800_register_write(rt2x00dev, USB_DMA_CFG, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 311 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 312 | rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 313 | rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_TX, 1); |
| 314 | rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_RX, 1); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 315 | rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 316 | |
| 317 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 318 | * Initialize LED control |
| 319 | */ |
| 320 | rt2x00_eeprom_read(rt2x00dev, EEPROM_LED1, &word); |
Bartlomiej Zolnierkiewicz | 4f2c532 | 2009-11-04 18:34:32 +0100 | [diff] [blame] | 321 | rt2800_mcu_request(rt2x00dev, MCU_LED_1, 0xff, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 322 | word & 0xff, (word >> 8) & 0xff); |
| 323 | |
| 324 | rt2x00_eeprom_read(rt2x00dev, EEPROM_LED2, &word); |
Bartlomiej Zolnierkiewicz | 4f2c532 | 2009-11-04 18:34:32 +0100 | [diff] [blame] | 325 | rt2800_mcu_request(rt2x00dev, MCU_LED_2, 0xff, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 326 | word & 0xff, (word >> 8) & 0xff); |
| 327 | |
| 328 | rt2x00_eeprom_read(rt2x00dev, EEPROM_LED3, &word); |
Bartlomiej Zolnierkiewicz | 4f2c532 | 2009-11-04 18:34:32 +0100 | [diff] [blame] | 329 | rt2800_mcu_request(rt2x00dev, MCU_LED_3, 0xff, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 330 | word & 0xff, (word >> 8) & 0xff); |
| 331 | |
| 332 | return 0; |
| 333 | } |
| 334 | |
| 335 | static void rt2800usb_disable_radio(struct rt2x00_dev *rt2x00dev) |
| 336 | { |
| 337 | u32 reg; |
| 338 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 339 | rt2800_register_read(rt2x00dev, WPDMA_GLO_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 340 | rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0); |
| 341 | rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 342 | rt2800_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 343 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 344 | rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, 0); |
| 345 | rt2800_register_write(rt2x00dev, PWR_PIN_CFG, 0); |
| 346 | rt2800_register_write(rt2x00dev, TX_PIN_CFG, 0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 347 | |
| 348 | /* Wait for DMA, ignore error */ |
| 349 | rt2800usb_wait_wpdma_ready(rt2x00dev); |
| 350 | |
| 351 | rt2x00usb_disable_radio(rt2x00dev); |
| 352 | } |
| 353 | |
| 354 | static int rt2800usb_set_state(struct rt2x00_dev *rt2x00dev, |
| 355 | enum dev_state state) |
| 356 | { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 357 | if (state == STATE_AWAKE) |
Bartlomiej Zolnierkiewicz | 4f2c532 | 2009-11-04 18:34:32 +0100 | [diff] [blame] | 358 | rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 0); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 359 | else |
Bartlomiej Zolnierkiewicz | 4f2c532 | 2009-11-04 18:34:32 +0100 | [diff] [blame] | 360 | rt2800_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0, 2); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 361 | |
| 362 | return 0; |
| 363 | } |
| 364 | |
| 365 | static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev, |
| 366 | enum dev_state state) |
| 367 | { |
| 368 | int retval = 0; |
| 369 | |
| 370 | switch (state) { |
| 371 | case STATE_RADIO_ON: |
| 372 | /* |
| 373 | * Before the radio can be enabled, the device first has |
| 374 | * to be woken up. After that it needs a bit of time |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 375 | * to be fully awake and then the radio can be enabled. |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 376 | */ |
| 377 | rt2800usb_set_state(rt2x00dev, STATE_AWAKE); |
| 378 | msleep(1); |
| 379 | retval = rt2800usb_enable_radio(rt2x00dev); |
| 380 | break; |
| 381 | case STATE_RADIO_OFF: |
| 382 | /* |
Luis Correia | 4951348 | 2009-07-17 21:39:19 +0200 | [diff] [blame] | 383 | * After the radio has been disabled, the device should |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 384 | * be put to sleep for powersaving. |
| 385 | */ |
| 386 | rt2800usb_disable_radio(rt2x00dev); |
| 387 | rt2800usb_set_state(rt2x00dev, STATE_SLEEP); |
| 388 | break; |
| 389 | case STATE_RADIO_RX_ON: |
| 390 | case STATE_RADIO_RX_ON_LINK: |
| 391 | case STATE_RADIO_RX_OFF: |
| 392 | case STATE_RADIO_RX_OFF_LINK: |
| 393 | rt2800usb_toggle_rx(rt2x00dev, state); |
| 394 | break; |
| 395 | case STATE_RADIO_IRQ_ON: |
| 396 | case STATE_RADIO_IRQ_OFF: |
| 397 | /* No support, but no error either */ |
| 398 | break; |
| 399 | case STATE_DEEP_SLEEP: |
| 400 | case STATE_SLEEP: |
| 401 | case STATE_STANDBY: |
| 402 | case STATE_AWAKE: |
| 403 | retval = rt2800usb_set_state(rt2x00dev, state); |
| 404 | break; |
| 405 | default: |
| 406 | retval = -ENOTSUPP; |
| 407 | break; |
| 408 | } |
| 409 | |
| 410 | if (unlikely(retval)) |
| 411 | ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n", |
| 412 | state, retval); |
| 413 | |
| 414 | return retval; |
| 415 | } |
| 416 | |
| 417 | /* |
| 418 | * TX descriptor initialization |
| 419 | */ |
| 420 | static void rt2800usb_write_tx_desc(struct rt2x00_dev *rt2x00dev, |
| 421 | struct sk_buff *skb, |
| 422 | struct txentry_desc *txdesc) |
| 423 | { |
| 424 | struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb); |
| 425 | __le32 *txi = skbdesc->desc; |
| 426 | __le32 *txwi = &txi[TXINFO_DESC_SIZE / sizeof(__le32)]; |
| 427 | u32 word; |
| 428 | |
| 429 | /* |
| 430 | * Initialize TX Info descriptor |
| 431 | */ |
| 432 | rt2x00_desc_read(txwi, 0, &word); |
| 433 | rt2x00_set_field32(&word, TXWI_W0_FRAG, |
| 434 | test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags)); |
| 435 | rt2x00_set_field32(&word, TXWI_W0_MIMO_PS, 0); |
| 436 | rt2x00_set_field32(&word, TXWI_W0_CF_ACK, 0); |
| 437 | rt2x00_set_field32(&word, TXWI_W0_TS, |
| 438 | test_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc->flags)); |
| 439 | rt2x00_set_field32(&word, TXWI_W0_AMPDU, |
| 440 | test_bit(ENTRY_TXD_HT_AMPDU, &txdesc->flags)); |
| 441 | rt2x00_set_field32(&word, TXWI_W0_MPDU_DENSITY, txdesc->mpdu_density); |
| 442 | rt2x00_set_field32(&word, TXWI_W0_TX_OP, txdesc->ifs); |
| 443 | rt2x00_set_field32(&word, TXWI_W0_MCS, txdesc->mcs); |
| 444 | rt2x00_set_field32(&word, TXWI_W0_BW, |
| 445 | test_bit(ENTRY_TXD_HT_BW_40, &txdesc->flags)); |
| 446 | rt2x00_set_field32(&word, TXWI_W0_SHORT_GI, |
| 447 | test_bit(ENTRY_TXD_HT_SHORT_GI, &txdesc->flags)); |
| 448 | rt2x00_set_field32(&word, TXWI_W0_STBC, txdesc->stbc); |
| 449 | rt2x00_set_field32(&word, TXWI_W0_PHYMODE, txdesc->rate_mode); |
| 450 | rt2x00_desc_write(txwi, 0, word); |
| 451 | |
| 452 | rt2x00_desc_read(txwi, 1, &word); |
| 453 | rt2x00_set_field32(&word, TXWI_W1_ACK, |
| 454 | test_bit(ENTRY_TXD_ACK, &txdesc->flags)); |
| 455 | rt2x00_set_field32(&word, TXWI_W1_NSEQ, |
| 456 | test_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags)); |
| 457 | rt2x00_set_field32(&word, TXWI_W1_BW_WIN_SIZE, txdesc->ba_size); |
| 458 | rt2x00_set_field32(&word, TXWI_W1_WIRELESS_CLI_ID, |
| 459 | test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags) ? |
Benoit PAPILLAULT | 1761631 | 2009-10-15 21:17:09 +0200 | [diff] [blame] | 460 | txdesc->key_idx : 0xff); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 461 | rt2x00_set_field32(&word, TXWI_W1_MPDU_TOTAL_BYTE_COUNT, |
| 462 | skb->len - txdesc->l2pad); |
| 463 | rt2x00_set_field32(&word, TXWI_W1_PACKETID, |
Ivo van Doorn | 534aff0 | 2009-08-17 18:55:15 +0200 | [diff] [blame] | 464 | skbdesc->entry->queue->qid + 1); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 465 | rt2x00_desc_write(txwi, 1, word); |
| 466 | |
| 467 | /* |
| 468 | * Always write 0 to IV/EIV fields, hardware will insert the IV |
| 469 | * from the IVEIV register when TXINFO_W0_WIV is set to 0. |
| 470 | * When TXINFO_W0_WIV is set to 1 it will use the IV data |
| 471 | * from the descriptor. The TXWI_W1_WIRELESS_CLI_ID indicates which |
| 472 | * crypto entry in the registers should be used to encrypt the frame. |
| 473 | */ |
| 474 | _rt2x00_desc_write(txwi, 2, 0 /* skbdesc->iv[0] */); |
| 475 | _rt2x00_desc_write(txwi, 3, 0 /* skbdesc->iv[1] */); |
| 476 | |
| 477 | /* |
| 478 | * Initialize TX descriptor |
| 479 | */ |
| 480 | rt2x00_desc_read(txi, 0, &word); |
| 481 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN, |
| 482 | skb->len + TXWI_DESC_SIZE); |
| 483 | rt2x00_set_field32(&word, TXINFO_W0_WIV, |
| 484 | !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc->flags)); |
| 485 | rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2); |
| 486 | rt2x00_set_field32(&word, TXINFO_W0_SW_USE_LAST_ROUND, 0); |
| 487 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_NEXT_VALID, 0); |
| 488 | rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_BURST, |
| 489 | test_bit(ENTRY_TXD_BURST, &txdesc->flags)); |
| 490 | rt2x00_desc_write(txi, 0, word); |
| 491 | } |
| 492 | |
| 493 | /* |
| 494 | * TX data initialization |
| 495 | */ |
| 496 | static void rt2800usb_write_beacon(struct queue_entry *entry) |
| 497 | { |
| 498 | struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; |
| 499 | struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); |
| 500 | unsigned int beacon_base; |
| 501 | u32 reg; |
| 502 | |
| 503 | /* |
| 504 | * Add the descriptor in front of the skb. |
| 505 | */ |
| 506 | skb_push(entry->skb, entry->queue->desc_size); |
| 507 | memcpy(entry->skb->data, skbdesc->desc, skbdesc->desc_len); |
| 508 | skbdesc->desc = entry->skb->data; |
| 509 | |
| 510 | /* |
| 511 | * Disable beaconing while we are reloading the beacon data, |
| 512 | * otherwise we might be sending out invalid data. |
| 513 | */ |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 514 | rt2800_register_read(rt2x00dev, BCN_TIME_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 515 | rt2x00_set_field32(®, BCN_TIME_CFG_BEACON_GEN, 0); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 516 | rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 517 | |
| 518 | /* |
| 519 | * Write entire beacon with descriptor to register. |
| 520 | */ |
| 521 | beacon_base = HW_BEACON_OFFSET(entry->entry_idx); |
| 522 | rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, |
| 523 | USB_VENDOR_REQUEST_OUT, beacon_base, |
| 524 | entry->skb->data, entry->skb->len, |
| 525 | REGISTER_TIMEOUT32(entry->skb->len)); |
| 526 | |
| 527 | /* |
| 528 | * Clean up the beacon skb. |
| 529 | */ |
| 530 | dev_kfree_skb(entry->skb); |
| 531 | entry->skb = NULL; |
| 532 | } |
| 533 | |
| 534 | static int rt2800usb_get_tx_data_len(struct queue_entry *entry) |
| 535 | { |
| 536 | int length; |
| 537 | |
| 538 | /* |
| 539 | * The length _must_ include 4 bytes padding, |
| 540 | * it should always be multiple of 4, |
| 541 | * but it must _not_ be a multiple of the USB packet size. |
| 542 | */ |
| 543 | length = roundup(entry->skb->len + 4, 4); |
| 544 | length += (4 * !(length % entry->queue->usb_maxpacket)); |
| 545 | |
| 546 | return length; |
| 547 | } |
| 548 | |
| 549 | static void rt2800usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev, |
| 550 | const enum data_queue_qid queue) |
| 551 | { |
| 552 | u32 reg; |
| 553 | |
| 554 | if (queue != QID_BEACON) { |
| 555 | rt2x00usb_kick_tx_queue(rt2x00dev, queue); |
| 556 | return; |
| 557 | } |
| 558 | |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 559 | rt2800_register_read(rt2x00dev, BCN_TIME_CFG, ®); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 560 | if (!rt2x00_get_field32(reg, BCN_TIME_CFG_BEACON_GEN)) { |
| 561 | rt2x00_set_field32(®, BCN_TIME_CFG_TSF_TICKING, 1); |
| 562 | rt2x00_set_field32(®, BCN_TIME_CFG_TBTT_ENABLE, 1); |
| 563 | rt2x00_set_field32(®, BCN_TIME_CFG_BEACON_GEN, 1); |
Bartlomiej Zolnierkiewicz | abbb505 | 2009-11-04 18:33:05 +0100 | [diff] [blame] | 564 | rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 565 | } |
| 566 | } |
| 567 | |
| 568 | /* |
| 569 | * RX control handlers |
| 570 | */ |
| 571 | static void rt2800usb_fill_rxdone(struct queue_entry *entry, |
| 572 | struct rxdone_entry_desc *rxdesc) |
| 573 | { |
| 574 | struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; |
| 575 | struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); |
| 576 | __le32 *rxd = (__le32 *)entry->skb->data; |
| 577 | __le32 *rxwi; |
| 578 | u32 rxd0; |
| 579 | u32 rxwi0; |
| 580 | u32 rxwi1; |
| 581 | u32 rxwi2; |
| 582 | u32 rxwi3; |
| 583 | |
| 584 | /* |
| 585 | * Copy descriptor to the skbdesc->desc buffer, making it safe from |
| 586 | * moving of frame data in rt2x00usb. |
| 587 | */ |
| 588 | memcpy(skbdesc->desc, rxd, skbdesc->desc_len); |
| 589 | rxd = (__le32 *)skbdesc->desc; |
Bartlomiej Zolnierkiewicz | d42c8d8 | 2009-11-04 18:35:47 +0100 | [diff] [blame] | 590 | rxwi = &rxd[RXINFO_DESC_SIZE / sizeof(__le32)]; |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 591 | |
| 592 | /* |
| 593 | * It is now safe to read the descriptor on all architectures. |
| 594 | */ |
| 595 | rt2x00_desc_read(rxd, 0, &rxd0); |
| 596 | rt2x00_desc_read(rxwi, 0, &rxwi0); |
| 597 | rt2x00_desc_read(rxwi, 1, &rxwi1); |
| 598 | rt2x00_desc_read(rxwi, 2, &rxwi2); |
| 599 | rt2x00_desc_read(rxwi, 3, &rxwi3); |
| 600 | |
Bartlomiej Zolnierkiewicz | 4116cb4 | 2009-11-08 14:39:40 +0100 | [diff] [blame] | 601 | if (rt2x00_get_field32(rxd0, RXINFO_W0_CRC_ERROR)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 602 | rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC; |
| 603 | |
| 604 | if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags)) { |
| 605 | rxdesc->cipher = rt2x00_get_field32(rxwi0, RXWI_W0_UDF); |
| 606 | rxdesc->cipher_status = |
Bartlomiej Zolnierkiewicz | 4116cb4 | 2009-11-08 14:39:40 +0100 | [diff] [blame] | 607 | rt2x00_get_field32(rxd0, RXINFO_W0_CIPHER_ERROR); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 608 | } |
| 609 | |
Bartlomiej Zolnierkiewicz | 4116cb4 | 2009-11-08 14:39:40 +0100 | [diff] [blame] | 610 | if (rt2x00_get_field32(rxd0, RXINFO_W0_DECRYPTED)) { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 611 | /* |
| 612 | * Hardware has stripped IV/EIV data from 802.11 frame during |
| 613 | * decryption. Unfortunately the descriptor doesn't contain |
| 614 | * any fields with the EIV/IV data either, so they can't |
| 615 | * be restored by rt2x00lib. |
| 616 | */ |
| 617 | rxdesc->flags |= RX_FLAG_IV_STRIPPED; |
| 618 | |
| 619 | if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS) |
| 620 | rxdesc->flags |= RX_FLAG_DECRYPTED; |
| 621 | else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC) |
| 622 | rxdesc->flags |= RX_FLAG_MMIC_ERROR; |
| 623 | } |
| 624 | |
Bartlomiej Zolnierkiewicz | 4116cb4 | 2009-11-08 14:39:40 +0100 | [diff] [blame] | 625 | if (rt2x00_get_field32(rxd0, RXINFO_W0_MY_BSS)) |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 626 | rxdesc->dev_flags |= RXDONE_MY_BSS; |
| 627 | |
Bartlomiej Zolnierkiewicz | 4116cb4 | 2009-11-08 14:39:40 +0100 | [diff] [blame] | 628 | if (rt2x00_get_field32(rxd0, RXINFO_W0_L2PAD)) { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 629 | rxdesc->dev_flags |= RXDONE_L2PAD; |
Ivo van Doorn | 0fefe0f | 2009-08-17 18:54:50 +0200 | [diff] [blame] | 630 | skbdesc->flags |= SKBDESC_L2_PADDED; |
| 631 | } |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 632 | |
| 633 | if (rt2x00_get_field32(rxwi1, RXWI_W1_SHORT_GI)) |
| 634 | rxdesc->flags |= RX_FLAG_SHORT_GI; |
| 635 | |
| 636 | if (rt2x00_get_field32(rxwi1, RXWI_W1_BW)) |
| 637 | rxdesc->flags |= RX_FLAG_40MHZ; |
| 638 | |
| 639 | /* |
| 640 | * Detect RX rate, always use MCS as signal type. |
| 641 | */ |
| 642 | rxdesc->dev_flags |= RXDONE_SIGNAL_MCS; |
| 643 | rxdesc->rate_mode = rt2x00_get_field32(rxwi1, RXWI_W1_PHYMODE); |
| 644 | rxdesc->signal = rt2x00_get_field32(rxwi1, RXWI_W1_MCS); |
| 645 | |
| 646 | /* |
| 647 | * Mask of 0x8 bit to remove the short preamble flag. |
| 648 | */ |
| 649 | if (rxdesc->rate_mode == RATE_MODE_CCK) |
| 650 | rxdesc->signal &= ~0x8; |
| 651 | |
| 652 | rxdesc->rssi = |
| 653 | (rt2x00_get_field32(rxwi2, RXWI_W2_RSSI0) + |
| 654 | rt2x00_get_field32(rxwi2, RXWI_W2_RSSI1)) / 2; |
| 655 | |
| 656 | rxdesc->noise = |
| 657 | (rt2x00_get_field32(rxwi3, RXWI_W3_SNR0) + |
| 658 | rt2x00_get_field32(rxwi3, RXWI_W3_SNR1)) / 2; |
| 659 | |
| 660 | rxdesc->size = rt2x00_get_field32(rxwi0, RXWI_W0_MPDU_TOTAL_BYTE_COUNT); |
| 661 | |
| 662 | /* |
| 663 | * Remove RXWI descriptor from start of buffer. |
| 664 | */ |
| 665 | skb_pull(entry->skb, skbdesc->desc_len); |
| 666 | skb_trim(entry->skb, rxdesc->size); |
| 667 | } |
| 668 | |
| 669 | /* |
| 670 | * Device probe functions. |
| 671 | */ |
Bartlomiej Zolnierkiewicz | 7ab7132 | 2009-11-08 14:38:54 +0100 | [diff] [blame] | 672 | static int rt2800usb_validate_eeprom(struct rt2x00_dev *rt2x00dev) |
| 673 | { |
Bartlomiej Zolnierkiewicz | 40beee5 | 2009-11-08 14:39:55 +0100 | [diff] [blame] | 674 | if (rt2800_efuse_detect(rt2x00dev)) |
| 675 | rt2800_read_eeprom_efuse(rt2x00dev); |
| 676 | else |
| 677 | rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom, |
| 678 | EEPROM_SIZE); |
Bartlomiej Zolnierkiewicz | 7ab7132 | 2009-11-08 14:38:54 +0100 | [diff] [blame] | 679 | |
| 680 | return rt2800_validate_eeprom(rt2x00dev); |
| 681 | } |
| 682 | |
Bartlomiej Zolnierkiewicz | 7a345d3 | 2009-11-04 18:34:53 +0100 | [diff] [blame] | 683 | static const struct rt2800_ops rt2800usb_rt2800_ops = { |
| 684 | .register_read = rt2x00usb_register_read, |
Gertjan van Wingerde | 31a4cf1f | 2009-11-14 20:20:36 +0100 | [diff] [blame] | 685 | .register_read_lock = rt2x00usb_register_read_lock, |
Bartlomiej Zolnierkiewicz | 7a345d3 | 2009-11-04 18:34:53 +0100 | [diff] [blame] | 686 | .register_write = rt2x00usb_register_write, |
| 687 | .register_write_lock = rt2x00usb_register_write_lock, |
| 688 | |
| 689 | .register_multiread = rt2x00usb_register_multiread, |
| 690 | .register_multiwrite = rt2x00usb_register_multiwrite, |
| 691 | |
| 692 | .regbusy_read = rt2x00usb_regbusy_read, |
| 693 | }; |
| 694 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 695 | static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev) |
| 696 | { |
| 697 | int retval; |
| 698 | |
Bartlomiej Zolnierkiewicz | 7a345d3 | 2009-11-04 18:34:53 +0100 | [diff] [blame] | 699 | rt2x00dev->priv = (void *)&rt2800usb_rt2800_ops; |
| 700 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 701 | /* |
| 702 | * Allocate eeprom data. |
| 703 | */ |
| 704 | retval = rt2800usb_validate_eeprom(rt2x00dev); |
| 705 | if (retval) |
| 706 | return retval; |
| 707 | |
Bartlomiej Zolnierkiewicz | 38bd7b8 | 2009-11-08 14:39:01 +0100 | [diff] [blame] | 708 | retval = rt2800_init_eeprom(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 709 | if (retval) |
| 710 | return retval; |
| 711 | |
| 712 | /* |
| 713 | * Initialize hw specifications. |
| 714 | */ |
Bartlomiej Zolnierkiewicz | 4da2933 | 2009-11-08 14:39:32 +0100 | [diff] [blame] | 715 | retval = rt2800_probe_hw_mode(rt2x00dev); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 716 | if (retval) |
| 717 | return retval; |
| 718 | |
| 719 | /* |
Igor Perminov | 1afcfd54 | 2009-08-08 23:55:55 +0200 | [diff] [blame] | 720 | * This device has multiple filters for control frames |
| 721 | * and has a separate filter for PS Poll frames. |
| 722 | */ |
| 723 | __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags); |
| 724 | __set_bit(DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, &rt2x00dev->flags); |
| 725 | |
| 726 | /* |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 727 | * This device requires firmware. |
| 728 | */ |
| 729 | __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags); |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 730 | __set_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags); |
| 731 | if (!modparam_nohwcrypt) |
| 732 | __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags); |
| 733 | |
| 734 | /* |
| 735 | * Set the rssi offset. |
| 736 | */ |
| 737 | rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET; |
| 738 | |
| 739 | return 0; |
| 740 | } |
| 741 | |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 742 | static const struct rt2x00lib_ops rt2800usb_rt2x00_ops = { |
| 743 | .probe_hw = rt2800usb_probe_hw, |
| 744 | .get_firmware_name = rt2800usb_get_firmware_name, |
| 745 | .check_firmware = rt2800usb_check_firmware, |
| 746 | .load_firmware = rt2800usb_load_firmware, |
| 747 | .initialize = rt2x00usb_initialize, |
| 748 | .uninitialize = rt2x00usb_uninitialize, |
| 749 | .clear_entry = rt2x00usb_clear_entry, |
| 750 | .set_device_state = rt2800usb_set_device_state, |
Bartlomiej Zolnierkiewicz | f445061 | 2009-11-04 18:36:40 +0100 | [diff] [blame] | 751 | .rfkill_poll = rt2800_rfkill_poll, |
| 752 | .link_stats = rt2800_link_stats, |
| 753 | .reset_tuner = rt2800_reset_tuner, |
| 754 | .link_tuner = rt2800_link_tuner, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 755 | .write_tx_desc = rt2800usb_write_tx_desc, |
| 756 | .write_tx_data = rt2x00usb_write_tx_data, |
| 757 | .write_beacon = rt2800usb_write_beacon, |
| 758 | .get_tx_data_len = rt2800usb_get_tx_data_len, |
| 759 | .kick_tx_queue = rt2800usb_kick_tx_queue, |
| 760 | .kill_tx_queue = rt2x00usb_kill_tx_queue, |
| 761 | .fill_rxdone = rt2800usb_fill_rxdone, |
Bartlomiej Zolnierkiewicz | f445061 | 2009-11-04 18:36:40 +0100 | [diff] [blame] | 762 | .config_shared_key = rt2800_config_shared_key, |
| 763 | .config_pairwise_key = rt2800_config_pairwise_key, |
| 764 | .config_filter = rt2800_config_filter, |
| 765 | .config_intf = rt2800_config_intf, |
| 766 | .config_erp = rt2800_config_erp, |
| 767 | .config_ant = rt2800_config_ant, |
| 768 | .config = rt2800_config, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 769 | }; |
| 770 | |
| 771 | static const struct data_queue_desc rt2800usb_queue_rx = { |
| 772 | .entry_num = RX_ENTRIES, |
| 773 | .data_size = AGGREGATION_SIZE, |
Bartlomiej Zolnierkiewicz | d42c8d8 | 2009-11-04 18:35:47 +0100 | [diff] [blame] | 774 | .desc_size = RXINFO_DESC_SIZE + RXWI_DESC_SIZE, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 775 | .priv_size = sizeof(struct queue_entry_priv_usb), |
| 776 | }; |
| 777 | |
| 778 | static const struct data_queue_desc rt2800usb_queue_tx = { |
| 779 | .entry_num = TX_ENTRIES, |
| 780 | .data_size = AGGREGATION_SIZE, |
| 781 | .desc_size = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, |
| 782 | .priv_size = sizeof(struct queue_entry_priv_usb), |
| 783 | }; |
| 784 | |
| 785 | static const struct data_queue_desc rt2800usb_queue_bcn = { |
| 786 | .entry_num = 8 * BEACON_ENTRIES, |
| 787 | .data_size = MGMT_FRAME_SIZE, |
| 788 | .desc_size = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, |
| 789 | .priv_size = sizeof(struct queue_entry_priv_usb), |
| 790 | }; |
| 791 | |
| 792 | static const struct rt2x00_ops rt2800usb_ops = { |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 793 | .name = KBUILD_MODNAME, |
| 794 | .max_sta_intf = 1, |
| 795 | .max_ap_intf = 8, |
| 796 | .eeprom_size = EEPROM_SIZE, |
| 797 | .rf_size = RF_SIZE, |
| 798 | .tx_queues = NUM_TX_QUEUES, |
Gertjan van Wingerde | e6218cc | 2009-11-23 22:44:52 +0100 | [diff] [blame] | 799 | .extra_tx_headroom = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 800 | .rx = &rt2800usb_queue_rx, |
| 801 | .tx = &rt2800usb_queue_tx, |
| 802 | .bcn = &rt2800usb_queue_bcn, |
| 803 | .lib = &rt2800usb_rt2x00_ops, |
| 804 | .hw = &rt2800_mac80211_ops, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 805 | #ifdef CONFIG_RT2X00_LIB_DEBUGFS |
Gertjan van Wingerde | 04d0362 | 2009-11-23 22:44:51 +0100 | [diff] [blame] | 806 | .debugfs = &rt2800_rt2x00debug, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 807 | #endif /* CONFIG_RT2X00_LIB_DEBUGFS */ |
| 808 | }; |
| 809 | |
| 810 | /* |
| 811 | * rt2800usb module information. |
| 812 | */ |
| 813 | static struct usb_device_id rt2800usb_device_table[] = { |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 814 | /* Abocom */ |
| 815 | { USB_DEVICE(0x07b8, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 816 | { USB_DEVICE(0x07b8, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 817 | { USB_DEVICE(0x07b8, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 818 | { USB_DEVICE(0x07b8, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 819 | { USB_DEVICE(0x07b8, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 820 | { USB_DEVICE(0x1482, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 821 | /* AirTies */ |
| 822 | { USB_DEVICE(0x1eda, 0x2310), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 823 | /* Amigo */ |
| 824 | { USB_DEVICE(0x0e0b, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 825 | { USB_DEVICE(0x0e0b, 0x9041), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 826 | /* Amit */ |
| 827 | { USB_DEVICE(0x15c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 828 | /* Askey */ |
| 829 | { USB_DEVICE(0x1690, 0x0740), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 830 | { USB_DEVICE(0x1690, 0x0744), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 831 | { USB_DEVICE(0x0930, 0x0a07), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 832 | /* ASUS */ |
| 833 | { USB_DEVICE(0x0b05, 0x1731), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 834 | { USB_DEVICE(0x0b05, 0x1732), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 835 | { USB_DEVICE(0x0b05, 0x1742), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 836 | { USB_DEVICE(0x0b05, 0x1760), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 837 | { USB_DEVICE(0x0b05, 0x1761), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 838 | { USB_DEVICE(0x0b05, 0x1784), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 839 | /* AzureWave */ |
| 840 | { USB_DEVICE(0x13d3, 0x3247), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 841 | { USB_DEVICE(0x13d3, 0x3262), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 842 | { USB_DEVICE(0x13d3, 0x3273), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 843 | { USB_DEVICE(0x13d3, 0x3284), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 844 | { USB_DEVICE(0x13d3, 0x3305), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 845 | /* Belkin */ |
| 846 | { USB_DEVICE(0x050d, 0x8053), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 847 | { USB_DEVICE(0x050d, 0x805c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 848 | { USB_DEVICE(0x050d, 0x815c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | 2c617b0 | 2009-05-19 07:26:04 +0200 | [diff] [blame] | 849 | { USB_DEVICE(0x050d, 0x825a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 850 | /* Buffalo */ |
| 851 | { USB_DEVICE(0x0411, 0x00e8), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 852 | { USB_DEVICE(0x0411, 0x012e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 853 | /* Cisco */ |
| 854 | { USB_DEVICE(0x167b, 0x4001), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 855 | /* Conceptronic */ |
| 856 | { USB_DEVICE(0x14b2, 0x3c06), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 857 | { USB_DEVICE(0x14b2, 0x3c07), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 858 | { USB_DEVICE(0x14b2, 0x3c08), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 859 | { USB_DEVICE(0x14b2, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 860 | { USB_DEVICE(0x14b2, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 861 | { USB_DEVICE(0x14b2, 0x3c12), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 862 | { USB_DEVICE(0x14b2, 0x3c23), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 863 | { USB_DEVICE(0x14b2, 0x3c25), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 864 | { USB_DEVICE(0x14b2, 0x3c27), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 865 | { USB_DEVICE(0x14b2, 0x3c28), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 866 | /* Corega */ |
| 867 | { USB_DEVICE(0x07aa, 0x002f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 868 | { USB_DEVICE(0x07aa, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 869 | { USB_DEVICE(0x07aa, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 870 | { USB_DEVICE(0x07aa, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 871 | { USB_DEVICE(0x07aa, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 872 | { USB_DEVICE(0x18c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 873 | { USB_DEVICE(0x18c5, 0x0012), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 874 | /* D-Link */ |
| 875 | { USB_DEVICE(0x07d1, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 876 | { USB_DEVICE(0x07d1, 0x3c0a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 877 | { USB_DEVICE(0x07d1, 0x3c0b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 878 | { USB_DEVICE(0x07d1, 0x3c0d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 879 | { USB_DEVICE(0x07d1, 0x3c0e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 880 | { USB_DEVICE(0x07d1, 0x3c0f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 881 | { USB_DEVICE(0x07d1, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 882 | { USB_DEVICE(0x07d1, 0x3c13), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 883 | { USB_DEVICE(0x07d1, 0x3c15), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 884 | /* Edimax */ |
| 885 | { USB_DEVICE(0x7392, 0x7711), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 886 | { USB_DEVICE(0x7392, 0x7717), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 887 | { USB_DEVICE(0x7392, 0x7718), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 888 | /* Encore */ |
| 889 | { USB_DEVICE(0x203d, 0x1480), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 890 | { USB_DEVICE(0x203d, 0x14a1), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 891 | { USB_DEVICE(0x203d, 0x14a9), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 892 | /* EnGenius */ |
| 893 | { USB_DEVICE(0X1740, 0x9701), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 894 | { USB_DEVICE(0x1740, 0x9702), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 895 | { USB_DEVICE(0x1740, 0x9703), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 896 | { USB_DEVICE(0x1740, 0x9705), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 897 | { USB_DEVICE(0x1740, 0x9706), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 898 | { USB_DEVICE(0x1740, 0x9707), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 899 | { USB_DEVICE(0x1740, 0x9708), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 900 | { USB_DEVICE(0x1740, 0x9709), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 901 | { USB_DEVICE(0x1740, 0x9801), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 902 | /* Gemtek */ |
| 903 | { USB_DEVICE(0x15a9, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 904 | /* Gigabyte */ |
| 905 | { USB_DEVICE(0x1044, 0x800b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 906 | { USB_DEVICE(0x1044, 0x800c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 907 | { USB_DEVICE(0x1044, 0x800d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 908 | /* Hawking */ |
| 909 | { USB_DEVICE(0x0e66, 0x0001), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 910 | { USB_DEVICE(0x0e66, 0x0003), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 911 | { USB_DEVICE(0x0e66, 0x0009), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 912 | { USB_DEVICE(0x0e66, 0x000b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 913 | /* I-O DATA */ |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 914 | { USB_DEVICE(0x04bb, 0x0944), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 915 | { USB_DEVICE(0x04bb, 0x0945), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 916 | { USB_DEVICE(0x04bb, 0x0947), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 917 | { USB_DEVICE(0x04bb, 0x0948), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 918 | /* LevelOne */ |
| 919 | { USB_DEVICE(0x1740, 0x0605), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 920 | { USB_DEVICE(0x1740, 0x0615), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 921 | /* Linksys */ |
| 922 | { USB_DEVICE(0x1737, 0x0070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 923 | { USB_DEVICE(0x1737, 0x0071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | e430d60 | 2009-04-27 23:58:31 +0200 | [diff] [blame] | 924 | { USB_DEVICE(0x1737, 0x0077), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Gertjan van Wingerde | 5e31258 | 2009-12-23 00:03:21 +0100 | [diff] [blame] | 925 | { USB_DEVICE(0x1737, 0x0079), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 926 | /* Logitec */ |
| 927 | { USB_DEVICE(0x0789, 0x0162), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 928 | { USB_DEVICE(0x0789, 0x0163), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 929 | { USB_DEVICE(0x0789, 0x0164), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 930 | /* Motorola */ |
| 931 | { USB_DEVICE(0x100d, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 932 | { USB_DEVICE(0x100d, 0x9032), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 933 | /* MSI */ |
| 934 | { USB_DEVICE(0x0db0, 0x3820), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 935 | { USB_DEVICE(0x0db0, 0x3821), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 936 | { USB_DEVICE(0x0db0, 0x3870), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 937 | { USB_DEVICE(0x0db0, 0x6899), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 938 | { USB_DEVICE(0x0db0, 0x821a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 939 | { USB_DEVICE(0x0db0, 0x870a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 940 | { USB_DEVICE(0x0db0, 0x899a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 941 | /* Ovislink */ |
| 942 | { USB_DEVICE(0x1b75, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 943 | /* Para */ |
| 944 | { USB_DEVICE(0x20b8, 0x8888), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 945 | /* Pegatron */ |
| 946 | { USB_DEVICE(0x1d4d, 0x0002), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 947 | { USB_DEVICE(0x1d4d, 0x000c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 948 | { USB_DEVICE(0x1d4d, 0x000e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 949 | /* Philips */ |
| 950 | { USB_DEVICE(0x0471, 0x200f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 951 | /* Planex */ |
| 952 | { USB_DEVICE(0x2019, 0xed06), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 953 | { USB_DEVICE(0x2019, 0xab24), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 954 | { USB_DEVICE(0x2019, 0xab25), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 955 | /* Qcom */ |
| 956 | { USB_DEVICE(0x18e8, 0x6259), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 957 | /* Quanta */ |
| 958 | { USB_DEVICE(0x1a32, 0x0304), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 959 | /* Ralink */ |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 960 | { USB_DEVICE(0x148f, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 961 | { USB_DEVICE(0x148f, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 962 | { USB_DEVICE(0x148f, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 963 | { USB_DEVICE(0x148f, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 964 | { USB_DEVICE(0x148f, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 965 | { USB_DEVICE(0x148f, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 966 | { USB_DEVICE(0x148f, 0x3572), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 967 | /* Samsung */ |
| 968 | { USB_DEVICE(0x04e8, 0x2018), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 969 | /* Siemens */ |
| 970 | { USB_DEVICE(0x129b, 0x1828), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 971 | /* Sitecom */ |
| 972 | { USB_DEVICE(0x0df6, 0x0017), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 973 | { USB_DEVICE(0x0df6, 0x002b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 974 | { USB_DEVICE(0x0df6, 0x002c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 975 | { USB_DEVICE(0x0df6, 0x002d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 976 | { USB_DEVICE(0x0df6, 0x0039), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 977 | { USB_DEVICE(0x0df6, 0x003b), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 978 | { USB_DEVICE(0x0df6, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 979 | { USB_DEVICE(0x0df6, 0x003d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 980 | { USB_DEVICE(0x0df6, 0x003e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 981 | { USB_DEVICE(0x0df6, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 982 | { USB_DEVICE(0x0df6, 0x0040), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 983 | { USB_DEVICE(0x0df6, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 984 | { USB_DEVICE(0x0df6, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 985 | { USB_DEVICE(0x0df6, 0x0047), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 986 | { USB_DEVICE(0x0df6, 0x0048), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 987 | { USB_DEVICE(0x0df6, 0x004a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 988 | { USB_DEVICE(0x0df6, 0x004d), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 989 | /* SMC */ |
| 990 | { USB_DEVICE(0x083a, 0x6618), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 991 | { USB_DEVICE(0x083a, 0x7511), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 992 | { USB_DEVICE(0x083a, 0x7512), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 993 | { USB_DEVICE(0x083a, 0x7522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 994 | { USB_DEVICE(0x083a, 0x8522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 995 | { USB_DEVICE(0x083a, 0xa512), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 996 | { USB_DEVICE(0x083a, 0xa618), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 997 | { USB_DEVICE(0x083a, 0xa701), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 998 | { USB_DEVICE(0x083a, 0xa702), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 999 | { USB_DEVICE(0x083a, 0xb522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1000 | { USB_DEVICE(0x083a, 0xc522), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1001 | /* Sparklan */ |
| 1002 | { USB_DEVICE(0x15a9, 0x0006), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | 3b91c36 | 2009-05-21 19:16:14 +0200 | [diff] [blame] | 1003 | /* Sweex */ |
| 1004 | { USB_DEVICE(0x177f, 0x0153), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1005 | { USB_DEVICE(0x177f, 0x0302), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1006 | { USB_DEVICE(0x177f, 0x0313), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1007 | /* U-Media*/ |
| 1008 | { USB_DEVICE(0x157e, 0x300e), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1009 | /* ZCOM */ |
| 1010 | { USB_DEVICE(0x0cde, 0x0022), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1011 | { USB_DEVICE(0x0cde, 0x0025), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1012 | /* Zinwell */ |
| 1013 | { USB_DEVICE(0x5a57, 0x0280), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1014 | { USB_DEVICE(0x5a57, 0x0282), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 1015 | { USB_DEVICE(0x5a57, 0x0283), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Xose Vazquez Perez | 2edcb7f | 2009-11-17 13:43:16 +0100 | [diff] [blame] | 1016 | { USB_DEVICE(0x5a57, 0x0284), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | ce2ebc9 | 2009-05-22 21:33:21 +0200 | [diff] [blame] | 1017 | { USB_DEVICE(0x5a57, 0x5257), USB_DEVICE_DATA(&rt2800usb_ops) }, |
Ivo van Doorn | d53d9e6 | 2009-04-26 15:47:48 +0200 | [diff] [blame] | 1018 | /* Zyxel */ |
| 1019 | { USB_DEVICE(0x0586, 0x3416), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1020 | { USB_DEVICE(0x0586, 0x341a), USB_DEVICE_DATA(&rt2800usb_ops) }, |
| 1021 | { 0, } |
| 1022 | }; |
| 1023 | |
| 1024 | MODULE_AUTHOR(DRV_PROJECT); |
| 1025 | MODULE_VERSION(DRV_VERSION); |
| 1026 | MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver."); |
| 1027 | MODULE_SUPPORTED_DEVICE("Ralink RT2870 USB chipset based cards"); |
| 1028 | MODULE_DEVICE_TABLE(usb, rt2800usb_device_table); |
| 1029 | MODULE_FIRMWARE(FIRMWARE_RT2870); |
| 1030 | MODULE_LICENSE("GPL"); |
| 1031 | |
| 1032 | static struct usb_driver rt2800usb_driver = { |
| 1033 | .name = KBUILD_MODNAME, |
| 1034 | .id_table = rt2800usb_device_table, |
| 1035 | .probe = rt2x00usb_probe, |
| 1036 | .disconnect = rt2x00usb_disconnect, |
| 1037 | .suspend = rt2x00usb_suspend, |
| 1038 | .resume = rt2x00usb_resume, |
| 1039 | }; |
| 1040 | |
| 1041 | static int __init rt2800usb_init(void) |
| 1042 | { |
| 1043 | return usb_register(&rt2800usb_driver); |
| 1044 | } |
| 1045 | |
| 1046 | static void __exit rt2800usb_exit(void) |
| 1047 | { |
| 1048 | usb_deregister(&rt2800usb_driver); |
| 1049 | } |
| 1050 | |
| 1051 | module_init(rt2800usb_init); |
| 1052 | module_exit(rt2800usb_exit); |