Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003     Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
0004     <http://rt2x00.serialmonkey.com>
0005 
0006  */
0007 
0008 /*
0009     Module: rt2500usb
0010     Abstract: rt2500usb device specific routines.
0011     Supported chipsets: RT2570.
0012  */
0013 
0014 #include <linux/delay.h>
0015 #include <linux/etherdevice.h>
0016 #include <linux/kernel.h>
0017 #include <linux/module.h>
0018 #include <linux/slab.h>
0019 #include <linux/usb.h>
0020 
0021 #include "rt2x00.h"
0022 #include "rt2x00usb.h"
0023 #include "rt2500usb.h"
0024 
0025 /*
0026  * Allow hardware encryption to be disabled.
0027  */
0028 static bool modparam_nohwcrypt;
0029 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, 0444);
0030 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
0031 
0032 /*
0033  * Register access.
0034  * All access to the CSR registers will go through the methods
0035  * rt2500usb_register_read and rt2500usb_register_write.
0036  * BBP and RF register require indirect register access,
0037  * and use the CSR registers BBPCSR and RFCSR to achieve this.
0038  * These indirect registers work with busy bits,
0039  * and we will try maximal REGISTER_USB_BUSY_COUNT times to access
0040  * the register while taking a REGISTER_BUSY_DELAY us delay
0041  * between each attampt. When the busy bit is still set at that time,
0042  * the access attempt is considered to have failed,
0043  * and we will print an error.
0044  * If the csr_mutex is already held then the _lock variants must
0045  * be used instead.
0046  */
0047 static u16 rt2500usb_register_read(struct rt2x00_dev *rt2x00dev,
0048                    const unsigned int offset)
0049 {
0050     __le16 reg;
0051     rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_READ,
0052                       USB_VENDOR_REQUEST_IN, offset,
0053                       &reg, sizeof(reg));
0054     return le16_to_cpu(reg);
0055 }
0056 
0057 static u16 rt2500usb_register_read_lock(struct rt2x00_dev *rt2x00dev,
0058                     const unsigned int offset)
0059 {
0060     __le16 reg;
0061     rt2x00usb_vendor_req_buff_lock(rt2x00dev, USB_MULTI_READ,
0062                        USB_VENDOR_REQUEST_IN, offset,
0063                        &reg, sizeof(reg), REGISTER_TIMEOUT);
0064     return le16_to_cpu(reg);
0065 }
0066 
0067 static void rt2500usb_register_write(struct rt2x00_dev *rt2x00dev,
0068                         const unsigned int offset,
0069                         u16 value)
0070 {
0071     __le16 reg = cpu_to_le16(value);
0072     rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_WRITE,
0073                       USB_VENDOR_REQUEST_OUT, offset,
0074                       &reg, sizeof(reg));
0075 }
0076 
0077 static void rt2500usb_register_write_lock(struct rt2x00_dev *rt2x00dev,
0078                          const unsigned int offset,
0079                          u16 value)
0080 {
0081     __le16 reg = cpu_to_le16(value);
0082     rt2x00usb_vendor_req_buff_lock(rt2x00dev, USB_MULTI_WRITE,
0083                        USB_VENDOR_REQUEST_OUT, offset,
0084                        &reg, sizeof(reg), REGISTER_TIMEOUT);
0085 }
0086 
0087 static void rt2500usb_register_multiwrite(struct rt2x00_dev *rt2x00dev,
0088                          const unsigned int offset,
0089                          void *value, const u16 length)
0090 {
0091     rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_WRITE,
0092                       USB_VENDOR_REQUEST_OUT, offset,
0093                       value, length);
0094 }
0095 
0096 static int rt2500usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
0097                   const unsigned int offset,
0098                   struct rt2x00_field16 field,
0099                   u16 *reg)
0100 {
0101     unsigned int i;
0102 
0103     for (i = 0; i < REGISTER_USB_BUSY_COUNT; i++) {
0104         *reg = rt2500usb_register_read_lock(rt2x00dev, offset);
0105         if (!rt2x00_get_field16(*reg, field))
0106             return 1;
0107         udelay(REGISTER_BUSY_DELAY);
0108     }
0109 
0110     rt2x00_err(rt2x00dev, "Indirect register access failed: offset=0x%.08x, value=0x%.08x\n",
0111            offset, *reg);
0112     *reg = ~0;
0113 
0114     return 0;
0115 }
0116 
0117 #define WAIT_FOR_BBP(__dev, __reg) \
0118     rt2500usb_regbusy_read((__dev), PHY_CSR8, PHY_CSR8_BUSY, (__reg))
0119 #define WAIT_FOR_RF(__dev, __reg) \
0120     rt2500usb_regbusy_read((__dev), PHY_CSR10, PHY_CSR10_RF_BUSY, (__reg))
0121 
0122 static void rt2500usb_bbp_write(struct rt2x00_dev *rt2x00dev,
0123                 const unsigned int word, const u8 value)
0124 {
0125     u16 reg;
0126 
0127     mutex_lock(&rt2x00dev->csr_mutex);
0128 
0129     /*
0130      * Wait until the BBP becomes available, afterwards we
0131      * can safely write the new data into the register.
0132      */
0133     if (WAIT_FOR_BBP(rt2x00dev, &reg)) {
0134         reg = 0;
0135         rt2x00_set_field16(&reg, PHY_CSR7_DATA, value);
0136         rt2x00_set_field16(&reg, PHY_CSR7_REG_ID, word);
0137         rt2x00_set_field16(&reg, PHY_CSR7_READ_CONTROL, 0);
0138 
0139         rt2500usb_register_write_lock(rt2x00dev, PHY_CSR7, reg);
0140     }
0141 
0142     mutex_unlock(&rt2x00dev->csr_mutex);
0143 }
0144 
0145 static u8 rt2500usb_bbp_read(struct rt2x00_dev *rt2x00dev,
0146                  const unsigned int word)
0147 {
0148     u16 reg;
0149     u8 value;
0150 
0151     mutex_lock(&rt2x00dev->csr_mutex);
0152 
0153     /*
0154      * Wait until the BBP becomes available, afterwards we
0155      * can safely write the read request into the register.
0156      * After the data has been written, we wait until hardware
0157      * returns the correct value, if at any time the register
0158      * doesn't become available in time, reg will be 0xffffffff
0159      * which means we return 0xff to the caller.
0160      */
0161     if (WAIT_FOR_BBP(rt2x00dev, &reg)) {
0162         reg = 0;
0163         rt2x00_set_field16(&reg, PHY_CSR7_REG_ID, word);
0164         rt2x00_set_field16(&reg, PHY_CSR7_READ_CONTROL, 1);
0165 
0166         rt2500usb_register_write_lock(rt2x00dev, PHY_CSR7, reg);
0167 
0168         if (WAIT_FOR_BBP(rt2x00dev, &reg))
0169             reg = rt2500usb_register_read_lock(rt2x00dev, PHY_CSR7);
0170     }
0171 
0172     value = rt2x00_get_field16(reg, PHY_CSR7_DATA);
0173 
0174     mutex_unlock(&rt2x00dev->csr_mutex);
0175 
0176     return value;
0177 }
0178 
0179 static void rt2500usb_rf_write(struct rt2x00_dev *rt2x00dev,
0180                    const unsigned int word, const u32 value)
0181 {
0182     u16 reg;
0183 
0184     mutex_lock(&rt2x00dev->csr_mutex);
0185 
0186     /*
0187      * Wait until the RF becomes available, afterwards we
0188      * can safely write the new data into the register.
0189      */
0190     if (WAIT_FOR_RF(rt2x00dev, &reg)) {
0191         reg = 0;
0192         rt2x00_set_field16(&reg, PHY_CSR9_RF_VALUE, value);
0193         rt2500usb_register_write_lock(rt2x00dev, PHY_CSR9, reg);
0194 
0195         reg = 0;
0196         rt2x00_set_field16(&reg, PHY_CSR10_RF_VALUE, value >> 16);
0197         rt2x00_set_field16(&reg, PHY_CSR10_RF_NUMBER_OF_BITS, 20);
0198         rt2x00_set_field16(&reg, PHY_CSR10_RF_IF_SELECT, 0);
0199         rt2x00_set_field16(&reg, PHY_CSR10_RF_BUSY, 1);
0200 
0201         rt2500usb_register_write_lock(rt2x00dev, PHY_CSR10, reg);
0202         rt2x00_rf_write(rt2x00dev, word, value);
0203     }
0204 
0205     mutex_unlock(&rt2x00dev->csr_mutex);
0206 }
0207 
0208 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
0209 static u32 _rt2500usb_register_read(struct rt2x00_dev *rt2x00dev,
0210                      const unsigned int offset)
0211 {
0212     return rt2500usb_register_read(rt2x00dev, offset);
0213 }
0214 
0215 static void _rt2500usb_register_write(struct rt2x00_dev *rt2x00dev,
0216                       const unsigned int offset,
0217                       u32 value)
0218 {
0219     rt2500usb_register_write(rt2x00dev, offset, value);
0220 }
0221 
0222 static const struct rt2x00debug rt2500usb_rt2x00debug = {
0223     .owner  = THIS_MODULE,
0224     .csr    = {
0225         .read       = _rt2500usb_register_read,
0226         .write      = _rt2500usb_register_write,
0227         .flags      = RT2X00DEBUGFS_OFFSET,
0228         .word_base  = CSR_REG_BASE,
0229         .word_size  = sizeof(u16),
0230         .word_count = CSR_REG_SIZE / sizeof(u16),
0231     },
0232     .eeprom = {
0233         .read       = rt2x00_eeprom_read,
0234         .write      = rt2x00_eeprom_write,
0235         .word_base  = EEPROM_BASE,
0236         .word_size  = sizeof(u16),
0237         .word_count = EEPROM_SIZE / sizeof(u16),
0238     },
0239     .bbp    = {
0240         .read       = rt2500usb_bbp_read,
0241         .write      = rt2500usb_bbp_write,
0242         .word_base  = BBP_BASE,
0243         .word_size  = sizeof(u8),
0244         .word_count = BBP_SIZE / sizeof(u8),
0245     },
0246     .rf = {
0247         .read       = rt2x00_rf_read,
0248         .write      = rt2500usb_rf_write,
0249         .word_base  = RF_BASE,
0250         .word_size  = sizeof(u32),
0251         .word_count = RF_SIZE / sizeof(u32),
0252     },
0253 };
0254 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
0255 
0256 static int rt2500usb_rfkill_poll(struct rt2x00_dev *rt2x00dev)
0257 {
0258     u16 reg;
0259 
0260     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR19);
0261     return rt2x00_get_field16(reg, MAC_CSR19_VAL7);
0262 }
0263 
0264 #ifdef CONFIG_RT2X00_LIB_LEDS
0265 static void rt2500usb_brightness_set(struct led_classdev *led_cdev,
0266                      enum led_brightness brightness)
0267 {
0268     struct rt2x00_led *led =
0269         container_of(led_cdev, struct rt2x00_led, led_dev);
0270     unsigned int enabled = brightness != LED_OFF;
0271     u16 reg;
0272 
0273     reg = rt2500usb_register_read(led->rt2x00dev, MAC_CSR20);
0274 
0275     if (led->type == LED_TYPE_RADIO || led->type == LED_TYPE_ASSOC)
0276         rt2x00_set_field16(&reg, MAC_CSR20_LINK, enabled);
0277     else if (led->type == LED_TYPE_ACTIVITY)
0278         rt2x00_set_field16(&reg, MAC_CSR20_ACTIVITY, enabled);
0279 
0280     rt2500usb_register_write(led->rt2x00dev, MAC_CSR20, reg);
0281 }
0282 
0283 static int rt2500usb_blink_set(struct led_classdev *led_cdev,
0284                    unsigned long *delay_on,
0285                    unsigned long *delay_off)
0286 {
0287     struct rt2x00_led *led =
0288         container_of(led_cdev, struct rt2x00_led, led_dev);
0289     u16 reg;
0290 
0291     reg = rt2500usb_register_read(led->rt2x00dev, MAC_CSR21);
0292     rt2x00_set_field16(&reg, MAC_CSR21_ON_PERIOD, *delay_on);
0293     rt2x00_set_field16(&reg, MAC_CSR21_OFF_PERIOD, *delay_off);
0294     rt2500usb_register_write(led->rt2x00dev, MAC_CSR21, reg);
0295 
0296     return 0;
0297 }
0298 
0299 static void rt2500usb_init_led(struct rt2x00_dev *rt2x00dev,
0300                    struct rt2x00_led *led,
0301                    enum led_type type)
0302 {
0303     led->rt2x00dev = rt2x00dev;
0304     led->type = type;
0305     led->led_dev.brightness_set = rt2500usb_brightness_set;
0306     led->led_dev.blink_set = rt2500usb_blink_set;
0307     led->flags = LED_INITIALIZED;
0308 }
0309 #endif /* CONFIG_RT2X00_LIB_LEDS */
0310 
0311 /*
0312  * Configuration handlers.
0313  */
0314 
0315 /*
0316  * rt2500usb does not differentiate between shared and pairwise
0317  * keys, so we should use the same function for both key types.
0318  */
0319 static int rt2500usb_config_key(struct rt2x00_dev *rt2x00dev,
0320                 struct rt2x00lib_crypto *crypto,
0321                 struct ieee80211_key_conf *key)
0322 {
0323     u32 mask;
0324     u16 reg;
0325     enum cipher curr_cipher;
0326 
0327     if (crypto->cmd == SET_KEY) {
0328         /*
0329          * Disallow to set WEP key other than with index 0,
0330          * it is known that not work at least on some hardware.
0331          * SW crypto will be used in that case.
0332          */
0333         if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
0334              key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
0335             key->keyidx != 0)
0336             return -EOPNOTSUPP;
0337 
0338         /*
0339          * Pairwise key will always be entry 0, but this
0340          * could collide with a shared key on the same
0341          * position...
0342          */
0343         mask = TXRX_CSR0_KEY_ID.bit_mask;
0344 
0345         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR0);
0346         curr_cipher = rt2x00_get_field16(reg, TXRX_CSR0_ALGORITHM);
0347         reg &= mask;
0348 
0349         if (reg && reg == mask)
0350             return -ENOSPC;
0351 
0352         reg = rt2x00_get_field16(reg, TXRX_CSR0_KEY_ID);
0353 
0354         key->hw_key_idx += reg ? ffz(reg) : 0;
0355         /*
0356          * Hardware requires that all keys use the same cipher
0357          * (e.g. TKIP-only, AES-only, but not TKIP+AES).
0358          * If this is not the first key, compare the cipher with the
0359          * first one and fall back to SW crypto if not the same.
0360          */
0361         if (key->hw_key_idx > 0 && crypto->cipher != curr_cipher)
0362             return -EOPNOTSUPP;
0363 
0364         rt2500usb_register_multiwrite(rt2x00dev, KEY_ENTRY(key->hw_key_idx),
0365                           crypto->key, sizeof(crypto->key));
0366 
0367         /*
0368          * The driver does not support the IV/EIV generation
0369          * in hardware. However it demands the data to be provided
0370          * both separately as well as inside the frame.
0371          * We already provided the CONFIG_CRYPTO_COPY_IV to rt2x00lib
0372          * to ensure rt2x00lib will not strip the data from the
0373          * frame after the copy, now we must tell mac80211
0374          * to generate the IV/EIV data.
0375          */
0376         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
0377         key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
0378     }
0379 
0380     /*
0381      * TXRX_CSR0_KEY_ID contains only single-bit fields to indicate
0382      * a particular key is valid.
0383      */
0384     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR0);
0385     rt2x00_set_field16(&reg, TXRX_CSR0_ALGORITHM, crypto->cipher);
0386     rt2x00_set_field16(&reg, TXRX_CSR0_IV_OFFSET, IEEE80211_HEADER);
0387 
0388     mask = rt2x00_get_field16(reg, TXRX_CSR0_KEY_ID);
0389     if (crypto->cmd == SET_KEY)
0390         mask |= 1 << key->hw_key_idx;
0391     else if (crypto->cmd == DISABLE_KEY)
0392         mask &= ~(1 << key->hw_key_idx);
0393     rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, mask);
0394     rt2500usb_register_write(rt2x00dev, TXRX_CSR0, reg);
0395 
0396     return 0;
0397 }
0398 
0399 static void rt2500usb_config_filter(struct rt2x00_dev *rt2x00dev,
0400                     const unsigned int filter_flags)
0401 {
0402     u16 reg;
0403 
0404     /*
0405      * Start configuration steps.
0406      * Note that the version error will always be dropped
0407      * and broadcast frames will always be accepted since
0408      * there is no filter for it at this time.
0409      */
0410     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR2);
0411     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_CRC,
0412                !(filter_flags & FIF_FCSFAIL));
0413     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_PHYSICAL,
0414                !(filter_flags & FIF_PLCPFAIL));
0415     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_CONTROL,
0416                !(filter_flags & FIF_CONTROL));
0417     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_NOT_TO_ME,
0418                !test_bit(CONFIG_MONITORING, &rt2x00dev->flags));
0419     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_TODS,
0420                !test_bit(CONFIG_MONITORING, &rt2x00dev->flags) &&
0421                !rt2x00dev->intf_ap_count);
0422     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_VERSION_ERROR, 1);
0423     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_MULTICAST,
0424                !(filter_flags & FIF_ALLMULTI));
0425     rt2x00_set_field16(&reg, TXRX_CSR2_DROP_BROADCAST, 0);
0426     rt2500usb_register_write(rt2x00dev, TXRX_CSR2, reg);
0427 }
0428 
0429 static void rt2500usb_config_intf(struct rt2x00_dev *rt2x00dev,
0430                   struct rt2x00_intf *intf,
0431                   struct rt2x00intf_conf *conf,
0432                   const unsigned int flags)
0433 {
0434     unsigned int bcn_preload;
0435     u16 reg;
0436 
0437     if (flags & CONFIG_UPDATE_TYPE) {
0438         /*
0439          * Enable beacon config
0440          */
0441         bcn_preload = PREAMBLE + GET_DURATION(IEEE80211_HEADER, 20);
0442         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR20);
0443         rt2x00_set_field16(&reg, TXRX_CSR20_OFFSET, bcn_preload >> 6);
0444         rt2x00_set_field16(&reg, TXRX_CSR20_BCN_EXPECT_WINDOW,
0445                    2 * (conf->type != NL80211_IFTYPE_STATION));
0446         rt2500usb_register_write(rt2x00dev, TXRX_CSR20, reg);
0447 
0448         /*
0449          * Enable synchronisation.
0450          */
0451         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR18);
0452         rt2x00_set_field16(&reg, TXRX_CSR18_OFFSET, 0);
0453         rt2500usb_register_write(rt2x00dev, TXRX_CSR18, reg);
0454 
0455         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR19);
0456         rt2x00_set_field16(&reg, TXRX_CSR19_TSF_SYNC, conf->sync);
0457         rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
0458     }
0459 
0460     if (flags & CONFIG_UPDATE_MAC)
0461         rt2500usb_register_multiwrite(rt2x00dev, MAC_CSR2, conf->mac,
0462                           (3 * sizeof(__le16)));
0463 
0464     if (flags & CONFIG_UPDATE_BSSID)
0465         rt2500usb_register_multiwrite(rt2x00dev, MAC_CSR5, conf->bssid,
0466                           (3 * sizeof(__le16)));
0467 }
0468 
0469 static void rt2500usb_config_erp(struct rt2x00_dev *rt2x00dev,
0470                  struct rt2x00lib_erp *erp,
0471                  u32 changed)
0472 {
0473     u16 reg;
0474 
0475     if (changed & BSS_CHANGED_ERP_PREAMBLE) {
0476         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR10);
0477         rt2x00_set_field16(&reg, TXRX_CSR10_AUTORESPOND_PREAMBLE,
0478                    !!erp->short_preamble);
0479         rt2500usb_register_write(rt2x00dev, TXRX_CSR10, reg);
0480     }
0481 
0482     if (changed & BSS_CHANGED_BASIC_RATES)
0483         rt2500usb_register_write(rt2x00dev, TXRX_CSR11,
0484                      erp->basic_rates);
0485 
0486     if (changed & BSS_CHANGED_BEACON_INT) {
0487         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR18);
0488         rt2x00_set_field16(&reg, TXRX_CSR18_INTERVAL,
0489                    erp->beacon_int * 4);
0490         rt2500usb_register_write(rt2x00dev, TXRX_CSR18, reg);
0491     }
0492 
0493     if (changed & BSS_CHANGED_ERP_SLOT) {
0494         rt2500usb_register_write(rt2x00dev, MAC_CSR10, erp->slot_time);
0495         rt2500usb_register_write(rt2x00dev, MAC_CSR11, erp->sifs);
0496         rt2500usb_register_write(rt2x00dev, MAC_CSR12, erp->eifs);
0497     }
0498 }
0499 
0500 static void rt2500usb_config_ant(struct rt2x00_dev *rt2x00dev,
0501                  struct antenna_setup *ant)
0502 {
0503     u8 r2;
0504     u8 r14;
0505     u16 csr5;
0506     u16 csr6;
0507 
0508     /*
0509      * We should never come here because rt2x00lib is supposed
0510      * to catch this and send us the correct antenna explicitely.
0511      */
0512     BUG_ON(ant->rx == ANTENNA_SW_DIVERSITY ||
0513            ant->tx == ANTENNA_SW_DIVERSITY);
0514 
0515     r2 = rt2500usb_bbp_read(rt2x00dev, 2);
0516     r14 = rt2500usb_bbp_read(rt2x00dev, 14);
0517     csr5 = rt2500usb_register_read(rt2x00dev, PHY_CSR5);
0518     csr6 = rt2500usb_register_read(rt2x00dev, PHY_CSR6);
0519 
0520     /*
0521      * Configure the TX antenna.
0522      */
0523     switch (ant->tx) {
0524     case ANTENNA_HW_DIVERSITY:
0525         rt2x00_set_field8(&r2, BBP_R2_TX_ANTENNA, 1);
0526         rt2x00_set_field16(&csr5, PHY_CSR5_CCK, 1);
0527         rt2x00_set_field16(&csr6, PHY_CSR6_OFDM, 1);
0528         break;
0529     case ANTENNA_A:
0530         rt2x00_set_field8(&r2, BBP_R2_TX_ANTENNA, 0);
0531         rt2x00_set_field16(&csr5, PHY_CSR5_CCK, 0);
0532         rt2x00_set_field16(&csr6, PHY_CSR6_OFDM, 0);
0533         break;
0534     case ANTENNA_B:
0535     default:
0536         rt2x00_set_field8(&r2, BBP_R2_TX_ANTENNA, 2);
0537         rt2x00_set_field16(&csr5, PHY_CSR5_CCK, 2);
0538         rt2x00_set_field16(&csr6, PHY_CSR6_OFDM, 2);
0539         break;
0540     }
0541 
0542     /*
0543      * Configure the RX antenna.
0544      */
0545     switch (ant->rx) {
0546     case ANTENNA_HW_DIVERSITY:
0547         rt2x00_set_field8(&r14, BBP_R14_RX_ANTENNA, 1);
0548         break;
0549     case ANTENNA_A:
0550         rt2x00_set_field8(&r14, BBP_R14_RX_ANTENNA, 0);
0551         break;
0552     case ANTENNA_B:
0553     default:
0554         rt2x00_set_field8(&r14, BBP_R14_RX_ANTENNA, 2);
0555         break;
0556     }
0557 
0558     /*
0559      * RT2525E and RT5222 need to flip TX I/Q
0560      */
0561     if (rt2x00_rf(rt2x00dev, RF2525E) || rt2x00_rf(rt2x00dev, RF5222)) {
0562         rt2x00_set_field8(&r2, BBP_R2_TX_IQ_FLIP, 1);
0563         rt2x00_set_field16(&csr5, PHY_CSR5_CCK_FLIP, 1);
0564         rt2x00_set_field16(&csr6, PHY_CSR6_OFDM_FLIP, 1);
0565 
0566         /*
0567          * RT2525E does not need RX I/Q Flip.
0568          */
0569         if (rt2x00_rf(rt2x00dev, RF2525E))
0570             rt2x00_set_field8(&r14, BBP_R14_RX_IQ_FLIP, 0);
0571     } else {
0572         rt2x00_set_field16(&csr5, PHY_CSR5_CCK_FLIP, 0);
0573         rt2x00_set_field16(&csr6, PHY_CSR6_OFDM_FLIP, 0);
0574     }
0575 
0576     rt2500usb_bbp_write(rt2x00dev, 2, r2);
0577     rt2500usb_bbp_write(rt2x00dev, 14, r14);
0578     rt2500usb_register_write(rt2x00dev, PHY_CSR5, csr5);
0579     rt2500usb_register_write(rt2x00dev, PHY_CSR6, csr6);
0580 }
0581 
0582 static void rt2500usb_config_channel(struct rt2x00_dev *rt2x00dev,
0583                      struct rf_channel *rf, const int txpower)
0584 {
0585     /*
0586      * Set TXpower.
0587      */
0588     rt2x00_set_field32(&rf->rf3, RF3_TXPOWER, TXPOWER_TO_DEV(txpower));
0589 
0590     /*
0591      * For RT2525E we should first set the channel to half band higher.
0592      */
0593     if (rt2x00_rf(rt2x00dev, RF2525E)) {
0594         static const u32 vals[] = {
0595             0x000008aa, 0x000008ae, 0x000008ae, 0x000008b2,
0596             0x000008b2, 0x000008b6, 0x000008b6, 0x000008ba,
0597             0x000008ba, 0x000008be, 0x000008b7, 0x00000902,
0598             0x00000902, 0x00000906
0599         };
0600 
0601         rt2500usb_rf_write(rt2x00dev, 2, vals[rf->channel - 1]);
0602         if (rf->rf4)
0603             rt2500usb_rf_write(rt2x00dev, 4, rf->rf4);
0604     }
0605 
0606     rt2500usb_rf_write(rt2x00dev, 1, rf->rf1);
0607     rt2500usb_rf_write(rt2x00dev, 2, rf->rf2);
0608     rt2500usb_rf_write(rt2x00dev, 3, rf->rf3);
0609     if (rf->rf4)
0610         rt2500usb_rf_write(rt2x00dev, 4, rf->rf4);
0611 }
0612 
0613 static void rt2500usb_config_txpower(struct rt2x00_dev *rt2x00dev,
0614                      const int txpower)
0615 {
0616     u32 rf3;
0617 
0618     rf3 = rt2x00_rf_read(rt2x00dev, 3);
0619     rt2x00_set_field32(&rf3, RF3_TXPOWER, TXPOWER_TO_DEV(txpower));
0620     rt2500usb_rf_write(rt2x00dev, 3, rf3);
0621 }
0622 
0623 static void rt2500usb_config_ps(struct rt2x00_dev *rt2x00dev,
0624                 struct rt2x00lib_conf *libconf)
0625 {
0626     enum dev_state state =
0627         (libconf->conf->flags & IEEE80211_CONF_PS) ?
0628         STATE_SLEEP : STATE_AWAKE;
0629     u16 reg;
0630 
0631     if (state == STATE_SLEEP) {
0632         reg = rt2500usb_register_read(rt2x00dev, MAC_CSR18);
0633         rt2x00_set_field16(&reg, MAC_CSR18_DELAY_AFTER_BEACON,
0634                    rt2x00dev->beacon_int - 20);
0635         rt2x00_set_field16(&reg, MAC_CSR18_BEACONS_BEFORE_WAKEUP,
0636                    libconf->conf->listen_interval - 1);
0637 
0638         /* We must first disable autowake before it can be enabled */
0639         rt2x00_set_field16(&reg, MAC_CSR18_AUTO_WAKE, 0);
0640         rt2500usb_register_write(rt2x00dev, MAC_CSR18, reg);
0641 
0642         rt2x00_set_field16(&reg, MAC_CSR18_AUTO_WAKE, 1);
0643         rt2500usb_register_write(rt2x00dev, MAC_CSR18, reg);
0644     } else {
0645         reg = rt2500usb_register_read(rt2x00dev, MAC_CSR18);
0646         rt2x00_set_field16(&reg, MAC_CSR18_AUTO_WAKE, 0);
0647         rt2500usb_register_write(rt2x00dev, MAC_CSR18, reg);
0648     }
0649 
0650     rt2x00dev->ops->lib->set_device_state(rt2x00dev, state);
0651 }
0652 
0653 static void rt2500usb_config(struct rt2x00_dev *rt2x00dev,
0654                  struct rt2x00lib_conf *libconf,
0655                  const unsigned int flags)
0656 {
0657     if (flags & IEEE80211_CONF_CHANGE_CHANNEL)
0658         rt2500usb_config_channel(rt2x00dev, &libconf->rf,
0659                      libconf->conf->power_level);
0660     if ((flags & IEEE80211_CONF_CHANGE_POWER) &&
0661         !(flags & IEEE80211_CONF_CHANGE_CHANNEL))
0662         rt2500usb_config_txpower(rt2x00dev,
0663                      libconf->conf->power_level);
0664     if (flags & IEEE80211_CONF_CHANGE_PS)
0665         rt2500usb_config_ps(rt2x00dev, libconf);
0666 }
0667 
0668 /*
0669  * Link tuning
0670  */
0671 static void rt2500usb_link_stats(struct rt2x00_dev *rt2x00dev,
0672                  struct link_qual *qual)
0673 {
0674     u16 reg;
0675 
0676     /*
0677      * Update FCS error count from register.
0678      */
0679     reg = rt2500usb_register_read(rt2x00dev, STA_CSR0);
0680     qual->rx_failed = rt2x00_get_field16(reg, STA_CSR0_FCS_ERROR);
0681 
0682     /*
0683      * Update False CCA count from register.
0684      */
0685     reg = rt2500usb_register_read(rt2x00dev, STA_CSR3);
0686     qual->false_cca = rt2x00_get_field16(reg, STA_CSR3_FALSE_CCA_ERROR);
0687 }
0688 
0689 static void rt2500usb_reset_tuner(struct rt2x00_dev *rt2x00dev,
0690                   struct link_qual *qual)
0691 {
0692     u16 eeprom;
0693     u16 value;
0694 
0695     eeprom = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R24);
0696     value = rt2x00_get_field16(eeprom, EEPROM_BBPTUNE_R24_LOW);
0697     rt2500usb_bbp_write(rt2x00dev, 24, value);
0698 
0699     eeprom = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R25);
0700     value = rt2x00_get_field16(eeprom, EEPROM_BBPTUNE_R25_LOW);
0701     rt2500usb_bbp_write(rt2x00dev, 25, value);
0702 
0703     eeprom = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R61);
0704     value = rt2x00_get_field16(eeprom, EEPROM_BBPTUNE_R61_LOW);
0705     rt2500usb_bbp_write(rt2x00dev, 61, value);
0706 
0707     eeprom = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_VGC);
0708     value = rt2x00_get_field16(eeprom, EEPROM_BBPTUNE_VGCUPPER);
0709     rt2500usb_bbp_write(rt2x00dev, 17, value);
0710 
0711     qual->vgc_level = value;
0712 }
0713 
0714 /*
0715  * Queue handlers.
0716  */
0717 static void rt2500usb_start_queue(struct data_queue *queue)
0718 {
0719     struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
0720     u16 reg;
0721 
0722     switch (queue->qid) {
0723     case QID_RX:
0724         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR2);
0725         rt2x00_set_field16(&reg, TXRX_CSR2_DISABLE_RX, 0);
0726         rt2500usb_register_write(rt2x00dev, TXRX_CSR2, reg);
0727         break;
0728     case QID_BEACON:
0729         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR19);
0730         rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 1);
0731         rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 1);
0732         rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 1);
0733         rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
0734         break;
0735     default:
0736         break;
0737     }
0738 }
0739 
0740 static void rt2500usb_stop_queue(struct data_queue *queue)
0741 {
0742     struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
0743     u16 reg;
0744 
0745     switch (queue->qid) {
0746     case QID_RX:
0747         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR2);
0748         rt2x00_set_field16(&reg, TXRX_CSR2_DISABLE_RX, 1);
0749         rt2500usb_register_write(rt2x00dev, TXRX_CSR2, reg);
0750         break;
0751     case QID_BEACON:
0752         reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR19);
0753         rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 0);
0754         rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 0);
0755         rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 0);
0756         rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
0757         break;
0758     default:
0759         break;
0760     }
0761 }
0762 
0763 /*
0764  * Initialization functions.
0765  */
0766 static int rt2500usb_init_registers(struct rt2x00_dev *rt2x00dev)
0767 {
0768     u16 reg;
0769 
0770     rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, 0x0001,
0771                     USB_MODE_TEST, REGISTER_TIMEOUT);
0772     rt2x00usb_vendor_request_sw(rt2x00dev, USB_SINGLE_WRITE, 0x0308,
0773                     0x00f0, REGISTER_TIMEOUT);
0774 
0775     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR2);
0776     rt2x00_set_field16(&reg, TXRX_CSR2_DISABLE_RX, 1);
0777     rt2500usb_register_write(rt2x00dev, TXRX_CSR2, reg);
0778 
0779     rt2500usb_register_write(rt2x00dev, MAC_CSR13, 0x1111);
0780     rt2500usb_register_write(rt2x00dev, MAC_CSR14, 0x1e11);
0781 
0782     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR1);
0783     rt2x00_set_field16(&reg, MAC_CSR1_SOFT_RESET, 1);
0784     rt2x00_set_field16(&reg, MAC_CSR1_BBP_RESET, 1);
0785     rt2x00_set_field16(&reg, MAC_CSR1_HOST_READY, 0);
0786     rt2500usb_register_write(rt2x00dev, MAC_CSR1, reg);
0787 
0788     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR1);
0789     rt2x00_set_field16(&reg, MAC_CSR1_SOFT_RESET, 0);
0790     rt2x00_set_field16(&reg, MAC_CSR1_BBP_RESET, 0);
0791     rt2x00_set_field16(&reg, MAC_CSR1_HOST_READY, 0);
0792     rt2500usb_register_write(rt2x00dev, MAC_CSR1, reg);
0793 
0794     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR5);
0795     rt2x00_set_field16(&reg, TXRX_CSR5_BBP_ID0, 13);
0796     rt2x00_set_field16(&reg, TXRX_CSR5_BBP_ID0_VALID, 1);
0797     rt2x00_set_field16(&reg, TXRX_CSR5_BBP_ID1, 12);
0798     rt2x00_set_field16(&reg, TXRX_CSR5_BBP_ID1_VALID, 1);
0799     rt2500usb_register_write(rt2x00dev, TXRX_CSR5, reg);
0800 
0801     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR6);
0802     rt2x00_set_field16(&reg, TXRX_CSR6_BBP_ID0, 10);
0803     rt2x00_set_field16(&reg, TXRX_CSR6_BBP_ID0_VALID, 1);
0804     rt2x00_set_field16(&reg, TXRX_CSR6_BBP_ID1, 11);
0805     rt2x00_set_field16(&reg, TXRX_CSR6_BBP_ID1_VALID, 1);
0806     rt2500usb_register_write(rt2x00dev, TXRX_CSR6, reg);
0807 
0808     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR7);
0809     rt2x00_set_field16(&reg, TXRX_CSR7_BBP_ID0, 7);
0810     rt2x00_set_field16(&reg, TXRX_CSR7_BBP_ID0_VALID, 1);
0811     rt2x00_set_field16(&reg, TXRX_CSR7_BBP_ID1, 6);
0812     rt2x00_set_field16(&reg, TXRX_CSR7_BBP_ID1_VALID, 1);
0813     rt2500usb_register_write(rt2x00dev, TXRX_CSR7, reg);
0814 
0815     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR8);
0816     rt2x00_set_field16(&reg, TXRX_CSR8_BBP_ID0, 5);
0817     rt2x00_set_field16(&reg, TXRX_CSR8_BBP_ID0_VALID, 1);
0818     rt2x00_set_field16(&reg, TXRX_CSR8_BBP_ID1, 0);
0819     rt2x00_set_field16(&reg, TXRX_CSR8_BBP_ID1_VALID, 0);
0820     rt2500usb_register_write(rt2x00dev, TXRX_CSR8, reg);
0821 
0822     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR19);
0823     rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 0);
0824     rt2x00_set_field16(&reg, TXRX_CSR19_TSF_SYNC, 0);
0825     rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 0);
0826     rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 0);
0827     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
0828 
0829     rt2500usb_register_write(rt2x00dev, TXRX_CSR21, 0xe78f);
0830     rt2500usb_register_write(rt2x00dev, MAC_CSR9, 0xff1d);
0831 
0832     if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
0833         return -EBUSY;
0834 
0835     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR1);
0836     rt2x00_set_field16(&reg, MAC_CSR1_SOFT_RESET, 0);
0837     rt2x00_set_field16(&reg, MAC_CSR1_BBP_RESET, 0);
0838     rt2x00_set_field16(&reg, MAC_CSR1_HOST_READY, 1);
0839     rt2500usb_register_write(rt2x00dev, MAC_CSR1, reg);
0840 
0841     if (rt2x00_rev(rt2x00dev) >= RT2570_VERSION_C) {
0842         reg = rt2500usb_register_read(rt2x00dev, PHY_CSR2);
0843         rt2x00_set_field16(&reg, PHY_CSR2_LNA, 0);
0844     } else {
0845         reg = 0;
0846         rt2x00_set_field16(&reg, PHY_CSR2_LNA, 1);
0847         rt2x00_set_field16(&reg, PHY_CSR2_LNA_MODE, 3);
0848     }
0849     rt2500usb_register_write(rt2x00dev, PHY_CSR2, reg);
0850 
0851     rt2500usb_register_write(rt2x00dev, MAC_CSR11, 0x0002);
0852     rt2500usb_register_write(rt2x00dev, MAC_CSR22, 0x0053);
0853     rt2500usb_register_write(rt2x00dev, MAC_CSR15, 0x01ee);
0854     rt2500usb_register_write(rt2x00dev, MAC_CSR16, 0x0000);
0855 
0856     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR8);
0857     rt2x00_set_field16(&reg, MAC_CSR8_MAX_FRAME_UNIT,
0858                rt2x00dev->rx->data_size);
0859     rt2500usb_register_write(rt2x00dev, MAC_CSR8, reg);
0860 
0861     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR0);
0862     rt2x00_set_field16(&reg, TXRX_CSR0_ALGORITHM, CIPHER_NONE);
0863     rt2x00_set_field16(&reg, TXRX_CSR0_IV_OFFSET, IEEE80211_HEADER);
0864     rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, 0);
0865     rt2500usb_register_write(rt2x00dev, TXRX_CSR0, reg);
0866 
0867     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR18);
0868     rt2x00_set_field16(&reg, MAC_CSR18_DELAY_AFTER_BEACON, 90);
0869     rt2500usb_register_write(rt2x00dev, MAC_CSR18, reg);
0870 
0871     reg = rt2500usb_register_read(rt2x00dev, PHY_CSR4);
0872     rt2x00_set_field16(&reg, PHY_CSR4_LOW_RF_LE, 1);
0873     rt2500usb_register_write(rt2x00dev, PHY_CSR4, reg);
0874 
0875     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR1);
0876     rt2x00_set_field16(&reg, TXRX_CSR1_AUTO_SEQUENCE, 1);
0877     rt2500usb_register_write(rt2x00dev, TXRX_CSR1, reg);
0878 
0879     return 0;
0880 }
0881 
0882 static int rt2500usb_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
0883 {
0884     unsigned int i;
0885     u8 value;
0886 
0887     for (i = 0; i < REGISTER_USB_BUSY_COUNT; i++) {
0888         value = rt2500usb_bbp_read(rt2x00dev, 0);
0889         if ((value != 0xff) && (value != 0x00))
0890             return 0;
0891         udelay(REGISTER_BUSY_DELAY);
0892     }
0893 
0894     rt2x00_err(rt2x00dev, "BBP register access failed, aborting\n");
0895     return -EACCES;
0896 }
0897 
0898 static int rt2500usb_init_bbp(struct rt2x00_dev *rt2x00dev)
0899 {
0900     unsigned int i;
0901     u16 eeprom;
0902     u8 value;
0903     u8 reg_id;
0904 
0905     if (unlikely(rt2500usb_wait_bbp_ready(rt2x00dev)))
0906         return -EACCES;
0907 
0908     rt2500usb_bbp_write(rt2x00dev, 3, 0x02);
0909     rt2500usb_bbp_write(rt2x00dev, 4, 0x19);
0910     rt2500usb_bbp_write(rt2x00dev, 14, 0x1c);
0911     rt2500usb_bbp_write(rt2x00dev, 15, 0x30);
0912     rt2500usb_bbp_write(rt2x00dev, 16, 0xac);
0913     rt2500usb_bbp_write(rt2x00dev, 18, 0x18);
0914     rt2500usb_bbp_write(rt2x00dev, 19, 0xff);
0915     rt2500usb_bbp_write(rt2x00dev, 20, 0x1e);
0916     rt2500usb_bbp_write(rt2x00dev, 21, 0x08);
0917     rt2500usb_bbp_write(rt2x00dev, 22, 0x08);
0918     rt2500usb_bbp_write(rt2x00dev, 23, 0x08);
0919     rt2500usb_bbp_write(rt2x00dev, 24, 0x80);
0920     rt2500usb_bbp_write(rt2x00dev, 25, 0x50);
0921     rt2500usb_bbp_write(rt2x00dev, 26, 0x08);
0922     rt2500usb_bbp_write(rt2x00dev, 27, 0x23);
0923     rt2500usb_bbp_write(rt2x00dev, 30, 0x10);
0924     rt2500usb_bbp_write(rt2x00dev, 31, 0x2b);
0925     rt2500usb_bbp_write(rt2x00dev, 32, 0xb9);
0926     rt2500usb_bbp_write(rt2x00dev, 34, 0x12);
0927     rt2500usb_bbp_write(rt2x00dev, 35, 0x50);
0928     rt2500usb_bbp_write(rt2x00dev, 39, 0xc4);
0929     rt2500usb_bbp_write(rt2x00dev, 40, 0x02);
0930     rt2500usb_bbp_write(rt2x00dev, 41, 0x60);
0931     rt2500usb_bbp_write(rt2x00dev, 53, 0x10);
0932     rt2500usb_bbp_write(rt2x00dev, 54, 0x18);
0933     rt2500usb_bbp_write(rt2x00dev, 56, 0x08);
0934     rt2500usb_bbp_write(rt2x00dev, 57, 0x10);
0935     rt2500usb_bbp_write(rt2x00dev, 58, 0x08);
0936     rt2500usb_bbp_write(rt2x00dev, 61, 0x60);
0937     rt2500usb_bbp_write(rt2x00dev, 62, 0x10);
0938     rt2500usb_bbp_write(rt2x00dev, 75, 0xff);
0939 
0940     for (i = 0; i < EEPROM_BBP_SIZE; i++) {
0941         eeprom = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBP_START + i);
0942 
0943         if (eeprom != 0xffff && eeprom != 0x0000) {
0944             reg_id = rt2x00_get_field16(eeprom, EEPROM_BBP_REG_ID);
0945             value = rt2x00_get_field16(eeprom, EEPROM_BBP_VALUE);
0946             rt2500usb_bbp_write(rt2x00dev, reg_id, value);
0947         }
0948     }
0949 
0950     return 0;
0951 }
0952 
0953 /*
0954  * Device state switch handlers.
0955  */
0956 static int rt2500usb_enable_radio(struct rt2x00_dev *rt2x00dev)
0957 {
0958     /*
0959      * Initialize all registers.
0960      */
0961     if (unlikely(rt2500usb_init_registers(rt2x00dev) ||
0962              rt2500usb_init_bbp(rt2x00dev)))
0963         return -EIO;
0964 
0965     return 0;
0966 }
0967 
0968 static void rt2500usb_disable_radio(struct rt2x00_dev *rt2x00dev)
0969 {
0970     rt2500usb_register_write(rt2x00dev, MAC_CSR13, 0x2121);
0971     rt2500usb_register_write(rt2x00dev, MAC_CSR14, 0x2121);
0972 
0973     /*
0974      * Disable synchronisation.
0975      */
0976     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, 0);
0977 
0978     rt2x00usb_disable_radio(rt2x00dev);
0979 }
0980 
0981 static int rt2500usb_set_state(struct rt2x00_dev *rt2x00dev,
0982                    enum dev_state state)
0983 {
0984     u16 reg;
0985     u16 reg2;
0986     unsigned int i;
0987     char put_to_sleep;
0988     char bbp_state;
0989     char rf_state;
0990 
0991     put_to_sleep = (state != STATE_AWAKE);
0992 
0993     reg = 0;
0994     rt2x00_set_field16(&reg, MAC_CSR17_BBP_DESIRE_STATE, state);
0995     rt2x00_set_field16(&reg, MAC_CSR17_RF_DESIRE_STATE, state);
0996     rt2x00_set_field16(&reg, MAC_CSR17_PUT_TO_SLEEP, put_to_sleep);
0997     rt2500usb_register_write(rt2x00dev, MAC_CSR17, reg);
0998     rt2x00_set_field16(&reg, MAC_CSR17_SET_STATE, 1);
0999     rt2500usb_register_write(rt2x00dev, MAC_CSR17, reg);
1000 
1001     /*
1002      * Device is not guaranteed to be in the requested state yet.
1003      * We must wait until the register indicates that the
1004      * device has entered the correct state.
1005      */
1006     for (i = 0; i < REGISTER_USB_BUSY_COUNT; i++) {
1007         reg2 = rt2500usb_register_read(rt2x00dev, MAC_CSR17);
1008         bbp_state = rt2x00_get_field16(reg2, MAC_CSR17_BBP_CURR_STATE);
1009         rf_state = rt2x00_get_field16(reg2, MAC_CSR17_RF_CURR_STATE);
1010         if (bbp_state == state && rf_state == state)
1011             return 0;
1012         rt2500usb_register_write(rt2x00dev, MAC_CSR17, reg);
1013         msleep(30);
1014     }
1015 
1016     return -EBUSY;
1017 }
1018 
1019 static int rt2500usb_set_device_state(struct rt2x00_dev *rt2x00dev,
1020                       enum dev_state state)
1021 {
1022     int retval = 0;
1023 
1024     switch (state) {
1025     case STATE_RADIO_ON:
1026         retval = rt2500usb_enable_radio(rt2x00dev);
1027         break;
1028     case STATE_RADIO_OFF:
1029         rt2500usb_disable_radio(rt2x00dev);
1030         break;
1031     case STATE_RADIO_IRQ_ON:
1032     case STATE_RADIO_IRQ_OFF:
1033         /* No support, but no error either */
1034         break;
1035     case STATE_DEEP_SLEEP:
1036     case STATE_SLEEP:
1037     case STATE_STANDBY:
1038     case STATE_AWAKE:
1039         retval = rt2500usb_set_state(rt2x00dev, state);
1040         break;
1041     default:
1042         retval = -ENOTSUPP;
1043         break;
1044     }
1045 
1046     if (unlikely(retval))
1047         rt2x00_err(rt2x00dev, "Device failed to enter state %d (%d)\n",
1048                state, retval);
1049 
1050     return retval;
1051 }
1052 
1053 /*
1054  * TX descriptor initialization
1055  */
1056 static void rt2500usb_write_tx_desc(struct queue_entry *entry,
1057                     struct txentry_desc *txdesc)
1058 {
1059     struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
1060     __le32 *txd = (__le32 *) entry->skb->data;
1061     u32 word;
1062 
1063     /*
1064      * Start writing the descriptor words.
1065      */
1066     word = rt2x00_desc_read(txd, 0);
1067     rt2x00_set_field32(&word, TXD_W0_RETRY_LIMIT, txdesc->retry_limit);
1068     rt2x00_set_field32(&word, TXD_W0_MORE_FRAG,
1069                test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags));
1070     rt2x00_set_field32(&word, TXD_W0_ACK,
1071                test_bit(ENTRY_TXD_ACK, &txdesc->flags));
1072     rt2x00_set_field32(&word, TXD_W0_TIMESTAMP,
1073                test_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc->flags));
1074     rt2x00_set_field32(&word, TXD_W0_OFDM,
1075                (txdesc->rate_mode == RATE_MODE_OFDM));
1076     rt2x00_set_field32(&word, TXD_W0_NEW_SEQ,
1077                test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags));
1078     rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->u.plcp.ifs);
1079     rt2x00_set_field32(&word, TXD_W0_DATABYTE_COUNT, txdesc->length);
1080     rt2x00_set_field32(&word, TXD_W0_CIPHER, !!txdesc->cipher);
1081     rt2x00_set_field32(&word, TXD_W0_KEY_ID, txdesc->key_idx);
1082     rt2x00_desc_write(txd, 0, word);
1083 
1084     word = rt2x00_desc_read(txd, 1);
1085     rt2x00_set_field32(&word, TXD_W1_IV_OFFSET, txdesc->iv_offset);
1086     rt2x00_set_field32(&word, TXD_W1_AIFS, entry->queue->aifs);
1087     rt2x00_set_field32(&word, TXD_W1_CWMIN, entry->queue->cw_min);
1088     rt2x00_set_field32(&word, TXD_W1_CWMAX, entry->queue->cw_max);
1089     rt2x00_desc_write(txd, 1, word);
1090 
1091     word = rt2x00_desc_read(txd, 2);
1092     rt2x00_set_field32(&word, TXD_W2_PLCP_SIGNAL, txdesc->u.plcp.signal);
1093     rt2x00_set_field32(&word, TXD_W2_PLCP_SERVICE, txdesc->u.plcp.service);
1094     rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_LOW,
1095                txdesc->u.plcp.length_low);
1096     rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_HIGH,
1097                txdesc->u.plcp.length_high);
1098     rt2x00_desc_write(txd, 2, word);
1099 
1100     if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags)) {
1101         _rt2x00_desc_write(txd, 3, skbdesc->iv[0]);
1102         _rt2x00_desc_write(txd, 4, skbdesc->iv[1]);
1103     }
1104 
1105     /*
1106      * Register descriptor details in skb frame descriptor.
1107      */
1108     skbdesc->flags |= SKBDESC_DESC_IN_SKB;
1109     skbdesc->desc = txd;
1110     skbdesc->desc_len = TXD_DESC_SIZE;
1111 }
1112 
1113 /*
1114  * TX data initialization
1115  */
1116 static void rt2500usb_beacondone(struct urb *urb);
1117 
1118 static void rt2500usb_write_beacon(struct queue_entry *entry,
1119                    struct txentry_desc *txdesc)
1120 {
1121     struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
1122     struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
1123     struct queue_entry_priv_usb_bcn *bcn_priv = entry->priv_data;
1124     int pipe = usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint);
1125     int length;
1126     u16 reg, reg0;
1127 
1128     /*
1129      * Disable beaconing while we are reloading the beacon data,
1130      * otherwise we might be sending out invalid data.
1131      */
1132     reg = rt2500usb_register_read(rt2x00dev, TXRX_CSR19);
1133     rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 0);
1134     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
1135 
1136     /*
1137      * Add space for the descriptor in front of the skb.
1138      */
1139     skb_push(entry->skb, TXD_DESC_SIZE);
1140     memset(entry->skb->data, 0, TXD_DESC_SIZE);
1141 
1142     /*
1143      * Write the TX descriptor for the beacon.
1144      */
1145     rt2500usb_write_tx_desc(entry, txdesc);
1146 
1147     /*
1148      * Dump beacon to userspace through debugfs.
1149      */
1150     rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_BEACON, entry);
1151 
1152     /*
1153      * USB devices cannot blindly pass the skb->len as the
1154      * length of the data to usb_fill_bulk_urb. Pass the skb
1155      * to the driver to determine what the length should be.
1156      */
1157     length = rt2x00dev->ops->lib->get_tx_data_len(entry);
1158 
1159     usb_fill_bulk_urb(bcn_priv->urb, usb_dev, pipe,
1160               entry->skb->data, length, rt2500usb_beacondone,
1161               entry);
1162 
1163     /*
1164      * Second we need to create the guardian byte.
1165      * We only need a single byte, so lets recycle
1166      * the 'flags' field we are not using for beacons.
1167      */
1168     bcn_priv->guardian_data = 0;
1169     usb_fill_bulk_urb(bcn_priv->guardian_urb, usb_dev, pipe,
1170               &bcn_priv->guardian_data, 1, rt2500usb_beacondone,
1171               entry);
1172 
1173     /*
1174      * Send out the guardian byte.
1175      */
1176     usb_submit_urb(bcn_priv->guardian_urb, GFP_ATOMIC);
1177 
1178     /*
1179      * Enable beaconing again.
1180      */
1181     rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 1);
1182     rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 1);
1183     reg0 = reg;
1184     rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 1);
1185     /*
1186      * Beacon generation will fail initially.
1187      * To prevent this we need to change the TXRX_CSR19
1188      * register several times (reg0 is the same as reg
1189      * except for TXRX_CSR19_BEACON_GEN, which is 0 in reg0
1190      * and 1 in reg).
1191      */
1192     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
1193     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg0);
1194     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
1195     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg0);
1196     rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
1197 }
1198 
1199 static int rt2500usb_get_tx_data_len(struct queue_entry *entry)
1200 {
1201     int length;
1202 
1203     /*
1204      * The length _must_ be a multiple of 2,
1205      * but it must _not_ be a multiple of the USB packet size.
1206      */
1207     length = roundup(entry->skb->len, 2);
1208     length += (2 * !(length % entry->queue->usb_maxpacket));
1209 
1210     return length;
1211 }
1212 
1213 /*
1214  * RX control handlers
1215  */
1216 static void rt2500usb_fill_rxdone(struct queue_entry *entry,
1217                   struct rxdone_entry_desc *rxdesc)
1218 {
1219     struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
1220     struct queue_entry_priv_usb *entry_priv = entry->priv_data;
1221     struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
1222     __le32 *rxd =
1223         (__le32 *)(entry->skb->data +
1224                (entry_priv->urb->actual_length -
1225             entry->queue->desc_size));
1226     u32 word0;
1227     u32 word1;
1228 
1229     /*
1230      * Copy descriptor to the skbdesc->desc buffer, making it safe from moving of
1231      * frame data in rt2x00usb.
1232      */
1233     memcpy(skbdesc->desc, rxd, skbdesc->desc_len);
1234     rxd = (__le32 *)skbdesc->desc;
1235 
1236     /*
1237      * It is now safe to read the descriptor on all architectures.
1238      */
1239     word0 = rt2x00_desc_read(rxd, 0);
1240     word1 = rt2x00_desc_read(rxd, 1);
1241 
1242     if (rt2x00_get_field32(word0, RXD_W0_CRC_ERROR))
1243         rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC;
1244     if (rt2x00_get_field32(word0, RXD_W0_PHYSICAL_ERROR))
1245         rxdesc->flags |= RX_FLAG_FAILED_PLCP_CRC;
1246 
1247     rxdesc->cipher = rt2x00_get_field32(word0, RXD_W0_CIPHER);
1248     if (rt2x00_get_field32(word0, RXD_W0_CIPHER_ERROR))
1249         rxdesc->cipher_status = RX_CRYPTO_FAIL_KEY;
1250 
1251     if (rxdesc->cipher != CIPHER_NONE) {
1252         rxdesc->iv[0] = _rt2x00_desc_read(rxd, 2);
1253         rxdesc->iv[1] = _rt2x00_desc_read(rxd, 3);
1254         rxdesc->dev_flags |= RXDONE_CRYPTO_IV;
1255 
1256         /* ICV is located at the end of frame */
1257 
1258         rxdesc->flags |= RX_FLAG_MMIC_STRIPPED;
1259         if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS)
1260             rxdesc->flags |= RX_FLAG_DECRYPTED;
1261         else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC)
1262             rxdesc->flags |= RX_FLAG_MMIC_ERROR;
1263     }
1264 
1265     /*
1266      * Obtain the status about this packet.
1267      * When frame was received with an OFDM bitrate,
1268      * the signal is the PLCP value. If it was received with
1269      * a CCK bitrate the signal is the rate in 100kbit/s.
1270      */
1271     rxdesc->signal = rt2x00_get_field32(word1, RXD_W1_SIGNAL);
1272     rxdesc->rssi =
1273         rt2x00_get_field32(word1, RXD_W1_RSSI) - rt2x00dev->rssi_offset;
1274     rxdesc->size = rt2x00_get_field32(word0, RXD_W0_DATABYTE_COUNT);
1275 
1276     if (rt2x00_get_field32(word0, RXD_W0_OFDM))
1277         rxdesc->dev_flags |= RXDONE_SIGNAL_PLCP;
1278     else
1279         rxdesc->dev_flags |= RXDONE_SIGNAL_BITRATE;
1280     if (rt2x00_get_field32(word0, RXD_W0_MY_BSS))
1281         rxdesc->dev_flags |= RXDONE_MY_BSS;
1282 
1283     /*
1284      * Adjust the skb memory window to the frame boundaries.
1285      */
1286     skb_trim(entry->skb, rxdesc->size);
1287 }
1288 
1289 /*
1290  * Interrupt functions.
1291  */
1292 static void rt2500usb_beacondone(struct urb *urb)
1293 {
1294     struct queue_entry *entry = (struct queue_entry *)urb->context;
1295     struct queue_entry_priv_usb_bcn *bcn_priv = entry->priv_data;
1296 
1297     if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &entry->queue->rt2x00dev->flags))
1298         return;
1299 
1300     /*
1301      * Check if this was the guardian beacon,
1302      * if that was the case we need to send the real beacon now.
1303      * Otherwise we should free the sk_buffer, the device
1304      * should be doing the rest of the work now.
1305      */
1306     if (bcn_priv->guardian_urb == urb) {
1307         usb_submit_urb(bcn_priv->urb, GFP_ATOMIC);
1308     } else if (bcn_priv->urb == urb) {
1309         dev_kfree_skb(entry->skb);
1310         entry->skb = NULL;
1311     }
1312 }
1313 
1314 /*
1315  * Device probe functions.
1316  */
1317 static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
1318 {
1319     u16 word;
1320     u8 *mac;
1321     u8 bbp;
1322 
1323     rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom, EEPROM_SIZE);
1324 
1325     /*
1326      * Start validation of the data that has been read.
1327      */
1328     mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
1329     rt2x00lib_set_mac_address(rt2x00dev, mac);
1330 
1331     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA);
1332     if (word == 0xffff) {
1333         rt2x00_set_field16(&word, EEPROM_ANTENNA_NUM, 2);
1334         rt2x00_set_field16(&word, EEPROM_ANTENNA_TX_DEFAULT,
1335                    ANTENNA_SW_DIVERSITY);
1336         rt2x00_set_field16(&word, EEPROM_ANTENNA_RX_DEFAULT,
1337                    ANTENNA_SW_DIVERSITY);
1338         rt2x00_set_field16(&word, EEPROM_ANTENNA_LED_MODE,
1339                    LED_MODE_DEFAULT);
1340         rt2x00_set_field16(&word, EEPROM_ANTENNA_DYN_TXAGC, 0);
1341         rt2x00_set_field16(&word, EEPROM_ANTENNA_HARDWARE_RADIO, 0);
1342         rt2x00_set_field16(&word, EEPROM_ANTENNA_RF_TYPE, RF2522);
1343         rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word);
1344         rt2x00_eeprom_dbg(rt2x00dev, "Antenna: 0x%04x\n", word);
1345     }
1346 
1347     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC);
1348     if (word == 0xffff) {
1349         rt2x00_set_field16(&word, EEPROM_NIC_CARDBUS_ACCEL, 0);
1350         rt2x00_set_field16(&word, EEPROM_NIC_DYN_BBP_TUNE, 0);
1351         rt2x00_set_field16(&word, EEPROM_NIC_CCK_TX_POWER, 0);
1352         rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word);
1353         rt2x00_eeprom_dbg(rt2x00dev, "NIC: 0x%04x\n", word);
1354     }
1355 
1356     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_CALIBRATE_OFFSET);
1357     if (word == 0xffff) {
1358         rt2x00_set_field16(&word, EEPROM_CALIBRATE_OFFSET_RSSI,
1359                    DEFAULT_RSSI_OFFSET);
1360         rt2x00_eeprom_write(rt2x00dev, EEPROM_CALIBRATE_OFFSET, word);
1361         rt2x00_eeprom_dbg(rt2x00dev, "Calibrate offset: 0x%04x\n",
1362                   word);
1363     }
1364 
1365     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE);
1366     if (word == 0xffff) {
1367         rt2x00_set_field16(&word, EEPROM_BBPTUNE_THRESHOLD, 45);
1368         rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE, word);
1369         rt2x00_eeprom_dbg(rt2x00dev, "BBPtune: 0x%04x\n", word);
1370     }
1371 
1372     /*
1373      * Switch lower vgc bound to current BBP R17 value,
1374      * lower the value a bit for better quality.
1375      */
1376     bbp = rt2500usb_bbp_read(rt2x00dev, 17);
1377     bbp -= 6;
1378 
1379     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_VGC);
1380     if (word == 0xffff) {
1381         rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCUPPER, 0x40);
1382         rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCLOWER, bbp);
1383         rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_VGC, word);
1384         rt2x00_eeprom_dbg(rt2x00dev, "BBPtune vgc: 0x%04x\n", word);
1385     } else {
1386         rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCLOWER, bbp);
1387         rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_VGC, word);
1388     }
1389 
1390     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R17);
1391     if (word == 0xffff) {
1392         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R17_LOW, 0x48);
1393         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R17_HIGH, 0x41);
1394         rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R17, word);
1395         rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r17: 0x%04x\n", word);
1396     }
1397 
1398     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R24);
1399     if (word == 0xffff) {
1400         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R24_LOW, 0x40);
1401         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R24_HIGH, 0x80);
1402         rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R24, word);
1403         rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r24: 0x%04x\n", word);
1404     }
1405 
1406     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R25);
1407     if (word == 0xffff) {
1408         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R25_LOW, 0x40);
1409         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R25_HIGH, 0x50);
1410         rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R25, word);
1411         rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r25: 0x%04x\n", word);
1412     }
1413 
1414     word = rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R61);
1415     if (word == 0xffff) {
1416         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R61_LOW, 0x60);
1417         rt2x00_set_field16(&word, EEPROM_BBPTUNE_R61_HIGH, 0x6d);
1418         rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R61, word);
1419         rt2x00_eeprom_dbg(rt2x00dev, "BBPtune r61: 0x%04x\n", word);
1420     }
1421 
1422     return 0;
1423 }
1424 
1425 static int rt2500usb_init_eeprom(struct rt2x00_dev *rt2x00dev)
1426 {
1427     u16 reg;
1428     u16 value;
1429     u16 eeprom;
1430 
1431     /*
1432      * Read EEPROM word for configuration.
1433      */
1434     eeprom = rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA);
1435 
1436     /*
1437      * Identify RF chipset.
1438      */
1439     value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RF_TYPE);
1440     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR0);
1441     rt2x00_set_chip(rt2x00dev, RT2570, value, reg);
1442 
1443     if (((reg & 0xfff0) != 0) || ((reg & 0x0000000f) == 0)) {
1444         rt2x00_err(rt2x00dev, "Invalid RT chipset detected\n");
1445         return -ENODEV;
1446     }
1447 
1448     if (!rt2x00_rf(rt2x00dev, RF2522) &&
1449         !rt2x00_rf(rt2x00dev, RF2523) &&
1450         !rt2x00_rf(rt2x00dev, RF2524) &&
1451         !rt2x00_rf(rt2x00dev, RF2525) &&
1452         !rt2x00_rf(rt2x00dev, RF2525E) &&
1453         !rt2x00_rf(rt2x00dev, RF5222)) {
1454         rt2x00_err(rt2x00dev, "Invalid RF chipset detected\n");
1455         return -ENODEV;
1456     }
1457 
1458     /*
1459      * Identify default antenna configuration.
1460      */
1461     rt2x00dev->default_ant.tx =
1462         rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TX_DEFAULT);
1463     rt2x00dev->default_ant.rx =
1464         rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RX_DEFAULT);
1465 
1466     /*
1467      * When the eeprom indicates SW_DIVERSITY use HW_DIVERSITY instead.
1468      * I am not 100% sure about this, but the legacy drivers do not
1469      * indicate antenna swapping in software is required when
1470      * diversity is enabled.
1471      */
1472     if (rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
1473         rt2x00dev->default_ant.tx = ANTENNA_HW_DIVERSITY;
1474     if (rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
1475         rt2x00dev->default_ant.rx = ANTENNA_HW_DIVERSITY;
1476 
1477     /*
1478      * Store led mode, for correct led behaviour.
1479      */
1480 #ifdef CONFIG_RT2X00_LIB_LEDS
1481     value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_LED_MODE);
1482 
1483     rt2500usb_init_led(rt2x00dev, &rt2x00dev->led_radio, LED_TYPE_RADIO);
1484     if (value == LED_MODE_TXRX_ACTIVITY ||
1485         value == LED_MODE_DEFAULT ||
1486         value == LED_MODE_ASUS)
1487         rt2500usb_init_led(rt2x00dev, &rt2x00dev->led_qual,
1488                    LED_TYPE_ACTIVITY);
1489 #endif /* CONFIG_RT2X00_LIB_LEDS */
1490 
1491     /*
1492      * Detect if this device has an hardware controlled radio.
1493      */
1494     if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
1495         __set_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags);
1496 
1497     /*
1498      * Read the RSSI <-> dBm offset information.
1499      */
1500     eeprom = rt2x00_eeprom_read(rt2x00dev, EEPROM_CALIBRATE_OFFSET);
1501     rt2x00dev->rssi_offset =
1502         rt2x00_get_field16(eeprom, EEPROM_CALIBRATE_OFFSET_RSSI);
1503 
1504     return 0;
1505 }
1506 
1507 /*
1508  * RF value list for RF2522
1509  * Supports: 2.4 GHz
1510  */
1511 static const struct rf_channel rf_vals_bg_2522[] = {
1512     { 1,  0x00002050, 0x000c1fda, 0x00000101, 0 },
1513     { 2,  0x00002050, 0x000c1fee, 0x00000101, 0 },
1514     { 3,  0x00002050, 0x000c2002, 0x00000101, 0 },
1515     { 4,  0x00002050, 0x000c2016, 0x00000101, 0 },
1516     { 5,  0x00002050, 0x000c202a, 0x00000101, 0 },
1517     { 6,  0x00002050, 0x000c203e, 0x00000101, 0 },
1518     { 7,  0x00002050, 0x000c2052, 0x00000101, 0 },
1519     { 8,  0x00002050, 0x000c2066, 0x00000101, 0 },
1520     { 9,  0x00002050, 0x000c207a, 0x00000101, 0 },
1521     { 10, 0x00002050, 0x000c208e, 0x00000101, 0 },
1522     { 11, 0x00002050, 0x000c20a2, 0x00000101, 0 },
1523     { 12, 0x00002050, 0x000c20b6, 0x00000101, 0 },
1524     { 13, 0x00002050, 0x000c20ca, 0x00000101, 0 },
1525     { 14, 0x00002050, 0x000c20fa, 0x00000101, 0 },
1526 };
1527 
1528 /*
1529  * RF value list for RF2523
1530  * Supports: 2.4 GHz
1531  */
1532 static const struct rf_channel rf_vals_bg_2523[] = {
1533     { 1,  0x00022010, 0x00000c9e, 0x000e0111, 0x00000a1b },
1534     { 2,  0x00022010, 0x00000ca2, 0x000e0111, 0x00000a1b },
1535     { 3,  0x00022010, 0x00000ca6, 0x000e0111, 0x00000a1b },
1536     { 4,  0x00022010, 0x00000caa, 0x000e0111, 0x00000a1b },
1537     { 5,  0x00022010, 0x00000cae, 0x000e0111, 0x00000a1b },
1538     { 6,  0x00022010, 0x00000cb2, 0x000e0111, 0x00000a1b },
1539     { 7,  0x00022010, 0x00000cb6, 0x000e0111, 0x00000a1b },
1540     { 8,  0x00022010, 0x00000cba, 0x000e0111, 0x00000a1b },
1541     { 9,  0x00022010, 0x00000cbe, 0x000e0111, 0x00000a1b },
1542     { 10, 0x00022010, 0x00000d02, 0x000e0111, 0x00000a1b },
1543     { 11, 0x00022010, 0x00000d06, 0x000e0111, 0x00000a1b },
1544     { 12, 0x00022010, 0x00000d0a, 0x000e0111, 0x00000a1b },
1545     { 13, 0x00022010, 0x00000d0e, 0x000e0111, 0x00000a1b },
1546     { 14, 0x00022010, 0x00000d1a, 0x000e0111, 0x00000a03 },
1547 };
1548 
1549 /*
1550  * RF value list for RF2524
1551  * Supports: 2.4 GHz
1552  */
1553 static const struct rf_channel rf_vals_bg_2524[] = {
1554     { 1,  0x00032020, 0x00000c9e, 0x00000101, 0x00000a1b },
1555     { 2,  0x00032020, 0x00000ca2, 0x00000101, 0x00000a1b },
1556     { 3,  0x00032020, 0x00000ca6, 0x00000101, 0x00000a1b },
1557     { 4,  0x00032020, 0x00000caa, 0x00000101, 0x00000a1b },
1558     { 5,  0x00032020, 0x00000cae, 0x00000101, 0x00000a1b },
1559     { 6,  0x00032020, 0x00000cb2, 0x00000101, 0x00000a1b },
1560     { 7,  0x00032020, 0x00000cb6, 0x00000101, 0x00000a1b },
1561     { 8,  0x00032020, 0x00000cba, 0x00000101, 0x00000a1b },
1562     { 9,  0x00032020, 0x00000cbe, 0x00000101, 0x00000a1b },
1563     { 10, 0x00032020, 0x00000d02, 0x00000101, 0x00000a1b },
1564     { 11, 0x00032020, 0x00000d06, 0x00000101, 0x00000a1b },
1565     { 12, 0x00032020, 0x00000d0a, 0x00000101, 0x00000a1b },
1566     { 13, 0x00032020, 0x00000d0e, 0x00000101, 0x00000a1b },
1567     { 14, 0x00032020, 0x00000d1a, 0x00000101, 0x00000a03 },
1568 };
1569 
1570 /*
1571  * RF value list for RF2525
1572  * Supports: 2.4 GHz
1573  */
1574 static const struct rf_channel rf_vals_bg_2525[] = {
1575     { 1,  0x00022020, 0x00080c9e, 0x00060111, 0x00000a1b },
1576     { 2,  0x00022020, 0x00080ca2, 0x00060111, 0x00000a1b },
1577     { 3,  0x00022020, 0x00080ca6, 0x00060111, 0x00000a1b },
1578     { 4,  0x00022020, 0x00080caa, 0x00060111, 0x00000a1b },
1579     { 5,  0x00022020, 0x00080cae, 0x00060111, 0x00000a1b },
1580     { 6,  0x00022020, 0x00080cb2, 0x00060111, 0x00000a1b },
1581     { 7,  0x00022020, 0x00080cb6, 0x00060111, 0x00000a1b },
1582     { 8,  0x00022020, 0x00080cba, 0x00060111, 0x00000a1b },
1583     { 9,  0x00022020, 0x00080cbe, 0x00060111, 0x00000a1b },
1584     { 10, 0x00022020, 0x00080d02, 0x00060111, 0x00000a1b },
1585     { 11, 0x00022020, 0x00080d06, 0x00060111, 0x00000a1b },
1586     { 12, 0x00022020, 0x00080d0a, 0x00060111, 0x00000a1b },
1587     { 13, 0x00022020, 0x00080d0e, 0x00060111, 0x00000a1b },
1588     { 14, 0x00022020, 0x00080d1a, 0x00060111, 0x00000a03 },
1589 };
1590 
1591 /*
1592  * RF value list for RF2525e
1593  * Supports: 2.4 GHz
1594  */
1595 static const struct rf_channel rf_vals_bg_2525e[] = {
1596     { 1,  0x00022010, 0x0000089a, 0x00060111, 0x00000e1b },
1597     { 2,  0x00022010, 0x0000089e, 0x00060111, 0x00000e07 },
1598     { 3,  0x00022010, 0x0000089e, 0x00060111, 0x00000e1b },
1599     { 4,  0x00022010, 0x000008a2, 0x00060111, 0x00000e07 },
1600     { 5,  0x00022010, 0x000008a2, 0x00060111, 0x00000e1b },
1601     { 6,  0x00022010, 0x000008a6, 0x00060111, 0x00000e07 },
1602     { 7,  0x00022010, 0x000008a6, 0x00060111, 0x00000e1b },
1603     { 8,  0x00022010, 0x000008aa, 0x00060111, 0x00000e07 },
1604     { 9,  0x00022010, 0x000008aa, 0x00060111, 0x00000e1b },
1605     { 10, 0x00022010, 0x000008ae, 0x00060111, 0x00000e07 },
1606     { 11, 0x00022010, 0x000008ae, 0x00060111, 0x00000e1b },
1607     { 12, 0x00022010, 0x000008b2, 0x00060111, 0x00000e07 },
1608     { 13, 0x00022010, 0x000008b2, 0x00060111, 0x00000e1b },
1609     { 14, 0x00022010, 0x000008b6, 0x00060111, 0x00000e23 },
1610 };
1611 
1612 /*
1613  * RF value list for RF5222
1614  * Supports: 2.4 GHz & 5.2 GHz
1615  */
1616 static const struct rf_channel rf_vals_5222[] = {
1617     { 1,  0x00022020, 0x00001136, 0x00000101, 0x00000a0b },
1618     { 2,  0x00022020, 0x0000113a, 0x00000101, 0x00000a0b },
1619     { 3,  0x00022020, 0x0000113e, 0x00000101, 0x00000a0b },
1620     { 4,  0x00022020, 0x00001182, 0x00000101, 0x00000a0b },
1621     { 5,  0x00022020, 0x00001186, 0x00000101, 0x00000a0b },
1622     { 6,  0x00022020, 0x0000118a, 0x00000101, 0x00000a0b },
1623     { 7,  0x00022020, 0x0000118e, 0x00000101, 0x00000a0b },
1624     { 8,  0x00022020, 0x00001192, 0x00000101, 0x00000a0b },
1625     { 9,  0x00022020, 0x00001196, 0x00000101, 0x00000a0b },
1626     { 10, 0x00022020, 0x0000119a, 0x00000101, 0x00000a0b },
1627     { 11, 0x00022020, 0x0000119e, 0x00000101, 0x00000a0b },
1628     { 12, 0x00022020, 0x000011a2, 0x00000101, 0x00000a0b },
1629     { 13, 0x00022020, 0x000011a6, 0x00000101, 0x00000a0b },
1630     { 14, 0x00022020, 0x000011ae, 0x00000101, 0x00000a1b },
1631 
1632     /* 802.11 UNI / HyperLan 2 */
1633     { 36, 0x00022010, 0x00018896, 0x00000101, 0x00000a1f },
1634     { 40, 0x00022010, 0x0001889a, 0x00000101, 0x00000a1f },
1635     { 44, 0x00022010, 0x0001889e, 0x00000101, 0x00000a1f },
1636     { 48, 0x00022010, 0x000188a2, 0x00000101, 0x00000a1f },
1637     { 52, 0x00022010, 0x000188a6, 0x00000101, 0x00000a1f },
1638     { 66, 0x00022010, 0x000188aa, 0x00000101, 0x00000a1f },
1639     { 60, 0x00022010, 0x000188ae, 0x00000101, 0x00000a1f },
1640     { 64, 0x00022010, 0x000188b2, 0x00000101, 0x00000a1f },
1641 
1642     /* 802.11 HyperLan 2 */
1643     { 100, 0x00022010, 0x00008802, 0x00000101, 0x00000a0f },
1644     { 104, 0x00022010, 0x00008806, 0x00000101, 0x00000a0f },
1645     { 108, 0x00022010, 0x0000880a, 0x00000101, 0x00000a0f },
1646     { 112, 0x00022010, 0x0000880e, 0x00000101, 0x00000a0f },
1647     { 116, 0x00022010, 0x00008812, 0x00000101, 0x00000a0f },
1648     { 120, 0x00022010, 0x00008816, 0x00000101, 0x00000a0f },
1649     { 124, 0x00022010, 0x0000881a, 0x00000101, 0x00000a0f },
1650     { 128, 0x00022010, 0x0000881e, 0x00000101, 0x00000a0f },
1651     { 132, 0x00022010, 0x00008822, 0x00000101, 0x00000a0f },
1652     { 136, 0x00022010, 0x00008826, 0x00000101, 0x00000a0f },
1653 
1654     /* 802.11 UNII */
1655     { 140, 0x00022010, 0x0000882a, 0x00000101, 0x00000a0f },
1656     { 149, 0x00022020, 0x000090a6, 0x00000101, 0x00000a07 },
1657     { 153, 0x00022020, 0x000090ae, 0x00000101, 0x00000a07 },
1658     { 157, 0x00022020, 0x000090b6, 0x00000101, 0x00000a07 },
1659     { 161, 0x00022020, 0x000090be, 0x00000101, 0x00000a07 },
1660 };
1661 
1662 static int rt2500usb_probe_hw_mode(struct rt2x00_dev *rt2x00dev)
1663 {
1664     struct hw_mode_spec *spec = &rt2x00dev->spec;
1665     struct channel_info *info;
1666     char *tx_power;
1667     unsigned int i;
1668 
1669     /*
1670      * Initialize all hw fields.
1671      *
1672      * Don't set IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING unless we are
1673      * capable of sending the buffered frames out after the DTIM
1674      * transmission using rt2x00lib_beacondone. This will send out
1675      * multicast and broadcast traffic immediately instead of buffering it
1676      * infinitly and thus dropping it after some time.
1677      */
1678     ieee80211_hw_set(rt2x00dev->hw, PS_NULLFUNC_STACK);
1679     ieee80211_hw_set(rt2x00dev->hw, SUPPORTS_PS);
1680     ieee80211_hw_set(rt2x00dev->hw, RX_INCLUDES_FCS);
1681     ieee80211_hw_set(rt2x00dev->hw, SIGNAL_DBM);
1682 
1683     /*
1684      * Disable powersaving as default.
1685      */
1686     rt2x00dev->hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
1687 
1688     SET_IEEE80211_DEV(rt2x00dev->hw, rt2x00dev->dev);
1689     SET_IEEE80211_PERM_ADDR(rt2x00dev->hw,
1690                 rt2x00_eeprom_addr(rt2x00dev,
1691                            EEPROM_MAC_ADDR_0));
1692 
1693     /*
1694      * Initialize hw_mode information.
1695      */
1696     spec->supported_bands = SUPPORT_BAND_2GHZ;
1697     spec->supported_rates = SUPPORT_RATE_CCK | SUPPORT_RATE_OFDM;
1698 
1699     if (rt2x00_rf(rt2x00dev, RF2522)) {
1700         spec->num_channels = ARRAY_SIZE(rf_vals_bg_2522);
1701         spec->channels = rf_vals_bg_2522;
1702     } else if (rt2x00_rf(rt2x00dev, RF2523)) {
1703         spec->num_channels = ARRAY_SIZE(rf_vals_bg_2523);
1704         spec->channels = rf_vals_bg_2523;
1705     } else if (rt2x00_rf(rt2x00dev, RF2524)) {
1706         spec->num_channels = ARRAY_SIZE(rf_vals_bg_2524);
1707         spec->channels = rf_vals_bg_2524;
1708     } else if (rt2x00_rf(rt2x00dev, RF2525)) {
1709         spec->num_channels = ARRAY_SIZE(rf_vals_bg_2525);
1710         spec->channels = rf_vals_bg_2525;
1711     } else if (rt2x00_rf(rt2x00dev, RF2525E)) {
1712         spec->num_channels = ARRAY_SIZE(rf_vals_bg_2525e);
1713         spec->channels = rf_vals_bg_2525e;
1714     } else if (rt2x00_rf(rt2x00dev, RF5222)) {
1715         spec->supported_bands |= SUPPORT_BAND_5GHZ;
1716         spec->num_channels = ARRAY_SIZE(rf_vals_5222);
1717         spec->channels = rf_vals_5222;
1718     }
1719 
1720     /*
1721      * Create channel information array
1722      */
1723     info = kcalloc(spec->num_channels, sizeof(*info), GFP_KERNEL);
1724     if (!info)
1725         return -ENOMEM;
1726 
1727     spec->channels_info = info;
1728 
1729     tx_power = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_START);
1730     for (i = 0; i < 14; i++) {
1731         info[i].max_power = MAX_TXPOWER;
1732         info[i].default_power1 = TXPOWER_FROM_DEV(tx_power[i]);
1733     }
1734 
1735     if (spec->num_channels > 14) {
1736         for (i = 14; i < spec->num_channels; i++) {
1737             info[i].max_power = MAX_TXPOWER;
1738             info[i].default_power1 = DEFAULT_TXPOWER;
1739         }
1740     }
1741 
1742     return 0;
1743 }
1744 
1745 static int rt2500usb_probe_hw(struct rt2x00_dev *rt2x00dev)
1746 {
1747     int retval;
1748     u16 reg;
1749 
1750     /*
1751      * Allocate eeprom data.
1752      */
1753     retval = rt2500usb_validate_eeprom(rt2x00dev);
1754     if (retval)
1755         return retval;
1756 
1757     retval = rt2500usb_init_eeprom(rt2x00dev);
1758     if (retval)
1759         return retval;
1760 
1761     /*
1762      * Enable rfkill polling by setting GPIO direction of the
1763      * rfkill switch GPIO pin correctly.
1764      */
1765     reg = rt2500usb_register_read(rt2x00dev, MAC_CSR19);
1766     rt2x00_set_field16(&reg, MAC_CSR19_DIR0, 0);
1767     rt2500usb_register_write(rt2x00dev, MAC_CSR19, reg);
1768 
1769     /*
1770      * Initialize hw specifications.
1771      */
1772     retval = rt2500usb_probe_hw_mode(rt2x00dev);
1773     if (retval)
1774         return retval;
1775 
1776     /*
1777      * This device requires the atim queue
1778      */
1779     __set_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags);
1780     __set_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags);
1781     if (!modparam_nohwcrypt) {
1782         __set_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags);
1783         __set_bit(REQUIRE_COPY_IV, &rt2x00dev->cap_flags);
1784     }
1785     __set_bit(REQUIRE_SW_SEQNO, &rt2x00dev->cap_flags);
1786     __set_bit(REQUIRE_PS_AUTOWAKE, &rt2x00dev->cap_flags);
1787 
1788     /*
1789      * Set the rssi offset.
1790      */
1791     rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET;
1792 
1793     return 0;
1794 }
1795 
1796 static const struct ieee80211_ops rt2500usb_mac80211_ops = {
1797     .tx         = rt2x00mac_tx,
1798     .start          = rt2x00mac_start,
1799     .stop           = rt2x00mac_stop,
1800     .add_interface      = rt2x00mac_add_interface,
1801     .remove_interface   = rt2x00mac_remove_interface,
1802     .config         = rt2x00mac_config,
1803     .configure_filter   = rt2x00mac_configure_filter,
1804     .set_tim        = rt2x00mac_set_tim,
1805     .set_key        = rt2x00mac_set_key,
1806     .sw_scan_start      = rt2x00mac_sw_scan_start,
1807     .sw_scan_complete   = rt2x00mac_sw_scan_complete,
1808     .get_stats      = rt2x00mac_get_stats,
1809     .bss_info_changed   = rt2x00mac_bss_info_changed,
1810     .conf_tx        = rt2x00mac_conf_tx,
1811     .rfkill_poll        = rt2x00mac_rfkill_poll,
1812     .flush          = rt2x00mac_flush,
1813     .set_antenna        = rt2x00mac_set_antenna,
1814     .get_antenna        = rt2x00mac_get_antenna,
1815     .get_ringparam      = rt2x00mac_get_ringparam,
1816     .tx_frames_pending  = rt2x00mac_tx_frames_pending,
1817 };
1818 
1819 static const struct rt2x00lib_ops rt2500usb_rt2x00_ops = {
1820     .probe_hw       = rt2500usb_probe_hw,
1821     .initialize     = rt2x00usb_initialize,
1822     .uninitialize       = rt2x00usb_uninitialize,
1823     .clear_entry        = rt2x00usb_clear_entry,
1824     .set_device_state   = rt2500usb_set_device_state,
1825     .rfkill_poll        = rt2500usb_rfkill_poll,
1826     .link_stats     = rt2500usb_link_stats,
1827     .reset_tuner        = rt2500usb_reset_tuner,
1828     .watchdog       = rt2x00usb_watchdog,
1829     .start_queue        = rt2500usb_start_queue,
1830     .kick_queue     = rt2x00usb_kick_queue,
1831     .stop_queue     = rt2500usb_stop_queue,
1832     .flush_queue        = rt2x00usb_flush_queue,
1833     .write_tx_desc      = rt2500usb_write_tx_desc,
1834     .write_beacon       = rt2500usb_write_beacon,
1835     .get_tx_data_len    = rt2500usb_get_tx_data_len,
1836     .fill_rxdone        = rt2500usb_fill_rxdone,
1837     .config_shared_key  = rt2500usb_config_key,
1838     .config_pairwise_key    = rt2500usb_config_key,
1839     .config_filter      = rt2500usb_config_filter,
1840     .config_intf        = rt2500usb_config_intf,
1841     .config_erp     = rt2500usb_config_erp,
1842     .config_ant     = rt2500usb_config_ant,
1843     .config         = rt2500usb_config,
1844 };
1845 
1846 static void rt2500usb_queue_init(struct data_queue *queue)
1847 {
1848     switch (queue->qid) {
1849     case QID_RX:
1850         queue->limit = 32;
1851         queue->data_size = DATA_FRAME_SIZE;
1852         queue->desc_size = RXD_DESC_SIZE;
1853         queue->priv_size = sizeof(struct queue_entry_priv_usb);
1854         break;
1855 
1856     case QID_AC_VO:
1857     case QID_AC_VI:
1858     case QID_AC_BE:
1859     case QID_AC_BK:
1860         queue->limit = 32;
1861         queue->data_size = DATA_FRAME_SIZE;
1862         queue->desc_size = TXD_DESC_SIZE;
1863         queue->priv_size = sizeof(struct queue_entry_priv_usb);
1864         break;
1865 
1866     case QID_BEACON:
1867         queue->limit = 1;
1868         queue->data_size = MGMT_FRAME_SIZE;
1869         queue->desc_size = TXD_DESC_SIZE;
1870         queue->priv_size = sizeof(struct queue_entry_priv_usb_bcn);
1871         break;
1872 
1873     case QID_ATIM:
1874         queue->limit = 8;
1875         queue->data_size = DATA_FRAME_SIZE;
1876         queue->desc_size = TXD_DESC_SIZE;
1877         queue->priv_size = sizeof(struct queue_entry_priv_usb);
1878         break;
1879 
1880     default:
1881         BUG();
1882         break;
1883     }
1884 }
1885 
1886 static const struct rt2x00_ops rt2500usb_ops = {
1887     .name           = KBUILD_MODNAME,
1888     .max_ap_intf        = 1,
1889     .eeprom_size        = EEPROM_SIZE,
1890     .rf_size        = RF_SIZE,
1891     .tx_queues      = NUM_TX_QUEUES,
1892     .queue_init     = rt2500usb_queue_init,
1893     .lib            = &rt2500usb_rt2x00_ops,
1894     .hw         = &rt2500usb_mac80211_ops,
1895 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
1896     .debugfs        = &rt2500usb_rt2x00debug,
1897 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
1898 };
1899 
1900 /*
1901  * rt2500usb module information.
1902  */
1903 static const struct usb_device_id rt2500usb_device_table[] = {
1904     /* ASUS */
1905     { USB_DEVICE(0x0b05, 0x1706) },
1906     { USB_DEVICE(0x0b05, 0x1707) },
1907     /* Belkin */
1908     { USB_DEVICE(0x050d, 0x7050) }, /* FCC ID: K7SF5D7050A ver. 2.x */
1909     { USB_DEVICE(0x050d, 0x7051) },
1910     /* Cisco Systems */
1911     { USB_DEVICE(0x13b1, 0x000d) },
1912     { USB_DEVICE(0x13b1, 0x0011) },
1913     { USB_DEVICE(0x13b1, 0x001a) },
1914     /* Conceptronic */
1915     { USB_DEVICE(0x14b2, 0x3c02) },
1916     /* D-LINK */
1917     { USB_DEVICE(0x2001, 0x3c00) },
1918     /* Gigabyte */
1919     { USB_DEVICE(0x1044, 0x8001) },
1920     { USB_DEVICE(0x1044, 0x8007) },
1921     /* Hercules */
1922     { USB_DEVICE(0x06f8, 0xe000) },
1923     /* Melco */
1924     { USB_DEVICE(0x0411, 0x005e) },
1925     { USB_DEVICE(0x0411, 0x0066) },
1926     { USB_DEVICE(0x0411, 0x0067) },
1927     { USB_DEVICE(0x0411, 0x008b) },
1928     { USB_DEVICE(0x0411, 0x0097) },
1929     /* MSI */
1930     { USB_DEVICE(0x0db0, 0x6861) },
1931     { USB_DEVICE(0x0db0, 0x6865) },
1932     { USB_DEVICE(0x0db0, 0x6869) },
1933     /* Ralink */
1934     { USB_DEVICE(0x148f, 0x1706) },
1935     { USB_DEVICE(0x148f, 0x2570) },
1936     { USB_DEVICE(0x148f, 0x9020) },
1937     /* Sagem */
1938     { USB_DEVICE(0x079b, 0x004b) },
1939     /* Siemens */
1940     { USB_DEVICE(0x0681, 0x3c06) },
1941     /* SMC */
1942     { USB_DEVICE(0x0707, 0xee13) },
1943     /* Spairon */
1944     { USB_DEVICE(0x114b, 0x0110) },
1945     /* SURECOM */
1946     { USB_DEVICE(0x0769, 0x11f3) },
1947     /* Trust */
1948     { USB_DEVICE(0x0eb0, 0x9020) },
1949     /* VTech */
1950     { USB_DEVICE(0x0f88, 0x3012) },
1951     /* Zinwell */
1952     { USB_DEVICE(0x5a57, 0x0260) },
1953     { 0, }
1954 };
1955 
1956 MODULE_AUTHOR(DRV_PROJECT);
1957 MODULE_VERSION(DRV_VERSION);
1958 MODULE_DESCRIPTION("Ralink RT2500 USB Wireless LAN driver.");
1959 MODULE_DEVICE_TABLE(usb, rt2500usb_device_table);
1960 MODULE_LICENSE("GPL");
1961 
1962 static int rt2500usb_probe(struct usb_interface *usb_intf,
1963                const struct usb_device_id *id)
1964 {
1965     return rt2x00usb_probe(usb_intf, &rt2500usb_ops);
1966 }
1967 
1968 static struct usb_driver rt2500usb_driver = {
1969     .name       = KBUILD_MODNAME,
1970     .id_table   = rt2500usb_device_table,
1971     .probe      = rt2500usb_probe,
1972     .disconnect = rt2x00usb_disconnect,
1973     .suspend    = rt2x00usb_suspend,
1974     .resume     = rt2x00usb_resume,
1975     .reset_resume   = rt2x00usb_resume,
1976     .disable_hub_initiated_lpm = 1,
1977 };
1978 
1979 module_usb_driver(rt2500usb_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!