drivers/net/wireless/rt2x00/rt2800usb.c

   1 /*
   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>
   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"
  41 #include "rt2800lib.h"
  42 #include "rt2800.h"
  43 #include "rt2800usb.h"
  44
  45 /*
  46  * Allow hardware encryption to be disabled.
  47  */
  48 static int modparam_nohwcrypt = 0;
  49 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
  50 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
  51
  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         size_t offset = 0;
  96
  97         /*
  98          * Firmware files:
  99          * There are 2 variations of the rt2870 firmware.
 100          * a) size: 4kb
 101          * b) size: 8kb
 102          * Note that (b) contains 2 separate firmware blobs of 4k
 103          * within the file. The first blob is the same firmware as (a),
 104          * but the second blob is for the additional chipsets.
 105          */
 106         if (len != 4096 && len != 8192)
 107                 return FW_BAD_LENGTH;
 108
 109         /*
 110          * Check if we need the upper 4kb firmware data or not.
 111          */
 112         if ((len == 4096) &&
 113             !rt2x00_rt(rt2x00dev, RT2860) &&
 114             !rt2x00_rt(rt2x00dev, RT2872) &&
 115             !rt2x00_rt(rt2x00dev, RT3070))
 116                 return FW_BAD_VERSION;
 117
 118         /*
 119          * 8kb firmware files must be checked as if it were
 120          * 2 separate firmware files.
 121          */
 122         while (offset < len) {
 123                 if (!rt2800usb_check_crc(data + offset, 4096))
 124                         return FW_BAD_CRC;
 125
 126                 offset += 4096;
 127         }
 128
 129         return FW_OK;
 130 }
 131
 132 static int rt2800usb_load_firmware(struct rt2x00_dev *rt2x00dev,
 133                                    const u8 *data, const size_t len)
 134 {
 135         unsigned int i;
 136         int status;
 137         u32 reg;
 138         u32 offset;
 139         u32 length;
 140
 141         /*
 142          * Check which section of the firmware we need.
 143          */
 144         if (rt2x00_rt(rt2x00dev, RT2860) ||
 145             rt2x00_rt(rt2x00dev, RT2872) ||
 146             rt2x00_rt(rt2x00dev, RT3070)) {
 147                 offset = 0;
 148                 length = 4096;
 149         } else {
 150                 offset = 4096;
 151                 length = 4096;
 152         }
 153
 154         /*
 155          * Wait for stable hardware.
 156          */
 157         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
 158                 rt2800_register_read(rt2x00dev, MAC_CSR0, &reg);
 159                 if (reg && reg != ~0)
 160                         break;
 161                 msleep(1);
 162         }
 163
 164         if (i == REGISTER_BUSY_COUNT) {
 165                 ERROR(rt2x00dev, "Unstable hardware.\n");
 166                 return -EBUSY;
 167         }
 168
 169         /*
 170          * Write firmware to device.
 171          */
 172         rt2800_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE,
 173                                    data + offset, length);
 174
 175         rt2800_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0);
 176         rt2800_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0);
 177
 178         /*
 179          * Send firmware request to device to load firmware,
 180          * we need to specify a long timeout time.
 181          */
 182         status = rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE,
 183                                              0, USB_MODE_FIRMWARE,
 184                                              REGISTER_TIMEOUT_FIRMWARE);
 185         if (status < 0) {
 186                 ERROR(rt2x00dev, "Failed to write Firmware to device.\n");
 187                 return status;
 188         }
 189
 190         msleep(10);
 191         rt2800_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0);
 192
 193         /*
 194          * Send signal to firmware during boot time.
 195          */
 196         rt2800_mcu_request(rt2x00dev, MCU_BOOT_SIGNAL, 0, 0, 0);
 197
 198         if (rt2x00_rt(rt2x00dev, RT3070) ||
 199             rt2x00_rt(rt2x00dev, RT3071) ||
 200             rt2x00_rt(rt2x00dev, RT3572)) {
 201                 udelay(200);
 202                 rt2800_mcu_request(rt2x00dev, MCU_CURRENT, 0, 0, 0);
 203                 udelay(10);
 204         }
 205
 206         /*
 207          * Wait for device to stabilize.
 208          */
 209         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
 210                 rt2800_register_read(rt2x00dev, PBF_SYS_CTRL, &reg);
 211                 if (rt2x00_get_field32(reg, PBF_SYS_CTRL_READY))
 212                         break;
 213                 msleep(1);
 214         }
 215
 216         if (i == REGISTER_BUSY_COUNT) {
 217                 ERROR(rt2x00dev, "PBF system register not ready.\n");
 218                 return -EBUSY;
 219         }
 220
 221         /*
 222          * Initialize firmware.
 223          */
 224         rt2800_register_write(rt2x00dev, H2M_BBP_AGENT, 0);
 225         rt2800_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0);
 226         msleep(1);
 227
 228         return 0;
 229 }
 230
 231 /*
 232  * Device state switch handlers.
 233  */
 234 static void rt2800usb_toggle_rx(struct rt2x00_dev *rt2x00dev,
 235                                 enum dev_state state)
 236 {
 237         u32 reg;
 238
 239         rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
 240         rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX,
 241                            (state == STATE_RADIO_RX_ON) ||
 242                            (state == STATE_RADIO_RX_ON_LINK));
 243         rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
 244 }
 245
 246 static int rt2800usb_init_registers(struct rt2x00_dev *rt2x00dev)
 247 {
 248         u32 reg;
 249         int i;
 250
 251         /*
 252          * Wait until BBP and RF are ready.
 253          */
 254         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
 255                 rt2800_register_read(rt2x00dev, MAC_CSR0, &reg);
 256                 if (reg && reg != ~0)
 257                         break;
 258                 msleep(1);
 259         }
 260
 261         if (i == REGISTER_BUSY_COUNT) {
 262                 ERROR(rt2x00dev, "Unstable hardware.\n");
 263                 return -EBUSY;
 264         }
 265
 266         rt2800_register_read(rt2x00dev, PBF_SYS_CTRL, &reg);
 267         rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, reg & ~0x00002000);
 268
 269         rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
 270         rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_CSR, 1);
 271         rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_BBP, 1);
 272         rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
 273
 274         rt2800_register_write(rt2x00dev, USB_DMA_CFG, 0x00000000);
 275
 276         rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, 0,
 277                                     USB_MODE_RESET, REGISTER_TIMEOUT);
 278
 279         rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000);
 280
 281         return 0;
 282 }
 283
 284 static int rt2800usb_enable_radio(struct rt2x00_dev *rt2x00dev)
 285 {
 286         u32 reg;
 287         u16 word;
 288
 289         /*
 290          * Initialize all registers.
 291          */
 292         if (unlikely(rt2800_wait_wpdma_ready(rt2x00dev) ||
 293                      rt2800_init_registers(rt2x00dev) ||
 294                      rt2800_init_bbp(rt2x00dev) ||
 295                      rt2800_init_rfcsr(rt2x00dev)))
 296                 return -EIO;
 297
 298         rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
 299         rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_TX, 1);
 300         rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
 301
 302         udelay(50);
 303
 304         rt2800_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg);
 305         rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1);
 306         rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 1);
 307         rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 1);
 308         rt2800_register_write(rt2x00dev, WPDMA_GLO_CFG, reg);
 309
 310
 311         rt2800_register_read(rt2x00dev, USB_DMA_CFG, &reg);
 312         rt2x00_set_field32(&reg, USB_DMA_CFG_PHY_CLEAR, 0);
 313         rt2x00_set_field32(&reg, USB_DMA_CFG_RX_BULK_AGG_EN, 0);
 314         rt2x00_set_field32(&reg, USB_DMA_CFG_RX_BULK_AGG_TIMEOUT, 128);
 315         /*
 316          * Total room for RX frames in kilobytes, PBF might still exceed
 317          * this limit so reduce the number to prevent errors.
 318          */
 319         rt2x00_set_field32(&reg, USB_DMA_CFG_RX_BULK_AGG_LIMIT,
 320                            ((RX_ENTRIES * DATA_FRAME_SIZE) / 1024) - 3);
 321         rt2x00_set_field32(&reg, USB_DMA_CFG_RX_BULK_EN, 1);
 322         rt2x00_set_field32(&reg, USB_DMA_CFG_TX_BULK_EN, 1);
 323         rt2800_register_write(rt2x00dev, USB_DMA_CFG, reg);
 324
 325         rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
 326         rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_TX, 1);
 327         rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 1);
 328         rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
 329
 330         /*
 331          * Initialize LED control
 332          */
 333         rt2x00_eeprom_read(rt2x00dev, EEPROM_LED1, &word);
 334         rt2800_mcu_request(rt2x00dev, MCU_LED_1, 0xff,
 335                               word & 0xff, (word >> 8) & 0xff);
 336
 337         rt2x00_eeprom_read(rt2x00dev, EEPROM_LED2, &word);
 338         rt2800_mcu_request(rt2x00dev, MCU_LED_2, 0xff,
 339                               word & 0xff, (word >> 8) & 0xff);
 340
 341         rt2x00_eeprom_read(rt2x00dev, EEPROM_LED3, &word);
 342         rt2800_mcu_request(rt2x00dev, MCU_LED_3, 0xff,
 343                               word & 0xff, (word >> 8) & 0xff);
 344
 345         return 0;
 346 }
 347
 348 static void rt2800usb_disable_radio(struct rt2x00_dev *rt2x00dev)
 349 {
 350         u32 reg;
 351
 352         rt2800_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg);
 353         rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0);
 354         rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0);
 355         rt2800_register_write(rt2x00dev, WPDMA_GLO_CFG, reg);
 356
 357         rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, 0);
 358         rt2800_register_write(rt2x00dev, PWR_PIN_CFG, 0);
 359         rt2800_register_write(rt2x00dev, TX_PIN_CFG, 0);
 360
 361         /* Wait for DMA, ignore error */
 362         rt2800_wait_wpdma_ready(rt2x00dev);
 363
 364         rt2x00usb_disable_radio(rt2x00dev);
 365 }
 366
 367 static int rt2800usb_set_state(struct rt2x00_dev *rt2x00dev,
 368                                enum dev_state state)
 369 {
 370         if (state == STATE_AWAKE)
 371                 rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 0);
 372         else
 373                 rt2800_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0, 2);
 374
 375         return 0;
 376 }
 377
 378 static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev,
 379                                       enum dev_state state)
 380 {
 381         int retval = 0;
 382
 383         switch (state) {
 384         case STATE_RADIO_ON:
 385                 /*
 386                  * Before the radio can be enabled, the device first has
 387                  * to be woken up. After that it needs a bit of time
 388                  * to be fully awake and then the radio can be enabled.
 389                  */
 390                 rt2800usb_set_state(rt2x00dev, STATE_AWAKE);
 391                 msleep(1);
 392                 retval = rt2800usb_enable_radio(rt2x00dev);
 393                 break;
 394         case STATE_RADIO_OFF:
 395                 /*
 396                  * After the radio has been disabled, the device should
 397                  * be put to sleep for powersaving.
 398                  */
 399                 rt2800usb_disable_radio(rt2x00dev);
 400                 rt2800usb_set_state(rt2x00dev, STATE_SLEEP);
 401                 break;
 402         case STATE_RADIO_RX_ON:
 403         case STATE_RADIO_RX_ON_LINK:
 404         case STATE_RADIO_RX_OFF:
 405         case STATE_RADIO_RX_OFF_LINK:
 406                 rt2800usb_toggle_rx(rt2x00dev, state);
 407                 break;
 408         case STATE_RADIO_IRQ_ON:
 409         case STATE_RADIO_IRQ_OFF:
 410                 /* No support, but no error either */
 411                 break;
 412         case STATE_DEEP_SLEEP:
 413         case STATE_SLEEP:
 414         case STATE_STANDBY:
 415         case STATE_AWAKE:
 416                 retval = rt2800usb_set_state(rt2x00dev, state);
 417                 break;
 418         default:
 419                 retval = -ENOTSUPP;
 420                 break;
 421         }
 422
 423         if (unlikely(retval))
 424                 ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
 425                       state, retval);
 426
 427         return retval;
 428 }
 429
 430 /*
 431  * TX descriptor initialization
 432  */
 433 static void rt2800usb_write_tx_data(struct queue_entry* entry,
 434                                     struct txentry_desc *txdesc)
 435 {
 436         __le32 *txwi = (__le32 *) (entry->skb->data + TXINFO_DESC_SIZE);
 437
 438         rt2800_write_txwi(txwi, txdesc);
 439 }
 440
 441
 442 static void rt2800usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
 443                                     struct sk_buff *skb,
 444                                     struct txentry_desc *txdesc)
 445 {
 446         struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
 447         __le32 *txi = (__le32 *) skb->data;
 448         u32 word;
 449
 450         /*
 451          * Initialize TXINFO descriptor
 452          */
 453         rt2x00_desc_read(txi, 0, &word);
 454         rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN,
 455                            skb->len - TXINFO_DESC_SIZE);
 456         rt2x00_set_field32(&word, TXINFO_W0_WIV,
 457                            !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc->flags));
 458         rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2);
 459         rt2x00_set_field32(&word, TXINFO_W0_SW_USE_LAST_ROUND, 0);
 460         rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_NEXT_VALID, 0);
 461         rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_BURST,
 462                            test_bit(ENTRY_TXD_BURST, &txdesc->flags));
 463         rt2x00_desc_write(txi, 0, word);
 464
 465         /*
 466          * Register descriptor details in skb frame descriptor.
 467          */
 468         skbdesc->flags |= SKBDESC_DESC_IN_SKB;
 469         skbdesc->desc = txi;
 470         skbdesc->desc_len = TXINFO_DESC_SIZE + TXWI_DESC_SIZE;
 471 }
 472
 473 /*
 474  * TX data initialization
 475  */
 476 static int rt2800usb_get_tx_data_len(struct queue_entry *entry)
 477 {
 478         int length;
 479
 480         /*
 481          * The length _must_ include 4 bytes padding,
 482          * it should always be multiple of 4,
 483          * but it must _not_ be a multiple of the USB packet size.
 484          */
 485         length = roundup(entry->skb->len + 4, 4);
 486         length += (4 * !(length % entry->queue->usb_maxpacket));
 487
 488         return length;
 489 }
 490
 491 /*
 492  * RX control handlers
 493  */
 494 static void rt2800usb_fill_rxdone(struct queue_entry *entry,
 495                                   struct rxdone_entry_desc *rxdesc)
 496 {
 497         struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
 498         __le32 *rxi = (__le32 *)entry->skb->data;
 499         __le32 *rxd;
 500         u32 word;
 501         int rx_pkt_len;
 502
 503         /*
 504          * Copy descriptor to the skbdesc->desc buffer, making it safe from
 505          * moving of frame data in rt2x00usb.
 506          */
 507         memcpy(skbdesc->desc, rxi, skbdesc->desc_len);
 508
 509         /*
 510          * RX frame format is :
 511          * | RXINFO | RXWI | header | L2 pad | payload | pad | RXD | USB pad |
 512          *          |<------------ rx_pkt_len -------------->|
 513          */
 514         rt2x00_desc_read(rxi, 0, &word);
 515         rx_pkt_len = rt2x00_get_field32(word, RXINFO_W0_USB_DMA_RX_PKT_LEN);
 516
 517         /*
 518          * Remove the RXINFO structure from the sbk.
 519          */
 520         skb_pull(entry->skb, RXINFO_DESC_SIZE);
 521
 522         /*
 523          * FIXME: we need to check for rx_pkt_len validity
 524          */
 525         rxd = (__le32 *)(entry->skb->data + rx_pkt_len);
 526
 527         /*
 528          * It is now safe to read the descriptor on all architectures.
 529          */
 530         rt2x00_desc_read(rxd, 0, &word);
 531
 532         if (rt2x00_get_field32(word, RXD_W0_CRC_ERROR))
 533                 rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC;
 534
 535         rxdesc->cipher_status = rt2x00_get_field32(word, RXD_W0_CIPHER_ERROR);
 536
 537         if (rt2x00_get_field32(word, RXD_W0_DECRYPTED)) {
 538                 /*
 539                  * Hardware has stripped IV/EIV data from 802.11 frame during
 540                  * decryption. Unfortunately the descriptor doesn't contain
 541                  * any fields with the EIV/IV data either, so they can't
 542                  * be restored by rt2x00lib.
 543                  */
 544                 rxdesc->flags |= RX_FLAG_IV_STRIPPED;
 545
 546                 if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS)
 547                         rxdesc->flags |= RX_FLAG_DECRYPTED;
 548                 else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC)
 549                         rxdesc->flags |= RX_FLAG_MMIC_ERROR;
 550         }
 551
 552         if (rt2x00_get_field32(word, RXD_W0_MY_BSS))
 553                 rxdesc->dev_flags |= RXDONE_MY_BSS;
 554
 555         if (rt2x00_get_field32(word, RXD_W0_L2PAD))
 556                 rxdesc->dev_flags |= RXDONE_L2PAD;
 557
 558         /*
 559          * Remove RXD descriptor from end of buffer.
 560          */
 561         skb_trim(entry->skb, rx_pkt_len);
 562
 563         /*
 564          * Process the RXWI structure.
 565          */
 566         rt2800_process_rxwi(entry->skb, rxdesc);
 567 }
 568
 569 /*
 570  * Device probe functions.
 571  */
 572 static int rt2800usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
 573 {
 574         if (rt2800_efuse_detect(rt2x00dev))
 575                 rt2800_read_eeprom_efuse(rt2x00dev);
 576         else
 577                 rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom,
 578                                       EEPROM_SIZE);
 579
 580         return rt2800_validate_eeprom(rt2x00dev);
 581 }
 582
 583 static const struct rt2800_ops rt2800usb_rt2800_ops = {
 584         .register_read          = rt2x00usb_register_read,
 585         .register_read_lock     = rt2x00usb_register_read_lock,
 586         .register_write         = rt2x00usb_register_write,
 587         .register_write_lock    = rt2x00usb_register_write_lock,
 588
 589         .register_multiread     = rt2x00usb_register_multiread,
 590         .register_multiwrite    = rt2x00usb_register_multiwrite,
 591
 592         .regbusy_read           = rt2x00usb_regbusy_read,
 593
 594         .drv_init_registers     = rt2800usb_init_registers,
 595 };
 596
 597 static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev)
 598 {
 599         int retval;
 600
 601         rt2x00dev->priv = (void *)&rt2800usb_rt2800_ops;
 602
 603         /*
 604          * Allocate eeprom data.
 605          */
 606         retval = rt2800usb_validate_eeprom(rt2x00dev);
 607         if (retval)
 608                 return retval;
 609
 610         retval = rt2800_init_eeprom(rt2x00dev);
 611         if (retval)
 612                 return retval;
 613
 614         /*
 615          * Initialize hw specifications.
 616          */
 617         retval = rt2800_probe_hw_mode(rt2x00dev);
 618         if (retval)
 619                 return retval;
 620
 621         /*
 622          * This device has multiple filters for control frames
 623          * and has a separate filter for PS Poll frames.
 624          */
 625         __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags);
 626         __set_bit(DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, &rt2x00dev->flags);
 627
 628         /*
 629          * This device requires firmware.
 630          */
 631         __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags);
 632         __set_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags);
 633         if (!modparam_nohwcrypt)
 634                 __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
 635
 636         /*
 637          * Set the rssi offset.
 638          */
 639         rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET;
 640
 641         return 0;
 642 }
 643
 644 static const struct rt2x00lib_ops rt2800usb_rt2x00_ops = {
 645         .probe_hw               = rt2800usb_probe_hw,
 646         .get_firmware_name      = rt2800usb_get_firmware_name,
 647         .check_firmware         = rt2800usb_check_firmware,
 648         .load_firmware          = rt2800usb_load_firmware,
 649         .initialize             = rt2x00usb_initialize,
 650         .uninitialize           = rt2x00usb_uninitialize,
 651         .clear_entry            = rt2x00usb_clear_entry,
 652         .set_device_state       = rt2800usb_set_device_state,
 653         .rfkill_poll            = rt2800_rfkill_poll,
 654         .link_stats             = rt2800_link_stats,
 655         .reset_tuner            = rt2800_reset_tuner,
 656         .link_tuner             = rt2800_link_tuner,
 657         .write_tx_desc          = rt2800usb_write_tx_desc,
 658         .write_tx_data          = rt2800usb_write_tx_data,
 659         .write_beacon           = rt2800_write_beacon,
 660         .get_tx_data_len        = rt2800usb_get_tx_data_len,
 661         .kick_tx_queue          = rt2x00usb_kick_tx_queue,
 662         .kill_tx_queue          = rt2x00usb_kill_tx_queue,
 663         .fill_rxdone            = rt2800usb_fill_rxdone,
 664         .config_shared_key      = rt2800_config_shared_key,
 665         .config_pairwise_key    = rt2800_config_pairwise_key,
 666         .config_filter          = rt2800_config_filter,
 667         .config_intf            = rt2800_config_intf,
 668         .config_erp             = rt2800_config_erp,
 669         .config_ant             = rt2800_config_ant,
 670         .config                 = rt2800_config,
 671 };
 672
 673 static const struct data_queue_desc rt2800usb_queue_rx = {
 674         .entry_num              = RX_ENTRIES,
 675         .data_size              = AGGREGATION_SIZE,
 676         .desc_size              = RXINFO_DESC_SIZE + RXWI_DESC_SIZE,
 677         .priv_size              = sizeof(struct queue_entry_priv_usb),
 678 };
 679
 680 static const struct data_queue_desc rt2800usb_queue_tx = {
 681         .entry_num              = TX_ENTRIES,
 682         .data_size              = AGGREGATION_SIZE,
 683         .desc_size              = TXINFO_DESC_SIZE + TXWI_DESC_SIZE,
 684         .priv_size              = sizeof(struct queue_entry_priv_usb),
 685 };
 686
 687 static const struct data_queue_desc rt2800usb_queue_bcn = {
 688         .entry_num              = 8 * BEACON_ENTRIES,
 689         .data_size              = MGMT_FRAME_SIZE,
 690         .desc_size              = TXINFO_DESC_SIZE + TXWI_DESC_SIZE,
 691         .priv_size              = sizeof(struct queue_entry_priv_usb),
 692 };
 693
 694 static const struct rt2x00_ops rt2800usb_ops = {
 695         .name                   = KBUILD_MODNAME,
 696         .max_sta_intf           = 1,
 697         .max_ap_intf            = 8,
 698         .eeprom_size            = EEPROM_SIZE,
 699         .rf_size                = RF_SIZE,
 700         .tx_queues              = NUM_TX_QUEUES,
 701         .extra_tx_headroom      = TXINFO_DESC_SIZE + TXWI_DESC_SIZE,
 702         .rx                     = &rt2800usb_queue_rx,
 703         .tx                     = &rt2800usb_queue_tx,
 704         .bcn                    = &rt2800usb_queue_bcn,
 705         .lib                    = &rt2800usb_rt2x00_ops,
 706         .hw                     = &rt2800_mac80211_ops,
 707 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
 708         .debugfs                = &rt2800_rt2x00debug,
 709 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
 710 };
 711
 712 /*
 713  * rt2800usb module information.
 714  */
 715 static struct usb_device_id rt2800usb_device_table[] = {
 716         /* Abocom */
 717         { USB_DEVICE(0x07b8, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) },
 718         { USB_DEVICE(0x07b8, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) },
 719         { USB_DEVICE(0x1482, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) },
 720         /* Allwin */
 721         { USB_DEVICE(0x8516, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) },
 722         { USB_DEVICE(0x8516, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) },
 723         { USB_DEVICE(0x8516, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) },
 724         /* Amit */
 725         { USB_DEVICE(0x15c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) },
 726         /* Askey */
 727         { USB_DEVICE(0x1690, 0x0740), USB_DEVICE_DATA(&rt2800usb_ops) },
 728         /* ASUS */
 729         { USB_DEVICE(0x0b05, 0x1731), USB_DEVICE_DATA(&rt2800usb_ops) },
 730         { USB_DEVICE(0x0b05, 0x1732), USB_DEVICE_DATA(&rt2800usb_ops) },
 731         { USB_DEVICE(0x0b05, 0x1742), USB_DEVICE_DATA(&rt2800usb_ops) },
 732         /* AzureWave */
 733         { USB_DEVICE(0x13d3, 0x3247), USB_DEVICE_DATA(&rt2800usb_ops) },
 734         /* Belkin */
 735         { USB_DEVICE(0x050d, 0x8053), USB_DEVICE_DATA(&rt2800usb_ops) },
 736         { USB_DEVICE(0x050d, 0x805c), USB_DEVICE_DATA(&rt2800usb_ops) },
 737         { USB_DEVICE(0x050d, 0x815c), USB_DEVICE_DATA(&rt2800usb_ops) },
 738         /* Buffalo */
 739         { USB_DEVICE(0x0411, 0x00e8), USB_DEVICE_DATA(&rt2800usb_ops) },
 740         /* Conceptronic */
 741         { USB_DEVICE(0x14b2, 0x3c06), USB_DEVICE_DATA(&rt2800usb_ops) },
 742         { USB_DEVICE(0x14b2, 0x3c07), USB_DEVICE_DATA(&rt2800usb_ops) },
 743         { USB_DEVICE(0x14b2, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) },
 744         { USB_DEVICE(0x14b2, 0x3c23), USB_DEVICE_DATA(&rt2800usb_ops) },
 745         { USB_DEVICE(0x14b2, 0x3c25), USB_DEVICE_DATA(&rt2800usb_ops) },
 746         { USB_DEVICE(0x14b2, 0x3c27), USB_DEVICE_DATA(&rt2800usb_ops) },
 747         { USB_DEVICE(0x14b2, 0x3c28), USB_DEVICE_DATA(&rt2800usb_ops) },
 748         /* Corega */
 749         { USB_DEVICE(0x07aa, 0x002f), USB_DEVICE_DATA(&rt2800usb_ops) },
 750         { USB_DEVICE(0x07aa, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) },
 751         { USB_DEVICE(0x07aa, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) },
 752         /* D-Link */
 753         { USB_DEVICE(0x07d1, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) },
 754         { USB_DEVICE(0x07d1, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) },
 755         /* Edimax */
 756         { USB_DEVICE(0x7392, 0x7717), USB_DEVICE_DATA(&rt2800usb_ops) },
 757         { USB_DEVICE(0x7392, 0x7718), USB_DEVICE_DATA(&rt2800usb_ops) },
 758         /* EnGenius */
 759         { USB_DEVICE(0x1740, 0x9701), USB_DEVICE_DATA(&rt2800usb_ops) },
 760         { USB_DEVICE(0x1740, 0x9702), USB_DEVICE_DATA(&rt2800usb_ops) },
 761         /* Gigabyte */
 762         { USB_DEVICE(0x1044, 0x800b), USB_DEVICE_DATA(&rt2800usb_ops) },
 763         /* Hawking */
 764         { USB_DEVICE(0x0e66, 0x0001), USB_DEVICE_DATA(&rt2800usb_ops) },
 765         { USB_DEVICE(0x0e66, 0x0003), USB_DEVICE_DATA(&rt2800usb_ops) },
 766         { USB_DEVICE(0x0e66, 0x0009), USB_DEVICE_DATA(&rt2800usb_ops) },
 767         { USB_DEVICE(0x0e66, 0x000b), USB_DEVICE_DATA(&rt2800usb_ops) },
 768         { USB_DEVICE(0x0e66, 0x0013), USB_DEVICE_DATA(&rt2800usb_ops) },
 769         { USB_DEVICE(0x0e66, 0x0017), USB_DEVICE_DATA(&rt2800usb_ops) },
 770         { USB_DEVICE(0x0e66, 0x0018), USB_DEVICE_DATA(&rt2800usb_ops) },
 771         /* Linksys */
 772         { USB_DEVICE(0x1737, 0x0070), USB_DEVICE_DATA(&rt2800usb_ops) },
 773         { USB_DEVICE(0x1737, 0x0071), USB_DEVICE_DATA(&rt2800usb_ops) },
 774         /* Logitec */
 775         { USB_DEVICE(0x0789, 0x0162), USB_DEVICE_DATA(&rt2800usb_ops) },
 776         { USB_DEVICE(0x0789, 0x0163), USB_DEVICE_DATA(&rt2800usb_ops) },
 777         { USB_DEVICE(0x0789, 0x0164), USB_DEVICE_DATA(&rt2800usb_ops) },
 778         /* Motorola */
 779         { USB_DEVICE(0x100d, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) },
 780         /* MSI */
 781         { USB_DEVICE(0x0db0, 0x6899), USB_DEVICE_DATA(&rt2800usb_ops) },
 782         /* Philips */
 783         { USB_DEVICE(0x0471, 0x200f), USB_DEVICE_DATA(&rt2800usb_ops) },
 784         /* Planex */
 785         { USB_DEVICE(0x2019, 0xed06), USB_DEVICE_DATA(&rt2800usb_ops) },
 786         /* Ralink */
 787         { USB_DEVICE(0x148f, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) },
 788         { USB_DEVICE(0x148f, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) },
 789         /* Samsung */
 790         { USB_DEVICE(0x04e8, 0x2018), USB_DEVICE_DATA(&rt2800usb_ops) },
 791         /* Siemens */
 792         { USB_DEVICE(0x129b, 0x1828), USB_DEVICE_DATA(&rt2800usb_ops) },
 793         /* Sitecom */
 794         { USB_DEVICE(0x0df6, 0x0017), USB_DEVICE_DATA(&rt2800usb_ops) },
 795         { USB_DEVICE(0x0df6, 0x002b), USB_DEVICE_DATA(&rt2800usb_ops) },
 796         { USB_DEVICE(0x0df6, 0x002c), USB_DEVICE_DATA(&rt2800usb_ops) },
 797         { USB_DEVICE(0x0df6, 0x002d), USB_DEVICE_DATA(&rt2800usb_ops) },
 798         { USB_DEVICE(0x0df6, 0x0039), USB_DEVICE_DATA(&rt2800usb_ops) },
 799         { USB_DEVICE(0x0df6, 0x003b), USB_DEVICE_DATA(&rt2800usb_ops) },
 800         { USB_DEVICE(0x0df6, 0x003d), USB_DEVICE_DATA(&rt2800usb_ops) },
 801         { USB_DEVICE(0x0df6, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) },
 802         /* SMC */
 803         { USB_DEVICE(0x083a, 0x6618), USB_DEVICE_DATA(&rt2800usb_ops) },
 804         { USB_DEVICE(0x083a, 0x7512), USB_DEVICE_DATA(&rt2800usb_ops) },
 805         { USB_DEVICE(0x083a, 0x7522), USB_DEVICE_DATA(&rt2800usb_ops) },
 806         { USB_DEVICE(0x083a, 0x8522), USB_DEVICE_DATA(&rt2800usb_ops) },
 807         { USB_DEVICE(0x083a, 0xa618), USB_DEVICE_DATA(&rt2800usb_ops) },
 808         { USB_DEVICE(0x083a, 0xb522), USB_DEVICE_DATA(&rt2800usb_ops) },
 809         /* Sparklan */
 810         { USB_DEVICE(0x15a9, 0x0006), USB_DEVICE_DATA(&rt2800usb_ops) },
 811         /* Sweex */
 812         { USB_DEVICE(0x177f, 0x0302), USB_DEVICE_DATA(&rt2800usb_ops) },
 813         /* U-Media*/
 814         { USB_DEVICE(0x157e, 0x300e), USB_DEVICE_DATA(&rt2800usb_ops) },
 815         /* ZCOM */
 816         { USB_DEVICE(0x0cde, 0x0022), USB_DEVICE_DATA(&rt2800usb_ops) },
 817         { USB_DEVICE(0x0cde, 0x0025), USB_DEVICE_DATA(&rt2800usb_ops) },
 818         /* Zinwell */
 819         { USB_DEVICE(0x5a57, 0x0280), USB_DEVICE_DATA(&rt2800usb_ops) },
 820         { USB_DEVICE(0x5a57, 0x0282), USB_DEVICE_DATA(&rt2800usb_ops) },
 821         /* Zyxel */
 822         { USB_DEVICE(0x0586, 0x3416), USB_DEVICE_DATA(&rt2800usb_ops) },
 823 #ifdef CONFIG_RT2800USB_RT30XX
 824         /* Abocom */
 825         { USB_DEVICE(0x07b8, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) },
 826         { USB_DEVICE(0x07b8, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) },
 827         { USB_DEVICE(0x07b8, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) },
 828         /* AirTies */
 829         { USB_DEVICE(0x1eda, 0x2310), USB_DEVICE_DATA(&rt2800usb_ops) },
 830         /* Allwin */
 831         { USB_DEVICE(0x8516, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) },
 832         { USB_DEVICE(0x8516, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) },
 833         { USB_DEVICE(0x8516, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) },
 834         /* ASUS */
 835         { USB_DEVICE(0x0b05, 0x1784), USB_DEVICE_DATA(&rt2800usb_ops) },
 836         /* AzureWave */
 837         { USB_DEVICE(0x13d3, 0x3273), USB_DEVICE_DATA(&rt2800usb_ops) },
 838         { USB_DEVICE(0x13d3, 0x3305), USB_DEVICE_DATA(&rt2800usb_ops) },
 839         { USB_DEVICE(0x13d3, 0x3307), USB_DEVICE_DATA(&rt2800usb_ops) },
 840         { USB_DEVICE(0x13d3, 0x3321), USB_DEVICE_DATA(&rt2800usb_ops) },
 841         /* Conceptronic */
 842         { USB_DEVICE(0x14b2, 0x3c12), USB_DEVICE_DATA(&rt2800usb_ops) },
 843         /* Corega */
 844         { USB_DEVICE(0x18c5, 0x0012), USB_DEVICE_DATA(&rt2800usb_ops) },
 845         /* D-Link */
 846         { USB_DEVICE(0x07d1, 0x3c0a), USB_DEVICE_DATA(&rt2800usb_ops) },
 847         { USB_DEVICE(0x07d1, 0x3c0d), USB_DEVICE_DATA(&rt2800usb_ops) },
 848         { USB_DEVICE(0x07d1, 0x3c0e), USB_DEVICE_DATA(&rt2800usb_ops) },
 849         { USB_DEVICE(0x07d1, 0x3c0f), USB_DEVICE_DATA(&rt2800usb_ops) },
 850         { USB_DEVICE(0x07d1, 0x3c16), USB_DEVICE_DATA(&rt2800usb_ops) },
 851         /* Draytek */
 852         { USB_DEVICE(0x07fa, 0x7712), USB_DEVICE_DATA(&rt2800usb_ops) },
 853         /* Edimax */
 854         { USB_DEVICE(0x7392, 0x7711), USB_DEVICE_DATA(&rt2800usb_ops) },
 855         /* Encore */
 856         { USB_DEVICE(0x203d, 0x1480), USB_DEVICE_DATA(&rt2800usb_ops) },
 857         { USB_DEVICE(0x203d, 0x14a9), USB_DEVICE_DATA(&rt2800usb_ops) },
 858         /* EnGenius */
 859         { USB_DEVICE(0x1740, 0x9703), USB_DEVICE_DATA(&rt2800usb_ops) },
 860         { USB_DEVICE(0x1740, 0x9705), USB_DEVICE_DATA(&rt2800usb_ops) },
 861         { USB_DEVICE(0x1740, 0x9706), USB_DEVICE_DATA(&rt2800usb_ops) },
 862         { USB_DEVICE(0x1740, 0x9707), USB_DEVICE_DATA(&rt2800usb_ops) },
 863         { USB_DEVICE(0x1740, 0x9708), USB_DEVICE_DATA(&rt2800usb_ops) },
 864         { USB_DEVICE(0x1740, 0x9709), USB_DEVICE_DATA(&rt2800usb_ops) },
 865         /* Gigabyte */
 866         { USB_DEVICE(0x1044, 0x800d), USB_DEVICE_DATA(&rt2800usb_ops) },
 867         /* I-O DATA */
 868         { USB_DEVICE(0x04bb, 0x0945), USB_DEVICE_DATA(&rt2800usb_ops) },
 869         { USB_DEVICE(0x04bb, 0x0947), USB_DEVICE_DATA(&rt2800usb_ops) },
 870         { USB_DEVICE(0x04bb, 0x0948), USB_DEVICE_DATA(&rt2800usb_ops) },
 871         /* Logitec */
 872         { USB_DEVICE(0x0789, 0x0166), USB_DEVICE_DATA(&rt2800usb_ops) },
 873         /* MSI */
 874         { USB_DEVICE(0x0db0, 0x3820), USB_DEVICE_DATA(&rt2800usb_ops) },
 875         { USB_DEVICE(0x0db0, 0x3821), USB_DEVICE_DATA(&rt2800usb_ops) },
 876         { USB_DEVICE(0x0db0, 0x3822), USB_DEVICE_DATA(&rt2800usb_ops) },
 877         { USB_DEVICE(0x0db0, 0x3870), USB_DEVICE_DATA(&rt2800usb_ops) },
 878         { USB_DEVICE(0x0db0, 0x3871), USB_DEVICE_DATA(&rt2800usb_ops) },
 879         { USB_DEVICE(0x0db0, 0x821a), USB_DEVICE_DATA(&rt2800usb_ops) },
 880         { USB_DEVICE(0x0db0, 0x822a), USB_DEVICE_DATA(&rt2800usb_ops) },
 881         { USB_DEVICE(0x0db0, 0x822b), USB_DEVICE_DATA(&rt2800usb_ops) },
 882         { USB_DEVICE(0x0db0, 0x822c), USB_DEVICE_DATA(&rt2800usb_ops) },
 883         { USB_DEVICE(0x0db0, 0x870a), USB_DEVICE_DATA(&rt2800usb_ops) },
 884         { USB_DEVICE(0x0db0, 0x871a), USB_DEVICE_DATA(&rt2800usb_ops) },
 885         { USB_DEVICE(0x0db0, 0x871b), USB_DEVICE_DATA(&rt2800usb_ops) },
 886         { USB_DEVICE(0x0db0, 0x871c), USB_DEVICE_DATA(&rt2800usb_ops) },
 887         { USB_DEVICE(0x0db0, 0x899a), USB_DEVICE_DATA(&rt2800usb_ops) },
 888         /* Para */
 889         { USB_DEVICE(0x20b8, 0x8888), USB_DEVICE_DATA(&rt2800usb_ops) },
 890         /* Pegatron */
 891         { USB_DEVICE(0x1d4d, 0x000c), USB_DEVICE_DATA(&rt2800usb_ops) },
 892         { USB_DEVICE(0x1d4d, 0x000e), USB_DEVICE_DATA(&rt2800usb_ops) },
 893         /* Planex */
 894         { USB_DEVICE(0x2019, 0xab25), USB_DEVICE_DATA(&rt2800usb_ops) },
 895         /* Quanta */
 896         { USB_DEVICE(0x1a32, 0x0304), USB_DEVICE_DATA(&rt2800usb_ops) },
 897         /* Ralink */
 898         { USB_DEVICE(0x148f, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) },
 899         { USB_DEVICE(0x148f, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) },
 900         { USB_DEVICE(0x148f, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) },
 901         { USB_DEVICE(0x148f, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) },
 902         /* Sitecom */
 903         { USB_DEVICE(0x0df6, 0x003e), USB_DEVICE_DATA(&rt2800usb_ops) },
 904         { USB_DEVICE(0x0df6, 0x0040), USB_DEVICE_DATA(&rt2800usb_ops) },
 905         { USB_DEVICE(0x0df6, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) },
 906         { USB_DEVICE(0x0df6, 0x0047), USB_DEVICE_DATA(&rt2800usb_ops) },
 907         { USB_DEVICE(0x0df6, 0x0048), USB_DEVICE_DATA(&rt2800usb_ops) },
 908         /* SMC */
 909         { USB_DEVICE(0x083a, 0x7511), USB_DEVICE_DATA(&rt2800usb_ops) },
 910         { USB_DEVICE(0x083a, 0xa701), USB_DEVICE_DATA(&rt2800usb_ops) },
 911         { USB_DEVICE(0x083a, 0xa702), USB_DEVICE_DATA(&rt2800usb_ops) },
 912         { USB_DEVICE(0x083a, 0xa703), USB_DEVICE_DATA(&rt2800usb_ops) },
 913         /* Zinwell */
 914         { USB_DEVICE(0x5a57, 0x0283), USB_DEVICE_DATA(&rt2800usb_ops) },
 915         { USB_DEVICE(0x5a57, 0x5257), USB_DEVICE_DATA(&rt2800usb_ops) },
 916 #endif
 917 #ifdef CONFIG_RT2800USB_RT35XX
 918         /* Allwin */
 919         { USB_DEVICE(0x8516, 0x3572), USB_DEVICE_DATA(&rt2800usb_ops) },
 920         /* Askey */
 921         { USB_DEVICE(0x1690, 0x0744), USB_DEVICE_DATA(&rt2800usb_ops) },
 922         /* Cisco */
 923         { USB_DEVICE(0x167b, 0x4001), USB_DEVICE_DATA(&rt2800usb_ops) },
 924         /* EnGenius */
 925         { USB_DEVICE(0x1740, 0x9801), USB_DEVICE_DATA(&rt2800usb_ops) },
 926         /* I-O DATA */
 927         { USB_DEVICE(0x04bb, 0x0944), USB_DEVICE_DATA(&rt2800usb_ops) },
 928         /* Ralink */
 929         { USB_DEVICE(0x148f, 0x3370), USB_DEVICE_DATA(&rt2800usb_ops) },
 930         { USB_DEVICE(0x148f, 0x3572), USB_DEVICE_DATA(&rt2800usb_ops) },
 931         { USB_DEVICE(0x148f, 0x8070), USB_DEVICE_DATA(&rt2800usb_ops) },
 932         /* Sitecom */
 933         { USB_DEVICE(0x0df6, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) },
 934         { USB_DEVICE(0x0df6, 0x0050), USB_DEVICE_DATA(&rt2800usb_ops) },
 935         /* Zinwell */
 936         { USB_DEVICE(0x5a57, 0x0284), USB_DEVICE_DATA(&rt2800usb_ops) },
 937 #endif
 938 #ifdef CONFIG_RT2800USB_UNKNOWN
 939         /*
 940          * Unclear what kind of devices these are (they aren't supported by the
 941          * vendor linux driver).
 942          */
 943         /* Amigo */
 944         { USB_DEVICE(0x0e0b, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) },
 945         { USB_DEVICE(0x0e0b, 0x9041), USB_DEVICE_DATA(&rt2800usb_ops) },
 946         /* ASUS */
 947         { USB_DEVICE(0x0b05, 0x1760), USB_DEVICE_DATA(&rt2800usb_ops) },
 948         { USB_DEVICE(0x0b05, 0x1761), USB_DEVICE_DATA(&rt2800usb_ops) },
 949         { USB_DEVICE(0x0b05, 0x1790), USB_DEVICE_DATA(&rt2800usb_ops) },
 950         { USB_DEVICE(0x1761, 0x0b05), USB_DEVICE_DATA(&rt2800usb_ops) },
 951         /* AzureWave */
 952         { USB_DEVICE(0x13d3, 0x3262), USB_DEVICE_DATA(&rt2800usb_ops) },
 953         { USB_DEVICE(0x13d3, 0x3284), USB_DEVICE_DATA(&rt2800usb_ops) },
 954         { USB_DEVICE(0x13d3, 0x3322), USB_DEVICE_DATA(&rt2800usb_ops) },
 955         /* Belkin */
 956         { USB_DEVICE(0x050d, 0x825a), USB_DEVICE_DATA(&rt2800usb_ops) },
 957         /* Buffalo */
 958         { USB_DEVICE(0x0411, 0x012e), USB_DEVICE_DATA(&rt2800usb_ops) },
 959         { USB_DEVICE(0x0411, 0x0148), USB_DEVICE_DATA(&rt2800usb_ops) },
 960         { USB_DEVICE(0x0411, 0x0150), USB_DEVICE_DATA(&rt2800usb_ops) },
 961         { USB_DEVICE(0x0411, 0x015d), USB_DEVICE_DATA(&rt2800usb_ops) },
 962         /* Conceptronic */
 963         { USB_DEVICE(0x14b2, 0x3c08), USB_DEVICE_DATA(&rt2800usb_ops) },
 964         { USB_DEVICE(0x14b2, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) },
 965         /* Corega */
 966         { USB_DEVICE(0x07aa, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) },
 967         { USB_DEVICE(0x07aa, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) },
 968         { USB_DEVICE(0x18c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) },
 969         /* D-Link */
 970         { USB_DEVICE(0x07d1, 0x3c0b), USB_DEVICE_DATA(&rt2800usb_ops) },
 971         { USB_DEVICE(0x07d1, 0x3c13), USB_DEVICE_DATA(&rt2800usb_ops) },
 972         { USB_DEVICE(0x07d1, 0x3c15), USB_DEVICE_DATA(&rt2800usb_ops) },
 973         { USB_DEVICE(0x07d1, 0x3c17), USB_DEVICE_DATA(&rt2800usb_ops) },
 974         /* Encore */
 975         { USB_DEVICE(0x203d, 0x14a1), USB_DEVICE_DATA(&rt2800usb_ops) },
 976         /* Gemtek */
 977         { USB_DEVICE(0x15a9, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) },
 978         /* Gigabyte */
 979         { USB_DEVICE(0x1044, 0x800c), USB_DEVICE_DATA(&rt2800usb_ops) },
 980         /* LevelOne */
 981         { USB_DEVICE(0x1740, 0x0605), USB_DEVICE_DATA(&rt2800usb_ops) },
 982         { USB_DEVICE(0x1740, 0x0615), USB_DEVICE_DATA(&rt2800usb_ops) },
 983         /* Linksys */
 984         { USB_DEVICE(0x1737, 0x0077), USB_DEVICE_DATA(&rt2800usb_ops) },
 985         { USB_DEVICE(0x1737, 0x0078), USB_DEVICE_DATA(&rt2800usb_ops) },
 986         { USB_DEVICE(0x1737, 0x0079), USB_DEVICE_DATA(&rt2800usb_ops) },
 987         /* Motorola */
 988         { USB_DEVICE(0x100d, 0x9032), USB_DEVICE_DATA(&rt2800usb_ops) },
 989         /* Ovislink */
 990         { USB_DEVICE(0x1b75, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) },
 991         { USB_DEVICE(0x1b75, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) },
 992         /* Pegatron */
 993         { USB_DEVICE(0x05a6, 0x0101), USB_DEVICE_DATA(&rt2800usb_ops) },
 994         { USB_DEVICE(0x1d4d, 0x0002), USB_DEVICE_DATA(&rt2800usb_ops) },
 995         { USB_DEVICE(0x1d4d, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) },
 996         { USB_DEVICE(0x1d4d, 0x0011), USB_DEVICE_DATA(&rt2800usb_ops) },
 997         /* Planex */
 998         { USB_DEVICE(0x2019, 0xab24), USB_DEVICE_DATA(&rt2800usb_ops) },
 999         /* Qcom */
1000         { USB_DEVICE(0x18e8, 0x6259), USB_DEVICE_DATA(&rt2800usb_ops) },
1001         /* SMC */
1002         { USB_DEVICE(0x083a, 0xa512), USB_DEVICE_DATA(&rt2800usb_ops) },
1003         { USB_DEVICE(0x083a, 0xc522), USB_DEVICE_DATA(&rt2800usb_ops) },
1004         { USB_DEVICE(0x083a, 0xd522), USB_DEVICE_DATA(&rt2800usb_ops) },
1005         { USB_DEVICE(0x083a, 0xf511), USB_DEVICE_DATA(&rt2800usb_ops) },
1006         /* Sweex */
1007         { USB_DEVICE(0x177f, 0x0153), USB_DEVICE_DATA(&rt2800usb_ops) },
1008         { USB_DEVICE(0x177f, 0x0313), USB_DEVICE_DATA(&rt2800usb_ops) },
1009         /* Zyxel */
1010         { USB_DEVICE(0x0586, 0x341a), USB_DEVICE_DATA(&rt2800usb_ops) },
1011 #endif
1012         { 0, }
1013 };
1014
1015 MODULE_AUTHOR(DRV_PROJECT);
1016 MODULE_VERSION(DRV_VERSION);
1017 MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver.");
1018 MODULE_SUPPORTED_DEVICE("Ralink RT2870 USB chipset based cards");
1019 MODULE_DEVICE_TABLE(usb, rt2800usb_device_table);
1020 MODULE_FIRMWARE(FIRMWARE_RT2870);
1021 MODULE_LICENSE("GPL");
1022
1023 static struct usb_driver rt2800usb_driver = {
1024         .name           = KBUILD_MODNAME,
1025         .id_table       = rt2800usb_device_table,
1026         .probe          = rt2x00usb_probe,
1027         .disconnect     = rt2x00usb_disconnect,
1028         .suspend        = rt2x00usb_suspend,
1029         .resume         = rt2x00usb_resume,
1030 };
1031
1032 static int __init rt2800usb_init(void)
1033 {
1034         return usb_register(&rt2800usb_driver);
1035 }
1036
1037 static void __exit rt2800usb_exit(void)
1038 {
1039         usb_deregister(&rt2800usb_driver);
1040 }
1041
1042 module_init(rt2800usb_init);
1043 module_exit(rt2800usb_exit);