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