source: trunk/package/mac80211/patches/302-rt2x00-Implement-support-for-rt2800pci.patch @ 13961

Last change on this file since 13961 was 13961, checked in by juhosg, 7 years ago

[package] mac80211: update compat-wireless to 2009-01-10

File size: 146.6 KB
  • drivers/net/wireless/rt2x00/Makefile

    From dda25991ee4dc0a2ebe2e3b50857971fe1d878c4 Mon Sep 17 00:00:00 2001
    From: Ivo van Doorn <IvDoorn@gmail.com>
    Date: Sat, 10 Jan 2009 11:03:23 +0100
    Subject: [PATCH] rt2x00: Implement support for rt2800pci
    
    Add support for the rt2800pci chipset.
    
    Includes various patches from Mattias, Mark and Felix.
    
    Signed-off-by: Mattias Nissler <mattias.nissler@gmx.de>
    Signed-off-by: Mark Asselstine <asselsm@gmail.com>
    Signed-off-by: Felix Fietkau <nbd@openwrt.org>
    Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
    ---
     drivers/net/wireless/rt2x00/Kconfig     |   15 +
     drivers/net/wireless/rt2x00/Makefile    |    1 +
     drivers/net/wireless/rt2x00/rt2800pci.c | 2707 +++++++++++++++++++++++++++++++
     drivers/net/wireless/rt2x00/rt2800pci.h | 1879 +++++++++++++++++++++
     drivers/net/wireless/rt2x00/rt2x00.h    |    4 +
     5 files changed, 4606 insertions(+), 0 deletions(-)
     create mode 100644 drivers/net/wireless/rt2x00/rt2800pci.c
     create mode 100644 drivers/net/wireless/rt2x00/rt2800pci.h
    a b obj-$(CONFIG_RT2X00_LIB_USB) += rt2x00u 
    1616obj-$(CONFIG_RT2400PCI)                 += rt2400pci.o 
    1717obj-$(CONFIG_RT2500PCI)                 += rt2500pci.o 
    1818obj-$(CONFIG_RT61PCI)                   += rt61pci.o 
     19obj-$(CONFIG_RT2800PCI)                 += rt2800pci.o 
    1920obj-$(CONFIG_RT2500USB)                 += rt2500usb.o 
    2021obj-$(CONFIG_RT73USB)                   += rt73usb.o 
  • new file drivers/net/wireless/rt2x00/rt2800pci.c

    - +  
     1/* 
     2        Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     3        <http://rt2x00.serialmonkey.com> 
     4 
     5        This program is free software; you can redistribute it and/or modify 
     6        it under the terms of the GNU General Public License as published by 
     7        the Free Software Foundation; either version 2 of the License, or 
     8        (at your option) any later version. 
     9 
     10        This program is distributed in the hope that it will be useful, 
     11        but WITHOUT ANY WARRANTY; without even the implied warranty of 
     12        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
     13        GNU General Public License for more details. 
     14 
     15        You should have received a copy of the GNU General Public License 
     16        along with this program; if not, write to the 
     17        Free Software Foundation, Inc., 
     18        59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
     19 */ 
     20 
     21/* 
     22        Module: rt2800pci 
     23        Abstract: rt2800pci device specific routines. 
     24        Supported chipsets: RT2800E & RT2800ED. 
     25 */ 
     26 
     27#include <linux/crc-ccitt.h> 
     28#include <linux/delay.h> 
     29#include <linux/etherdevice.h> 
     30#include <linux/init.h> 
     31#include <linux/kernel.h> 
     32#include <linux/module.h> 
     33#include <linux/pci.h> 
     34#include <linux/eeprom_93cx6.h> 
     35 
     36#include "rt2x00.h" 
     37#include "rt2x00pci.h" 
     38#include "rt2800pci.h" 
     39 
     40/* 
     41 * Allow hardware encryption to be disabled. 
     42 */ 
     43static int modparam_nohwcrypt = 0; 
     44module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO); 
     45MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption."); 
     46 
     47/* 
     48 * Register access. 
     49 * BBP and RF register require indirect register access, 
     50 * and use the CSR registers PHY_CSR3 and PHY_CSR4 to achieve this. 
     51 * These indirect registers work with busy bits, 
     52 * and we will try maximal REGISTER_BUSY_COUNT times to access 
     53 * the register while taking a REGISTER_BUSY_DELAY us delay 
     54 * between each attampt. When the busy bit is still set at that time, 
     55 * the access attempt is considered to have failed, 
     56 * and we will print an error. 
     57 */ 
     58#define WAIT_FOR_BBP(__dev, __reg) \ 
     59        rt2x00pci_regbusy_read((__dev), BBP_CSR_CFG, BBP_CSR_CFG_BUSY, (__reg)) 
     60#define WAIT_FOR_RF(__dev, __reg) \ 
     61        rt2x00pci_regbusy_read((__dev), RF_CSR_CFG0, RF_CSR_CFG0_BUSY, (__reg)) 
     62#define WAIT_FOR_MCU(__dev, __reg) \ 
     63        rt2x00pci_regbusy_read((__dev), H2M_MAILBOX_CSR, \ 
     64                               H2M_MAILBOX_CSR_OWNER, (__reg)) 
     65 
     66static void rt2800pci_bbp_write(struct rt2x00_dev *rt2x00dev, 
     67                                const unsigned int word, const u8 value) 
     68{ 
     69        u32 reg; 
     70 
     71        mutex_lock(&rt2x00dev->csr_mutex); 
     72 
     73        /* 
     74         * Wait until the BBP becomes available, afterwards we 
     75         * can safely write the new data into the register. 
     76         */ 
     77        if (WAIT_FOR_BBP(rt2x00dev, &reg)) { 
     78                reg = 0; 
     79                rt2x00_set_field32(&reg, BBP_CSR_CFG_VALUE, value); 
     80                rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
     81                rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
     82                rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 0); 
     83                rt2x00_set_field32(&reg, BBP_CSR_CFG_BBP_RW_MODE, 1); 
     84 
     85                rt2x00pci_register_write(rt2x00dev, BBP_CSR_CFG, reg); 
     86        } 
     87 
     88        mutex_unlock(&rt2x00dev->csr_mutex); 
     89} 
     90 
     91static void rt2800pci_bbp_read(struct rt2x00_dev *rt2x00dev, 
     92                               const unsigned int word, u8 *value) 
     93{ 
     94        u32 reg; 
     95 
     96        mutex_lock(&rt2x00dev->csr_mutex); 
     97 
     98        /* 
     99         * Wait until the BBP becomes available, afterwards we 
     100         * can safely write the read request into the register. 
     101         * After the data has been written, we wait until hardware 
     102         * returns the correct value, if at any time the register 
     103         * doesn't become available in time, reg will be 0xffffffff 
     104         * which means we return 0xff to the caller. 
     105         */ 
     106        if (WAIT_FOR_BBP(rt2x00dev, &reg)) { 
     107                reg = 0; 
     108                rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
     109                rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
     110                rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 1); 
     111                rt2x00_set_field32(&reg, BBP_CSR_CFG_BBP_RW_MODE, 1); 
     112 
     113                rt2x00pci_register_write(rt2x00dev, BBP_CSR_CFG, reg); 
     114 
     115                WAIT_FOR_BBP(rt2x00dev, &reg); 
     116        } 
     117 
     118        *value = rt2x00_get_field32(reg, BBP_CSR_CFG_VALUE); 
     119 
     120        mutex_unlock(&rt2x00dev->csr_mutex); 
     121} 
     122 
     123static void rt2800pci_rf_write(struct rt2x00_dev *rt2x00dev, 
     124                               const unsigned int word, const u32 value) 
     125{ 
     126        u32 reg; 
     127 
     128        if (!word) 
     129                return; 
     130 
     131        mutex_lock(&rt2x00dev->csr_mutex); 
     132 
     133        /* 
     134         * Wait until the RF becomes available, afterwards we 
     135         * can safely write the new data into the register. 
     136         */ 
     137        if (WAIT_FOR_RF(rt2x00dev, &reg)) { 
     138                reg = 0; 
     139                rt2x00_set_field32(&reg, RF_CSR_CFG0_REG_VALUE_BW, value); 
     140                rt2x00_set_field32(&reg, RF_CSR_CFG0_STANDBYMODE, 0); 
     141                rt2x00_set_field32(&reg, RF_CSR_CFG0_SEL, 0); 
     142                rt2x00_set_field32(&reg, RF_CSR_CFG0_BUSY, 1); 
     143 
     144                rt2x00pci_register_write(rt2x00dev, RF_CSR_CFG0, reg); 
     145                rt2x00_rf_write(rt2x00dev, word, value); 
     146        } 
     147 
     148        mutex_unlock(&rt2x00dev->csr_mutex); 
     149} 
     150 
     151static void rt2800pci_mcu_request(struct rt2x00_dev *rt2x00dev, 
     152                                  const u8 command, const u8 token, 
     153                                  const u8 arg0, const u8 arg1) 
     154{ 
     155        u32 reg; 
     156 
     157        mutex_lock(&rt2x00dev->csr_mutex); 
     158 
     159        /* 
     160         * Wait until the MCU becomes available, afterwards we 
     161         * can safely write the new data into the register. 
     162         */ 
     163        if (WAIT_FOR_MCU(rt2x00dev, &reg)) { 
     164                rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_OWNER, 1); 
     165                rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_CMD_TOKEN, token); 
     166                rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG0, arg0); 
     167                rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG1, arg1); 
     168                rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CSR, reg); 
     169 
     170                reg = 0; 
     171                rt2x00_set_field32(&reg, HOST_CMD_CSR_HOST_COMMAND, command); 
     172                rt2x00pci_register_write(rt2x00dev, HOST_CMD_CSR, reg); 
     173        } 
     174 
     175        mutex_unlock(&rt2x00dev->csr_mutex); 
     176} 
     177 
     178static void rt2800pci_eepromregister_read(struct eeprom_93cx6 *eeprom) 
     179{ 
     180        struct rt2x00_dev *rt2x00dev = eeprom->data; 
     181        u32 reg; 
     182 
     183        rt2x00pci_register_read(rt2x00dev, E2PROM_CSR, &reg); 
     184 
     185        eeprom->reg_data_in = !!rt2x00_get_field32(reg, E2PROM_CSR_DATA_IN); 
     186        eeprom->reg_data_out = !!rt2x00_get_field32(reg, E2PROM_CSR_DATA_OUT); 
     187        eeprom->reg_data_clock = 
     188            !!rt2x00_get_field32(reg, E2PROM_CSR_DATA_CLOCK); 
     189        eeprom->reg_chip_select = 
     190            !!rt2x00_get_field32(reg, E2PROM_CSR_CHIP_SELECT); 
     191} 
     192 
     193static void rt2800pci_eepromregister_write(struct eeprom_93cx6 *eeprom) 
     194{ 
     195        struct rt2x00_dev *rt2x00dev = eeprom->data; 
     196        u32 reg = 0; 
     197 
     198        rt2x00_set_field32(&reg, E2PROM_CSR_DATA_IN, !!eeprom->reg_data_in); 
     199        rt2x00_set_field32(&reg, E2PROM_CSR_DATA_OUT, !!eeprom->reg_data_out); 
     200        rt2x00_set_field32(&reg, E2PROM_CSR_DATA_CLOCK, 
     201                           !!eeprom->reg_data_clock); 
     202        rt2x00_set_field32(&reg, E2PROM_CSR_CHIP_SELECT, 
     203                           !!eeprom->reg_chip_select); 
     204 
     205        rt2x00pci_register_write(rt2x00dev, E2PROM_CSR, reg); 
     206} 
     207 
     208#ifdef CONFIG_RT2X00_LIB_DEBUGFS 
     209static const struct rt2x00debug rt2800pci_rt2x00debug = { 
     210        .owner  = THIS_MODULE, 
     211        .csr    = { 
     212                .read           = rt2x00pci_register_read, 
     213                .write          = rt2x00pci_register_write, 
     214                .flags          = RT2X00DEBUGFS_OFFSET, 
     215                .word_base      = CSR_REG_BASE, 
     216                .word_size      = sizeof(u32), 
     217                .word_count     = CSR_REG_SIZE / sizeof(u32), 
     218        }, 
     219        .eeprom = { 
     220                .read           = rt2x00_eeprom_read, 
     221                .write          = rt2x00_eeprom_write, 
     222                .word_base      = EEPROM_BASE, 
     223                .word_size      = sizeof(u16), 
     224                .word_count     = EEPROM_SIZE / sizeof(u16), 
     225        }, 
     226        .bbp    = { 
     227                .read           = rt2800pci_bbp_read, 
     228                .write          = rt2800pci_bbp_write, 
     229                .word_base      = BBP_BASE, 
     230                .word_size      = sizeof(u8), 
     231                .word_count     = BBP_SIZE / sizeof(u8), 
     232        }, 
     233        .rf     = { 
     234                .read           = rt2x00_rf_read, 
     235                .write          = rt2800pci_rf_write, 
     236                .word_base      = RF_BASE, 
     237                .word_size      = sizeof(u32), 
     238                .word_count     = RF_SIZE / sizeof(u32), 
     239        }, 
     240}; 
     241#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 
     242 
     243#ifdef CONFIG_RT2X00_LIB_RFKILL 
     244static int rt2800pci_rfkill_poll(struct rt2x00_dev *rt2x00dev) 
     245{ 
     246        u32 reg; 
     247 
     248        rt2x00pci_register_read(rt2x00dev, GPIO_CTRL_CFG, &reg); 
     249        return rt2x00_get_field32(reg, GPIO_CTRL_CFG_BIT2); 
     250} 
     251#else 
     252#define rt2800pci_rfkill_poll   NULL 
     253#endif /* CONFIG_RT2X00_LIB_RFKILL */ 
     254 
     255#ifdef CONFIG_RT2X00_LIB_LEDS 
     256static void rt2800pci_brightness_set(struct led_classdev *led_cdev, 
     257                                     enum led_brightness brightness) 
     258{ 
     259        struct rt2x00_led *led = 
     260            container_of(led_cdev, struct rt2x00_led, led_dev); 
     261        unsigned int enabled = brightness != LED_OFF; 
     262        unsigned int bg_mode = 
     263            (enabled && led->rt2x00dev->curr_band == IEEE80211_BAND_2GHZ); 
     264        unsigned int polarity = 
     265                rt2x00_get_field16(led->rt2x00dev->led_mcu_reg, 
     266                                   EEPROM_FREQ_LED_POLARITY); 
     267        unsigned int ledmode = 
     268                rt2x00_get_field16(led->rt2x00dev->led_mcu_reg, 
     269                                   EEPROM_FREQ_LED_MODE); 
     270 
     271        if (led->type == LED_TYPE_RADIO) { 
     272                rt2800pci_mcu_request(led->rt2x00dev, MCU_LED, 0xff, ledmode, 
     273                                      enabled ? 0x20 : 0); 
     274        } else if (led->type == LED_TYPE_ASSOC) { 
     275                rt2800pci_mcu_request(led->rt2x00dev, MCU_LED, 0xff, ledmode, 
     276                                      enabled ? (bg_mode ? 0x60 : 0xa0) : 0x20); 
     277        } else if (led->type == LED_TYPE_QUALITY) { 
     278                /* 
     279                 * The brightness is divided into 6 levels (0 - 5), 
     280                 * The specs tell us the following levels: 
     281                 *      0, 1 ,3, 7, 15, 31 
     282                 * to determine the level in a simple way we can simply 
     283                 * work with bitshifting: 
     284                 *      (1 << level) - 1 
     285                 */ 
     286                rt2800pci_mcu_request(led->rt2x00dev, MCU_LED_STRENGTH, 0xff, 
     287                                      (1 << brightness / (LED_FULL / 6)) - 1, 
     288                                      polarity); 
     289        } 
     290} 
     291 
     292static int rt2800pci_blink_set(struct led_classdev *led_cdev, 
     293                               unsigned long *delay_on, 
     294                               unsigned long *delay_off) 
     295{ 
     296        struct rt2x00_led *led = 
     297            container_of(led_cdev, struct rt2x00_led, led_dev); 
     298        u32 reg; 
     299 
     300        rt2x00pci_register_read(led->rt2x00dev, LED_CFG, &reg); 
     301        rt2x00_set_field32(&reg, LED_CFG_ON_PERIOD, *delay_on); 
     302        rt2x00_set_field32(&reg, LED_CFG_OFF_PERIOD, *delay_off); 
     303        rt2x00_set_field32(&reg, LED_CFG_SLOW_BLINK_PERIOD, 3); 
     304        rt2x00_set_field32(&reg, LED_CFG_R_LED_MODE, 3); 
     305        rt2x00_set_field32(&reg, LED_CFG_G_LED_MODE, 12); 
     306        rt2x00_set_field32(&reg, LED_CFG_Y_LED_MODE, 3); 
     307        rt2x00_set_field32(&reg, LED_CFG_LED_POLAR, 1); 
     308        rt2x00pci_register_write(led->rt2x00dev, LED_CFG, reg); 
     309 
     310        return 0; 
     311} 
     312 
     313static void rt2800pci_init_led(struct rt2x00_dev *rt2x00dev, 
     314                               struct rt2x00_led *led, 
     315                               enum led_type type) 
     316{ 
     317        led->rt2x00dev = rt2x00dev; 
     318        led->type = type; 
     319        led->led_dev.brightness_set = rt2800pci_brightness_set; 
     320        led->led_dev.blink_set = rt2800pci_blink_set; 
     321        led->flags = LED_INITIALIZED; 
     322} 
     323#endif /* CONFIG_RT2X00_LIB_LEDS */ 
     324 
     325/* 
     326 * Configuration handlers. 
     327 */ 
     328static void rt2800pci_config_wcid_attr(struct rt2x00_dev *rt2x00dev, 
     329                                       struct rt2x00lib_crypto *crypto, 
     330                                       struct ieee80211_key_conf *key) 
     331{ 
     332        u32 offset; 
     333        u32 reg; 
     334 
     335        offset = MAC_WCID_ATTR_ENTRY(crypto->aid); 
     336 
     337        reg = 0; 
     338        rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_KEYTAB, 
     339                           !!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)); 
     340        rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_PAIRKEY_MODE, 
     341                           crypto->cipher); 
     342        rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_BSS_IDX, 
     343                           (crypto->cmd == SET_KEY) ? crypto->bssidx : 0); 
     344        rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_RX_WIUDF, 0); 
     345        rt2x00pci_register_write(rt2x00dev, offset, reg); 
     346} 
     347 
     348static int rt2800pci_config_shared_key(struct rt2x00_dev *rt2x00dev, 
     349                                       struct rt2x00lib_crypto *crypto, 
     350                                       struct ieee80211_key_conf *key) 
     351{ 
     352        struct hw_key_entry key_entry; 
     353        struct rt2x00_field32 field; 
     354        u32 offset; 
     355        u32 mask; 
     356        u32 reg; 
     357 
     358        if (crypto->cmd == SET_KEY) { 
     359                memcpy(key_entry.key, crypto->key, 
     360                       sizeof(key_entry.key)); 
     361                memcpy(key_entry.tx_mic, crypto->tx_mic, 
     362                       sizeof(key_entry.tx_mic)); 
     363                memcpy(key_entry.rx_mic, crypto->rx_mic, 
     364                       sizeof(key_entry.rx_mic)); 
     365 
     366                offset = SHARED_KEY_ENTRY(key->hw_key_idx); 
     367                rt2x00pci_register_multiwrite(rt2x00dev, offset, 
     368                                              &key_entry, sizeof(key_entry)); 
     369 
     370                /* 
     371                 * The driver does not support the IV/EIV generation 
     372                 * in hardware. However it doesn't support the IV/EIV 
     373                 * inside the ieee80211 frame either, but requires it 
     374                 * to be provided seperately for the descriptor. 
     375                 * rt2x00lib will cut the IV/EIV data out of all frames 
     376                 * given to us by mac80211, but we must tell mac80211 
     377                 * to generate the IV/EIV data. 
     378                 */ 
     379                key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 
     380        } 
     381 
     382        /* 
     383         * The cipher types are stored over multiple registers 
     384         * starting with SHARED_KEY_MODE_BASE each word will have 
     385         * 32 bits and contains the cipher types for 2 modes each. 
     386         * Using the correct defines correctly will cause overhead, 
     387         * so just calculate the correct offset. 
     388         */ 
     389        mask = key->hw_key_idx % 8; 
     390        field.bit_offset = (3 * mask); 
     391        field.bit_mask = 0x7 << field.bit_offset; 
     392 
     393        offset = SHARED_KEY_MODE_ENTRY(key->hw_key_idx / 8); 
     394        rt2x00pci_register_read(rt2x00dev, offset, &reg); 
     395        rt2x00_set_field32(&reg, field, 
     396                           (crypto->cmd == SET_KEY) ? crypto->cipher : 0); 
     397        rt2x00pci_register_write(rt2x00dev, offset, reg); 
     398 
     399        /* 
     400         * Update WCID information 
     401         */ 
     402        rt2800pci_config_wcid_attr(rt2x00dev, crypto, key); 
     403 
     404        return 0; 
     405} 
     406 
     407static int rt2800pci_config_pairwise_key(struct rt2x00_dev *rt2x00dev, 
     408                                         struct rt2x00lib_crypto *crypto, 
     409                                         struct ieee80211_key_conf *key) 
     410{ 
     411        struct hw_key_entry key_entry; 
     412        u32 offset; 
     413 
     414        /* 
     415         * 1 pairwise key is possible per AID, this means that the AID 
     416         * equals our hw_key_idx. 
     417         */ 
     418        key->hw_key_idx = crypto->aid; 
     419 
     420        if (crypto->cmd == SET_KEY) { 
     421                memcpy(key_entry.key, crypto->key, 
     422                       sizeof(key_entry.key)); 
     423                memcpy(key_entry.tx_mic, crypto->tx_mic, 
     424                       sizeof(key_entry.tx_mic)); 
     425                memcpy(key_entry.rx_mic, crypto->rx_mic, 
     426                       sizeof(key_entry.rx_mic)); 
     427 
     428                offset = PAIRWISE_KEY_ENTRY(key->hw_key_idx); 
     429                rt2x00pci_register_multiwrite(rt2x00dev, offset, 
     430                                              &key_entry, sizeof(key_entry)); 
     431 
     432                /* 
     433                 * The driver does not support the IV/EIV generation 
     434                 * in hardware. However it doesn't support the IV/EIV 
     435                 * inside the ieee80211 frame either, but requires it 
     436                 * to be provided seperately for the descriptor. 
     437                 * rt2x00lib will cut the IV/EIV data out of all frames 
     438                 * given to us by mac80211, but we must tell mac80211 
     439                 * to generate the IV/EIV data. 
     440                 */ 
     441                key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 
     442        } 
     443 
     444        /* 
     445         * Update WCID information 
     446         */ 
     447        rt2800pci_config_wcid_attr(rt2x00dev, crypto, key); 
     448 
     449        return 0; 
     450} 
     451 
     452static void rt2800pci_config_filter(struct rt2x00_dev *rt2x00dev, 
     453                                    const unsigned int filter_flags) 
     454{ 
     455        u32 reg; 
     456 
     457        /* 
     458         * Start configuration steps. 
     459         * Note that the version error will always be dropped 
     460         * and broadcast frames will always be accepted since 
     461         * there is no filter for it at this time. 
     462         */ 
     463        rt2x00pci_register_read(rt2x00dev, RX_FILTER_CFG, &reg); 
     464        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CRC_ERROR, 
     465                           !(filter_flags & FIF_FCSFAIL)); 
     466        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_PHY_ERROR, 
     467                           !(filter_flags & FIF_PLCPFAIL)); 
     468        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_TO_ME, 
     469                           !(filter_flags & FIF_PROMISC_IN_BSS)); 
     470        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 
     471                           !(filter_flags & FIF_OTHER_BSS)); 
     472        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_VER_ERROR, 1); 
     473        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_MULTICAST, 
     474                           !(filter_flags & FIF_ALLMULTI)); 
     475        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BROADCAST, 0); 
     476        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_DUPLICATE, 1); 
     477        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CF_END_ACK, 
     478                           !(filter_flags & FIF_CONTROL)); 
     479        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CF_END, 
     480                           !(filter_flags & FIF_CONTROL)); 
     481        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_ACK, 
     482                           !(filter_flags & FIF_CONTROL)); 
     483        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CTS, 
     484                           !(filter_flags & FIF_CONTROL)); 
     485        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_RTS, 
     486                           !(filter_flags & FIF_CONTROL)); 
     487        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_PSPOLL, 
     488                           !(filter_flags & FIF_CONTROL)); 
     489        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BA, 1); 
     490        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BAR, 1); 
     491        rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CNTL, 
     492                           !(filter_flags & FIF_CONTROL)); 
     493        rt2x00pci_register_write(rt2x00dev, RX_FILTER_CFG, reg); 
     494} 
     495 
     496static void rt2800pci_config_intf(struct rt2x00_dev *rt2x00dev, 
     497                                  struct rt2x00_intf *intf, 
     498                                  struct rt2x00intf_conf *conf, 
     499                                  const unsigned int flags) 
     500{ 
     501        unsigned int beacon_base; 
     502        u32 reg; 
     503 
     504        if (flags & CONFIG_UPDATE_TYPE) { 
     505                /* 
     506                 * Clear current synchronisation setup. 
     507                 * For the Beacon base registers we only need to clear 
     508                 * the first byte since that byte contains the VALID and OWNER 
     509                 * bits which (when set to 0) will invalidate the entire beacon. 
     510                 */ 
     511                beacon_base = HW_BEACON_OFFSET(intf->beacon->entry_idx); 
     512                rt2x00pci_register_write(rt2x00dev, beacon_base, 0); 
     513 
     514                /* 
     515                 * Enable synchronisation. 
     516                 */ 
     517                rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     518                rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1); 
     519                rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_SYNC, conf->sync); 
     520                rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1); 
     521                rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     522        } 
     523 
     524        if (flags & CONFIG_UPDATE_MAC) { 
     525                reg = le32_to_cpu(conf->mac[1]); 
     526                rt2x00_set_field32(&reg, MAC_ADDR_DW1_UNICAST_TO_ME_MASK, 0xff); 
     527                conf->mac[1] = cpu_to_le32(reg); 
     528 
     529                rt2x00pci_register_multiwrite(rt2x00dev, MAC_ADDR_DW0, 
     530                                              conf->mac, sizeof(conf->mac)); 
     531        } 
     532 
     533        if (flags & CONFIG_UPDATE_BSSID) { 
     534                reg = le32_to_cpu(conf->bssid[1]); 
     535                rt2x00_set_field32(&reg, MAC_BSSID_DW1_BSS_ID_MASK, 0); 
     536                rt2x00_set_field32(&reg, MAC_BSSID_DW1_BSS_BCN_NUM, 0); 
     537                conf->bssid[1] = cpu_to_le32(reg); 
     538 
     539                rt2x00pci_register_multiwrite(rt2x00dev, MAC_BSSID_DW0, 
     540                                              conf->bssid, sizeof(conf->bssid)); 
     541        } 
     542} 
     543 
     544static void rt2800pci_config_erp(struct rt2x00_dev *rt2x00dev, 
     545                                 struct rt2x00lib_erp *erp) 
     546{ 
     547        u32 reg; 
     548 
     549        rt2x00pci_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
     550        rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_RX_ACK_TIMEOUT, 
     551                           erp->ack_timeout); 
     552        rt2x00pci_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
     553 
     554        rt2x00pci_register_read(rt2x00dev, AUTO_RSP_CFG, &reg); 
     555        rt2x00_set_field32(&reg, AUTO_RSP_CFG_BAC_ACK_POLICY, 
     556                           !!erp->short_preamble); 
     557        rt2x00_set_field32(&reg, AUTO_RSP_CFG_AR_PREAMBLE, 
     558                           !!erp->short_preamble); 
     559        rt2x00pci_register_write(rt2x00dev, AUTO_RSP_CFG, reg); 
     560 
     561        rt2x00pci_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
     562        rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_CTRL, 
     563                           erp->cts_protection ? 2 : 0); 
     564        rt2x00pci_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
     565 
     566        rt2x00pci_register_write(rt2x00dev, LEGACY_BASIC_RATE, 
     567                                 erp->basic_rates); 
     568        rt2x00pci_register_write(rt2x00dev, HT_BASIC_RATE, 
     569                                 erp->basic_rates >> 32); 
     570 
     571        rt2x00pci_register_read(rt2x00dev, BKOFF_SLOT_CFG, &reg); 
     572        rt2x00_set_field32(&reg, BKOFF_SLOT_CFG_SLOT_TIME, erp->slot_time); 
     573        rt2x00_set_field32(&reg, BKOFF_SLOT_CFG_CC_DELAY_TIME, 2); 
     574        rt2x00pci_register_write(rt2x00dev, BKOFF_SLOT_CFG, reg); 
     575 
     576        rt2x00pci_register_read(rt2x00dev, XIFS_TIME_CFG, &reg); 
     577        rt2x00_set_field32(&reg, XIFS_TIME_CFG_CCKM_SIFS_TIME, erp->sifs); 
     578        rt2x00_set_field32(&reg, XIFS_TIME_CFG_OFDM_SIFS_TIME, erp->sifs); 
     579        rt2x00_set_field32(&reg, XIFS_TIME_CFG_OFDM_XIFS_TIME, 4); 
     580        rt2x00_set_field32(&reg, XIFS_TIME_CFG_EIFS, erp->eifs); 
     581        rt2x00_set_field32(&reg, XIFS_TIME_CFG_BB_RXEND_ENABLE, 1); 
     582        rt2x00pci_register_write(rt2x00dev, XIFS_TIME_CFG, reg); 
     583} 
     584 
     585static void rt2800pci_config_ant(struct rt2x00_dev *rt2x00dev, 
     586                                 struct antenna_setup *ant) 
     587{ 
     588        u16 eeprom; 
     589        u8 r1; 
     590        u8 r3; 
     591 
     592        /* 
     593         * FIXME: Use requested antenna configuration. 
     594         */ 
     595 
     596        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
     597 
     598        rt2800pci_bbp_read(rt2x00dev, 1, &r1); 
     599        rt2800pci_bbp_read(rt2x00dev, 3, &r3); 
     600 
     601        /* 
     602         * Configure the TX antenna. 
     603         */ 
     604        switch (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH)) { 
     605        case 1: 
     606                rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 0); 
     607                break; 
     608        case 2: 
     609        case 3: 
     610                /* Do nothing */ 
     611                break; 
     612        } 
     613 
     614        /* 
     615         * Configure the RX antenna. 
     616         */ 
     617        switch (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH)) { 
     618        case 1: 
     619                rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 0); 
     620                break; 
     621        case 2: 
     622                rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 1); 
     623                break; 
     624        case 3: 
     625                rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 2); 
     626                break; 
     627        } 
     628 
     629        rt2800pci_bbp_write(rt2x00dev, 3, r3); 
     630        rt2800pci_bbp_write(rt2x00dev, 1, r1); 
     631} 
     632 
     633static void rt2800pci_config_lna_gain(struct rt2x00_dev *rt2x00dev, 
     634                                      struct rt2x00lib_conf *libconf) 
     635{ 
     636        u16 eeprom; 
     637        short lna_gain; 
     638 
     639        if (libconf->rf.channel <= 14) { 
     640                rt2x00_eeprom_read(rt2x00dev, EEPROM_LNA, &eeprom); 
     641                lna_gain = rt2x00_get_field16(eeprom, EEPROM_LNA_BG); 
     642        } else if (libconf->rf.channel <= 64) { 
     643                rt2x00_eeprom_read(rt2x00dev, EEPROM_LNA, &eeprom); 
     644                lna_gain = rt2x00_get_field16(eeprom, EEPROM_LNA_A0); 
     645        } else if (libconf->rf.channel <= 128) { 
     646                rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_BG2, &eeprom); 
     647                lna_gain = rt2x00_get_field16(eeprom, EEPROM_RSSI_BG2_LNA_A1); 
     648        } else { 
     649                rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_A2, &eeprom); 
     650                lna_gain = rt2x00_get_field16(eeprom, EEPROM_RSSI_A2_LNA_A2); 
     651        } 
     652 
     653        rt2x00dev->lna_gain = lna_gain; 
     654} 
     655 
     656static void rt2800pci_config_channel(struct rt2x00_dev *rt2x00dev, 
     657                                     struct rf_channel *rf, 
     658                                     struct channel_info *info) 
     659{ 
     660        u32 reg; 
     661        unsigned int tx_pin; 
     662        u16 eeprom; 
     663 
     664        tx_pin = 0; 
     665        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 1); 
     666        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A0_EN, 1); 
     667        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G0_EN, 1); 
     668        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 1); 
     669        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 1); 
     670        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_RFTR_EN, 1); 
     671        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_TRSW_EN, 1); 
     672 
     673        rt2x00_set_field32(&rf->rf4, RF4_FREQ_OFFSET, rt2x00dev->freq_offset); 
     674 
     675        /* 
     676         * Determine antenna settings from EEPROM 
     677         */ 
     678        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
     679        if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) == 1) { 
     680                rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_TX1, 1); 
     681                /* Turn off unused PA or LNA when only 1T or 1R */ 
     682                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A1_EN, 0); 
     683                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 0); 
     684        } 
     685 
     686        if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH) == 1) { 
     687                rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_RX1, 1); 
     688                rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_RX2, 1); 
     689                /* Turn off unused PA or LNA when only 1T or 1R */ 
     690                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 0); 
     691                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 0); 
     692        } else if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH) == 2) 
     693                rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_RX2, 1); 
     694 
     695        if (rf->channel > 14) { 
     696                /* 
     697                 * When TX power is below 0, we should increase it by 7 to 
     698                 * make it a positive value (Minumum value is -7). 
     699                 * However this means that values between 0 and 7 have 
     700                 * double meaning, and we should set a 7DBm boost flag. 
     701                 */ 
     702                rt2x00_set_field32(&rf->rf3, RF3_TXPOWER_A_7DBM_BOOST, 
     703                                   (info->tx_power1 >= 0)); 
     704 
     705                if (info->tx_power1 < 0) 
     706                        info->tx_power1 += 7; 
     707 
     708                rt2x00_set_field32(&rf->rf3, RF3_TXPOWER_A, 
     709                                   TXPOWER_A_TO_DEV(info->tx_power1)); 
     710 
     711                rt2x00_set_field32(&rf->rf4, RF4_TXPOWER_A_7DBM_BOOST, 
     712                                   (info->tx_power2 >= 0)); 
     713 
     714                if (info->tx_power2 < 0) 
     715                        info->tx_power2 += 7; 
     716 
     717                rt2x00_set_field32(&rf->rf4, RF4_TXPOWER_A, 
     718                                   TXPOWER_A_TO_DEV(info->tx_power2)); 
     719 
     720                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A0_EN, 1); 
     721        } else { 
     722                rt2x00_set_field32(&rf->rf3, RF3_TXPOWER_G, 
     723                                   TXPOWER_G_TO_DEV(info->tx_power1)); 
     724                rt2x00_set_field32(&rf->rf4, RF4_TXPOWER_G, 
     725                                   TXPOWER_G_TO_DEV(info->tx_power2)); 
     726 
     727                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN, 1); 
     728        } 
     729 
     730        rt2x00_set_field32(&rf->rf4, RF4_BW40, 
     731                           test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags)); 
     732 
     733        rt2800pci_rf_write(rt2x00dev, 1, rf->rf1); 
     734        rt2800pci_rf_write(rt2x00dev, 2, rf->rf2); 
     735        rt2800pci_rf_write(rt2x00dev, 3, rf->rf3 & ~0x00000004); 
     736        rt2800pci_rf_write(rt2x00dev, 4, rf->rf4); 
     737 
     738        udelay(200); 
     739 
     740        rt2800pci_rf_write(rt2x00dev, 1, rf->rf1); 
     741        rt2800pci_rf_write(rt2x00dev, 2, rf->rf2); 
     742        rt2800pci_rf_write(rt2x00dev, 3, rf->rf3 | 0x00000004); 
     743        rt2800pci_rf_write(rt2x00dev, 4, rf->rf4); 
     744 
     745        udelay(200); 
     746 
     747        rt2800pci_rf_write(rt2x00dev, 1, rf->rf1); 
     748        rt2800pci_rf_write(rt2x00dev, 2, rf->rf2); 
     749        rt2800pci_rf_write(rt2x00dev, 3, rf->rf3 & ~0x00000004); 
     750        rt2800pci_rf_write(rt2x00dev, 4, rf->rf4); 
     751 
     752        /* 
     753         * Change BBP settings 
     754         */ 
     755        rt2800pci_bbp_write(rt2x00dev, 62, 0x37 - rt2x00dev->lna_gain); 
     756        rt2800pci_bbp_write(rt2x00dev, 63, 0x37 - rt2x00dev->lna_gain); 
     757        rt2800pci_bbp_write(rt2x00dev, 64, 0x37 - rt2x00dev->lna_gain); 
     758        rt2800pci_bbp_write(rt2x00dev, 86, 0); 
     759 
     760        if (rf->channel <= 14) { 
     761                if (test_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags)) { 
     762                        rt2800pci_bbp_write(rt2x00dev, 82, 0x62); 
     763                        rt2800pci_bbp_write(rt2x00dev, 75, 0x46); 
     764                } else { 
     765                        rt2800pci_bbp_write(rt2x00dev, 82, 0x84); 
     766                        rt2800pci_bbp_write(rt2x00dev, 75, 0x50); 
     767                } 
     768 
     769                rt2x00pci_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
     770                rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_A, 0); 
     771                rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_BG, 1); 
     772                rt2x00pci_register_write(rt2x00dev, TX_BAND_CFG, reg); 
     773        } else { 
     774                rt2800pci_bbp_write(rt2x00dev, 82, 0xf2); 
     775 
     776                if (test_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags)) 
     777                        rt2800pci_bbp_write(rt2x00dev, 75, 0x46); 
     778                else 
     779                        rt2800pci_bbp_write(rt2x00dev, 75, 0x50); 
     780 
     781                rt2x00pci_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
     782                rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_A, 1); 
     783                rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_BG, 0); 
     784                rt2x00pci_register_write(rt2x00dev, TX_BAND_CFG, reg); 
     785        } 
     786 
     787        rt2x00pci_register_write(rt2x00dev, TX_PIN_CFG, tx_pin); 
     788 
     789        msleep(1); 
     790} 
     791 
     792static void rt2800pci_config_txpower(struct rt2x00_dev *rt2x00dev, 
     793                                     const int txpower) 
     794{ 
     795        u32 reg; 
     796        u32 value = TXPOWER_G_TO_DEV(txpower); 
     797        u8 r1; 
     798 
     799        rt2800pci_bbp_read(rt2x00dev, 1, &r1); 
     800        rt2x00_set_field8(&reg, BBP1_TX_POWER, 0); 
     801        rt2800pci_bbp_write(rt2x00dev, 1, r1); 
     802 
     803        rt2x00pci_register_read(rt2x00dev, TX_PWR_CFG_0, &reg); 
     804        rt2x00_set_field32(&reg, TX_PWR_CFG_0_1MBS, value); 
     805        rt2x00_set_field32(&reg, TX_PWR_CFG_0_2MBS, value); 
     806        rt2x00_set_field32(&reg, TX_PWR_CFG_0_55MBS, value); 
     807        rt2x00_set_field32(&reg, TX_PWR_CFG_0_11MBS, value); 
     808        rt2x00_set_field32(&reg, TX_PWR_CFG_0_6MBS, value); 
     809        rt2x00_set_field32(&reg, TX_PWR_CFG_0_9MBS, value); 
     810        rt2x00_set_field32(&reg, TX_PWR_CFG_0_12MBS, value); 
     811        rt2x00_set_field32(&reg, TX_PWR_CFG_0_18MBS, value); 
     812        rt2x00pci_register_write(rt2x00dev, TX_PWR_CFG_0, reg); 
     813 
     814        rt2x00pci_register_read(rt2x00dev, TX_PWR_CFG_1, &reg); 
     815        rt2x00_set_field32(&reg, TX_PWR_CFG_1_24MBS, value); 
     816        rt2x00_set_field32(&reg, TX_PWR_CFG_1_36MBS, value); 
     817        rt2x00_set_field32(&reg, TX_PWR_CFG_1_48MBS, value); 
     818        rt2x00_set_field32(&reg, TX_PWR_CFG_1_54MBS, value); 
     819        rt2x00_set_field32(&reg, TX_PWR_CFG_1_MCS0, value); 
     820        rt2x00_set_field32(&reg, TX_PWR_CFG_1_MCS1, value); 
     821        rt2x00_set_field32(&reg, TX_PWR_CFG_1_MCS2, value); 
     822        rt2x00_set_field32(&reg, TX_PWR_CFG_1_MCS3, value); 
     823        rt2x00pci_register_write(rt2x00dev, TX_PWR_CFG_1, reg); 
     824 
     825        rt2x00pci_register_read(rt2x00dev, TX_PWR_CFG_2, &reg); 
     826        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS4, value); 
     827        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS5, value); 
     828        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS6, value); 
     829        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS7, value); 
     830        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS8, value); 
     831        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS9, value); 
     832        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS10, value); 
     833        rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS11, value); 
     834        rt2x00pci_register_write(rt2x00dev, TX_PWR_CFG_2, reg); 
     835 
     836        rt2x00pci_register_read(rt2x00dev, TX_PWR_CFG_3, &reg); 
     837        rt2x00_set_field32(&reg, TX_PWR_CFG_3_MCS12, value); 
     838        rt2x00_set_field32(&reg, TX_PWR_CFG_3_MCS13, value); 
     839        rt2x00_set_field32(&reg, TX_PWR_CFG_3_MCS14, value); 
     840        rt2x00_set_field32(&reg, TX_PWR_CFG_3_MCS15, value); 
     841        rt2x00_set_field32(&reg, TX_PWR_CFG_3_UKNOWN1, value); 
     842        rt2x00_set_field32(&reg, TX_PWR_CFG_3_UKNOWN2, value); 
     843        rt2x00_set_field32(&reg, TX_PWR_CFG_3_UKNOWN3, value); 
     844        rt2x00_set_field32(&reg, TX_PWR_CFG_3_UKNOWN4, value); 
     845        rt2x00pci_register_write(rt2x00dev, TX_PWR_CFG_3, reg); 
     846 
     847        rt2x00pci_register_read(rt2x00dev, TX_PWR_CFG_4, &reg); 
     848        rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN5, value); 
     849        rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN6, value); 
     850        rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN7, value); 
     851        rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN8, value); 
     852        rt2x00pci_register_write(rt2x00dev, TX_PWR_CFG_4, reg); 
     853} 
     854 
     855static void rt2800pci_config_retry_limit(struct rt2x00_dev *rt2x00dev, 
     856                                         struct rt2x00lib_conf *libconf) 
     857{ 
     858        u32 reg; 
     859 
     860        rt2x00pci_register_read(rt2x00dev, TX_RTY_CFG, &reg); 
     861        rt2x00_set_field32(&reg, TX_RTY_CFG_SHORT_RTY_LIMIT, 
     862                           libconf->conf->short_frame_max_tx_count); 
     863        rt2x00_set_field32(&reg, TX_RTY_CFG_LONG_RTY_LIMIT, 
     864                           libconf->conf->long_frame_max_tx_count); 
     865        rt2x00_set_field32(&reg, TX_RTY_CFG_LONG_RTY_THRE, 2000); 
     866        rt2x00_set_field32(&reg, TX_RTY_CFG_NON_AGG_RTY_MODE, 0); 
     867        rt2x00_set_field32(&reg, TX_RTY_CFG_AGG_RTY_MODE, 0); 
     868        rt2x00_set_field32(&reg, TX_RTY_CFG_TX_AUTO_FB_ENABLE, 1); 
     869        rt2x00pci_register_write(rt2x00dev, TX_RTY_CFG, reg); 
     870} 
     871 
     872static void rt2800pci_config_duration(struct rt2x00_dev *rt2x00dev, 
     873                                      struct rt2x00lib_conf *libconf) 
     874{ 
     875        u32 reg; 
     876 
     877        rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     878        rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL, 
     879                           libconf->conf->beacon_int * 16); 
     880        rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     881} 
     882 
     883static void rt2800pci_config(struct rt2x00_dev *rt2x00dev, 
     884                             struct rt2x00lib_conf *libconf, 
     885                             const unsigned int flags) 
     886{ 
     887        /* Always recalculate LNA gain before changing configuration */ 
     888        rt2800pci_config_lna_gain(rt2x00dev, libconf); 
     889 
     890        if (flags & IEEE80211_CONF_CHANGE_CHANNEL) 
     891                rt2800pci_config_channel(rt2x00dev, &libconf->rf, 
     892                                         &libconf->channel); 
     893        if (flags & IEEE80211_CONF_CHANGE_POWER) 
     894                rt2800pci_config_txpower(rt2x00dev, libconf->conf->power_level); 
     895        if (flags & IEEE80211_CONF_CHANGE_RETRY_LIMITS) 
     896                rt2800pci_config_retry_limit(rt2x00dev, libconf); 
     897        if (flags & IEEE80211_CONF_CHANGE_BEACON_INTERVAL) 
     898                rt2800pci_config_duration(rt2x00dev, libconf); 
     899} 
     900 
     901/* 
     902 * Link tuning 
     903 */ 
     904static void rt2800pci_link_stats(struct rt2x00_dev *rt2x00dev, 
     905                                 struct link_qual *qual) 
     906{ 
     907        u32 reg; 
     908 
     909        /* 
     910         * Update FCS error count from register. 
     911         */ 
     912        rt2x00pci_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
     913        qual->rx_failed = rt2x00_get_field32(reg, RX_STA_CNT0_CRC_ERR); 
     914 
     915        /* 
     916         * Update False CCA count from register. 
     917         */ 
     918        rt2x00pci_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
     919        qual->false_cca = rt2x00_get_field32(reg, RX_STA_CNT1_FALSE_CCA); 
     920} 
     921 
     922static u8 rt2800pci_get_default_vgc(struct rt2x00_dev *rt2x00dev) 
     923{ 
     924        if (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ) 
     925                return 0x2e + rt2x00dev->lna_gain; 
     926 
     927        if (!test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags)) 
     928                return 0x32 + (rt2x00dev->lna_gain * 5) / 3; 
     929        else 
     930                return 0x3a + (rt2x00dev->lna_gain * 5) / 3; 
     931} 
     932 
     933static inline void rt2800pci_set_vgc(struct rt2x00_dev *rt2x00dev, 
     934                                     struct link_qual *qual, u8 vgc_level) 
     935{ 
     936        if (qual->vgc_level != vgc_level) { 
     937                rt2800pci_bbp_write(rt2x00dev, 66, vgc_level); 
     938                qual->vgc_level = vgc_level; 
     939                qual->vgc_level_reg = vgc_level; 
     940        } 
     941} 
     942 
     943static void rt2800pci_reset_tuner(struct rt2x00_dev *rt2x00dev, 
     944                                  struct link_qual *qual) 
     945{ 
     946        rt2800pci_set_vgc(rt2x00dev, qual, 
     947                          rt2800pci_get_default_vgc(rt2x00dev)); 
     948} 
     949 
     950static void rt2800pci_link_tuner(struct rt2x00_dev *rt2x00dev, 
     951                                 struct link_qual *qual, const u32 count) 
     952{ 
     953        if (rt2x00_rev(&rt2x00dev->chip) == RT2860_VERSION_C) 
     954                return; 
     955 
     956        /* 
     957         * When RSSI is better then -80 increase VGC level with 0x10 
     958         */ 
     959        rt2800pci_set_vgc(rt2x00dev, qual, 
     960                          rt2800pci_get_default_vgc(rt2x00dev) + 
     961                          ((qual->rssi > -80) * 0x10)); 
     962} 
     963 
     964/* 
     965 * Firmware functions 
     966 */ 
     967static char *rt2800pci_get_firmware_name(struct rt2x00_dev *rt2x00dev) 
     968{ 
     969        return FIRMWARE_RT2860; 
     970} 
     971 
     972static u16 rt2800pci_get_firmware_crc(const void *data, const size_t len) 
     973{ 
     974        u16 crc; 
     975 
     976        /* 
     977         * Use the crc ccitt algorithm. 
     978         * This will return the same value as the legacy driver which 
     979         * used bit ordering reversion on the both the firmware bytes 
     980         * before input input as well as on the final output. 
     981         * Obviously using crc ccitt directly is much more efficient. 
     982         * The last 2 bytes in the firmware array are the crc checksum itself, 
     983         * this means that we should never pass those 2 bytes to the crc 
     984         * algorithm. 
     985         */ 
     986        crc = crc_ccitt(~0, data, len - 2); 
     987 
     988        /* 
     989         * There is a small difference between the crc-itu-t + bitrev and 
     990         * the crc-ccitt crc calculation. In the latter method the 2 bytes 
     991         * will be swapped, use swab16 to convert the crc to the correct 
     992         * value. 
     993         */ 
     994        return swab16(crc); 
     995} 
     996 
     997static int rt2800pci_load_firmware(struct rt2x00_dev *rt2x00dev, 
     998                                   const void *data, const size_t len) 
     999{ 
     1000        unsigned int i; 
     1001        u32 reg; 
     1002 
     1003        /* 
     1004         * Wait for stable hardware. 
     1005         */ 
     1006        for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
     1007                rt2x00pci_register_read(rt2x00dev, MAC_CSR0, &reg); 
     1008                if (reg && reg != ~0) 
     1009                        break; 
     1010                msleep(1); 
     1011        } 
     1012 
     1013        if (i == REGISTER_BUSY_COUNT) { 
     1014                ERROR(rt2x00dev, "Unstable hardware.\n"); 
     1015                return -EBUSY; 
     1016        } 
     1017 
     1018        rt2x00pci_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000002); 
     1019        rt2x00pci_register_write(rt2x00dev, AUTOWAKEUP_CFG, 0x00000000); 
     1020 
     1021        /* 
     1022         * Disable DMA, will be reenabled later when enabling 
     1023         * the radio. 
     1024         */ 
     1025        rt2x00pci_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     1026        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0); 
     1027        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_DMA_BUSY, 0); 
     1028        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0); 
     1029        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_RX_DMA_BUSY, 0); 
     1030        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1); 
     1031        rt2x00pci_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
     1032 
     1033        /* 
     1034         * enable Host program ram write selection 
     1035         */ 
     1036        reg = 0; 
     1037        rt2x00_set_field32(&reg, PBF_SYS_CTRL_HOST_RAM_WRITE, 1); 
     1038        rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, reg); 
     1039 
     1040        /* 
     1041         * Write firmware to device. 
     1042         */ 
     1043        rt2x00pci_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE, 
     1044                                      data, len); 
     1045 
     1046        rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000); 
     1047        rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00001); 
     1048 
     1049        /* 
     1050         * Wait for device to stabilize. 
     1051         */ 
     1052        for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
     1053                rt2x00pci_register_read(rt2x00dev, PBF_SYS_CTRL, &reg); 
     1054                if (rt2x00_get_field32(reg, PBF_SYS_CTRL_READY)) 
     1055                        break; 
     1056                msleep(1); 
     1057        } 
     1058 
     1059        if (i == REGISTER_BUSY_COUNT) { 
     1060                ERROR(rt2x00dev, "PBF system register not ready.\n"); 
     1061                return -EBUSY; 
     1062        } 
     1063 
     1064        /* 
     1065         * Disable interrupts 
     1066         */ 
     1067        rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF); 
     1068 
     1069        /* 
     1070         * Initialize BBP R/W access agent 
     1071         */ 
     1072        rt2x00pci_register_write(rt2x00dev, H2M_BBP_AGENT, 0); 
     1073        rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); 
     1074 
     1075        return 0; 
     1076} 
     1077 
     1078/* 
     1079 * Initialization functions. 
     1080 */ 
     1081static bool rt2800pci_get_entry_state(struct queue_entry *entry) 
     1082{ 
     1083        struct queue_entry_priv_pci *entry_priv = entry->priv_data; 
     1084        u32 word; 
     1085 
     1086        if (entry->queue->qid == QID_RX) { 
     1087                rt2x00_desc_read(entry_priv->desc, 1, &word); 
     1088 
     1089                return (!rt2x00_get_field32(word, RXD_W1_DMA_DONE)); 
     1090        } else { 
     1091                rt2x00_desc_read(entry_priv->desc, 1, &word); 
     1092 
     1093                return (!rt2x00_get_field32(word, TXD_W1_DMA_DONE)); 
     1094        } 
     1095} 
     1096 
     1097static void rt2800pci_clear_entry(struct queue_entry *entry) 
     1098{ 
     1099        struct queue_entry_priv_pci *entry_priv = entry->priv_data; 
     1100        struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); 
     1101        u32 word; 
     1102 
     1103        if (entry->queue->qid == QID_RX) { 
     1104                rt2x00_desc_read(entry_priv->desc, 0, &word); 
     1105                rt2x00_set_field32(&word, RXD_W0_SDP0, skbdesc->skb_dma); 
     1106                rt2x00_desc_write(entry_priv->desc, 0, word); 
     1107 
     1108                rt2x00_desc_read(entry_priv->desc, 1, &word); 
     1109                rt2x00_set_field32(&word, RXD_W1_DMA_DONE, 0); 
     1110                rt2x00_desc_write(entry_priv->desc, 1, word); 
     1111        } else { 
     1112                rt2x00_desc_read(entry_priv->desc, 1, &word); 
     1113                rt2x00_set_field32(&word, TXD_W1_DMA_DONE, 1); 
     1114                rt2x00_desc_write(entry_priv->desc, 1, word); 
     1115        } 
     1116} 
     1117 
     1118static int rt2800pci_init_queues(struct rt2x00_dev *rt2x00dev) 
     1119{ 
     1120        struct queue_entry_priv_pci *entry_priv; 
     1121        u32 reg; 
     1122 
     1123        /* 
     1124         * Initialize registers. 
     1125         */ 
     1126        entry_priv = rt2x00dev->tx[0].entries[0].priv_data; 
     1127        rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR0, entry_priv->desc_dma); 
     1128        rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT0, rt2x00dev->tx[0].limit); 
     1129        rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX0, 0); 
     1130 
     1131        entry_priv = rt2x00dev->tx[1].entries[0].priv_data; 
     1132        rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR1, entry_priv->desc_dma); 
     1133        rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT1, rt2x00dev->tx[1].limit); 
     1134        rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX1, 0); 
     1135 
     1136        entry_priv = rt2x00dev->tx[2].entries[0].priv_data; 
     1137        rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR2, entry_priv->desc_dma); 
     1138        rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT2, rt2x00dev->tx[2].limit); 
     1139        rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX2, 0); 
     1140 
     1141        entry_priv = rt2x00dev->tx[3].entries[0].priv_data; 
     1142        rt2x00pci_register_write(rt2x00dev, TX_BASE_PTR3, entry_priv->desc_dma); 
     1143        rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT3, rt2x00dev->tx[3].limit); 
     1144        rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX3, 0); 
     1145 
     1146        entry_priv = rt2x00dev->rx->entries[0].priv_data; 
     1147        rt2x00pci_register_write(rt2x00dev, RX_BASE_PTR, entry_priv->desc_dma); 
     1148        rt2x00pci_register_write(rt2x00dev, RX_MAX_CNT, rt2x00dev->rx[0].limit); 
     1149        rt2x00pci_register_write(rt2x00dev, RX_CRX_IDX, 0); 
     1150 
     1151        /* 
     1152         * Enable global DMA configuration 
     1153         */ 
     1154        rt2x00pci_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     1155        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0); 
     1156        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0); 
     1157        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1); 
     1158        rt2x00pci_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
     1159 
     1160        rt2x00pci_register_write(rt2x00dev, DELAY_INT_CFG, 0); 
     1161 
     1162        return 0; 
     1163} 
     1164 
     1165static int rt2800pci_init_registers(struct rt2x00_dev *rt2x00dev) 
     1166{ 
     1167        u32 reg; 
     1168        unsigned int i; 
     1169 
     1170        rt2x00pci_register_read(rt2x00dev, WPDMA_RST_IDX, &reg); 
     1171        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX0, 1); 
     1172        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX1, 1); 
     1173        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX2, 1); 
     1174        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX3, 1); 
     1175        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX4, 1); 
     1176        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX5, 1); 
     1177        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DRX_IDX0, 1); 
     1178        rt2x00pci_register_write(rt2x00dev, WPDMA_RST_IDX, reg); 
     1179 
     1180        rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e1f); 
     1181        rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e00); 
     1182 
     1183        rt2x00pci_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000003); 
     1184 
     1185        rt2x00pci_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     1186        rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_CSR, 1); 
     1187        rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_BBP, 1); 
     1188        rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     1189 
     1190        rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); 
     1191 
     1192        rt2x00pci_register_read(rt2x00dev, BCN_OFFSET0, &reg); 
     1193        rt2x00_set_field32(&reg, BCN_OFFSET0_BCN0, 0xe0); /* 0x3800 */ 
     1194        rt2x00_set_field32(&reg, BCN_OFFSET0_BCN1, 0xe8); /* 0x3a00 */ 
     1195        rt2x00_set_field32(&reg, BCN_OFFSET0_BCN2, 0xf0); /* 0x3c00 */ 
     1196        rt2x00_set_field32(&reg, BCN_OFFSET0_BCN3, 0xf8); /* 0x3e00 */ 
     1197        rt2x00pci_register_write(rt2x00dev, BCN_OFFSET0, reg); 
     1198 
     1199        rt2x00pci_register_read(rt2x00dev, BCN_OFFSET1, &reg); 
     1200        rt2x00_set_field32(&reg, BCN_OFFSET1_BCN4, 0xc8); /* 0x3200 */ 
     1201        rt2x00_set_field32(&reg, BCN_OFFSET1_BCN5, 0xd0); /* 0x3400 */ 
     1202        rt2x00_set_field32(&reg, BCN_OFFSET1_BCN6, 0x77); /* 0x1dc0 */ 
     1203        rt2x00_set_field32(&reg, BCN_OFFSET1_BCN7, 0x6f); /* 0x1bc0 */ 
     1204        rt2x00pci_register_write(rt2x00dev, BCN_OFFSET1, reg); 
     1205 
     1206        rt2x00pci_register_write(rt2x00dev, LEGACY_BASIC_RATE, 0x0000013f); 
     1207        rt2x00pci_register_write(rt2x00dev, HT_BASIC_RATE, 0x00008003); 
     1208 
     1209        rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); 
     1210 
     1211        rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     1212        rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL, 0); 
     1213        rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0); 
     1214        rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_SYNC, 0); 
     1215        rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0); 
     1216        rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0); 
     1217        rt2x00_set_field32(&reg, BCN_TIME_CFG_TX_TIME_COMPENSATE, 0); 
     1218        rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     1219 
     1220        rt2x00pci_register_write(rt2x00dev, TX_SW_CFG0, 0x00040a06); 
     1221        rt2x00pci_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606); 
     1222 
     1223        rt2x00pci_register_read(rt2x00dev, TX_LINK_CFG, &reg); 
     1224        rt2x00_set_field32(&reg, TX_LINK_CFG_REMOTE_MFB_LIFETIME, 32); 
     1225        rt2x00_set_field32(&reg, TX_LINK_CFG_MFB_ENABLE, 0); 
     1226        rt2x00_set_field32(&reg, TX_LINK_CFG_REMOTE_UMFS_ENABLE, 0); 
     1227        rt2x00_set_field32(&reg, TX_LINK_CFG_TX_MRQ_EN, 0); 
     1228        rt2x00_set_field32(&reg, TX_LINK_CFG_TX_RDG_EN, 0); 
     1229        rt2x00_set_field32(&reg, TX_LINK_CFG_TX_CF_ACK_EN, 1); 
     1230        rt2x00_set_field32(&reg, TX_LINK_CFG_REMOTE_MFB, 0); 
     1231        rt2x00_set_field32(&reg, TX_LINK_CFG_REMOTE_MFS, 0); 
     1232        rt2x00pci_register_write(rt2x00dev, TX_LINK_CFG, reg); 
     1233 
     1234        rt2x00pci_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
     1235        rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_MPDU_LIFETIME, 9); 
     1236        rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_TX_OP_TIMEOUT, 10); 
     1237        rt2x00pci_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
     1238 
     1239        rt2x00pci_register_read(rt2x00dev, MAX_LEN_CFG, &reg); 
     1240        rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_MPDU, AGGREGATION_SIZE); 
     1241        rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 1); 
     1242        rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_PSDU, 0); 
     1243        rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_MPDU, 0); 
     1244        rt2x00pci_register_write(rt2x00dev, MAX_LEN_CFG, reg); 
     1245 
     1246        rt2x00pci_register_write(rt2x00dev, PBF_MAX_PCNT, 0x1f3fbf9f); 
     1247 
     1248        rt2x00pci_register_read(rt2x00dev, AUTO_RSP_CFG, &reg); 
     1249        rt2x00_set_field32(&reg, AUTO_RSP_CFG_AUTORESPONDER, 1); 
     1250        rt2x00_set_field32(&reg, AUTO_RSP_CFG_CTS_40_MMODE, 0); 
     1251        rt2x00_set_field32(&reg, AUTO_RSP_CFG_CTS_40_MREF, 0); 
     1252        rt2x00_set_field32(&reg, AUTO_RSP_CFG_DUAL_CTS_EN, 0); 
     1253        rt2x00_set_field32(&reg, AUTO_RSP_CFG_ACK_CTS_PSM_BIT, 0); 
     1254        rt2x00pci_register_write(rt2x00dev, AUTO_RSP_CFG, reg); 
     1255 
     1256        rt2x00pci_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
     1257        rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_RATE, 3); 
     1258        rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_CTRL, 0); 
     1259        rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_NAV, 1); 
     1260        rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_CCK, 1); 
     1261        rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
     1262        rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
     1263        rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1264        rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
     1265        rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     1266        rt2x00pci_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
     1267 
     1268        rt2x00pci_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
     1269        rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_RATE, 3); 
     1270        rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_CTRL, 0); 
     1271        rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_NAV, 1); 
     1272        rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_CCK, 1); 
     1273        rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
     1274        rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
     1275        rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1276        rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
     1277        rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     1278        rt2x00pci_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
     1279 
     1280        rt2x00pci_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
     1281        rt2x00_set_field32(&reg, MM20_PROT_CFG_PROTECT_RATE, 0x4004); 
     1282        rt2x00_set_field32(&reg, MM20_PROT_CFG_PROTECT_CTRL, 0); 
     1283        rt2x00_set_field32(&reg, MM20_PROT_CFG_PROTECT_NAV, 1); 
     1284        rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_CCK, 1); 
     1285        rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
     1286        rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
     1287        rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1288        rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
     1289        rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_GF40, 0); 
     1290        rt2x00pci_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
     1291 
     1292        rt2x00pci_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
     1293        rt2x00_set_field32(&reg, MM40_PROT_CFG_PROTECT_RATE, 0x4084); 
     1294        rt2x00_set_field32(&reg, MM40_PROT_CFG_PROTECT_CTRL, 0); 
     1295        rt2x00_set_field32(&reg, MM40_PROT_CFG_PROTECT_NAV, 1); 
     1296        rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_CCK, 1); 
     1297        rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
     1298        rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
     1299        rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_MM40, 1); 
     1300        rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
     1301        rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     1302        rt2x00pci_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
     1303 
     1304        rt2x00pci_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
     1305        rt2x00_set_field32(&reg, GF20_PROT_CFG_PROTECT_RATE, 0x4004); 
     1306        rt2x00_set_field32(&reg, GF20_PROT_CFG_PROTECT_CTRL, 0); 
     1307        rt2x00_set_field32(&reg, GF20_PROT_CFG_PROTECT_NAV, 1); 
     1308        rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_CCK, 1); 
     1309        rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
     1310        rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
     1311        rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1312        rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
     1313        rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_GF40, 0); 
     1314        rt2x00pci_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
     1315 
     1316        rt2x00pci_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
     1317        rt2x00_set_field32(&reg, GF40_PROT_CFG_PROTECT_RATE, 0x4084); 
     1318        rt2x00_set_field32(&reg, GF40_PROT_CFG_PROTECT_CTRL, 0); 
     1319        rt2x00_set_field32(&reg, GF40_PROT_CFG_PROTECT_NAV, 1); 
     1320        rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_CCK, 1); 
     1321        rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
     1322        rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
     1323        rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_MM40, 1); 
     1324        rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
     1325        rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     1326        rt2x00pci_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
     1327 
     1328        rt2x00pci_register_write(rt2x00dev, TXOP_CTRL_CFG, 0x0000583f); 
     1329        rt2x00pci_register_write(rt2x00dev, TXOP_HLDR_ET, 0x00000002); 
     1330 
     1331        rt2x00pci_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
     1332        rt2x00_set_field32(&reg, TX_RTS_CFG_AUTO_RTS_RETRY_LIMIT, 32); 
     1333        rt2x00_set_field32(&reg, TX_RTS_CFG_RTS_FBK_EN, 0); 
     1334        rt2x00pci_register_write(rt2x00dev, TX_RTS_CFG, reg); 
     1335 
     1336        rt2x00pci_register_write(rt2x00dev, EXP_ACK_TIME, 0x002400ca); 
     1337        rt2x00pci_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000003); 
     1338 
     1339        /* 
     1340         * ASIC will keep garbage value after boot, clear encryption keys. 
     1341         */ 
     1342        for (i = 0; i < 254; i++) { 
     1343                u32 wcid[2] = { 0xffffffff, 0x0000ffff }; 
     1344                rt2x00pci_register_multiwrite(rt2x00dev, MAC_WCID_ENTRY(i), 
     1345                                              wcid, sizeof(wcid)); 
     1346        } 
     1347 
     1348        for (i = 0; i < 4; i++) 
     1349                rt2x00pci_register_write(rt2x00dev, 
     1350                                         SHARED_KEY_MODE_ENTRY(i), 0); 
     1351 
     1352        for (i = 0; i < 256; i++) 
     1353                rt2x00pci_register_write(rt2x00dev, MAC_WCID_ATTR_ENTRY(i), 1); 
     1354 
     1355        /* 
     1356         * Clear all beacons 
     1357         * For the Beacon base registers we only need to clear 
     1358         * the first byte since that byte contains the VALID and OWNER 
     1359         * bits which (when set to 0) will invalidate the entire beacon. 
     1360         */ 
     1361        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE0, 0); 
     1362        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE1, 0); 
     1363        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE2, 0); 
     1364        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE3, 0); 
     1365        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE4, 0); 
     1366        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE5, 0); 
     1367        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE6, 0); 
     1368        rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE7, 0); 
     1369 
     1370        rt2x00pci_register_read(rt2x00dev, HT_FBK_CFG0, &reg); 
     1371        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS0FBK, 0); 
     1372        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS1FBK, 0); 
     1373        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS2FBK, 1); 
     1374        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS3FBK, 2); 
     1375        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS4FBK, 3); 
     1376        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS5FBK, 4); 
     1377        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS6FBK, 5); 
     1378        rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS7FBK, 6); 
     1379        rt2x00pci_register_write(rt2x00dev, HT_FBK_CFG0, reg); 
     1380 
     1381        rt2x00pci_register_read(rt2x00dev, HT_FBK_CFG1, &reg); 
     1382        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS8FBK, 8); 
     1383        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS9FBK, 8); 
     1384        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS10FBK, 9); 
     1385        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS11FBK, 10); 
     1386        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS12FBK, 11); 
     1387        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS13FBK, 12); 
     1388        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS14FBK, 13); 
     1389        rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS15FBK, 14); 
     1390        rt2x00pci_register_write(rt2x00dev, HT_FBK_CFG1, reg); 
     1391 
     1392        rt2x00pci_register_read(rt2x00dev, LG_FBK_CFG0, &reg); 
     1393        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS0FBK, 8); 
     1394        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS1FBK, 8); 
     1395        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS2FBK, 10); 
     1396        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS3FBK, 11); 
     1397        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS4FBK, 12); 
     1398        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS5FBK, 13); 
     1399        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS6FBK, 14); 
     1400        rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS7FBK, 15); 
     1401        rt2x00pci_register_write(rt2x00dev, LG_FBK_CFG0, reg); 
     1402 
     1403        rt2x00pci_register_read(rt2x00dev, LG_FBK_CFG1, &reg); 
     1404        rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS0FBK, 0); 
     1405        rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS1FBK, 0); 
     1406        rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS2FBK, 1); 
     1407        rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS3FBK, 2); 
     1408        rt2x00pci_register_write(rt2x00dev, LG_FBK_CFG1, reg); 
     1409 
     1410        /* 
     1411         * We must clear the error counters. 
     1412         * These registers are cleared on read, 
     1413         * so we may pass a useless variable to store the value. 
     1414         */ 
     1415        rt2x00pci_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
     1416        rt2x00pci_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
     1417        rt2x00pci_register_read(rt2x00dev, RX_STA_CNT2, &reg); 
     1418        rt2x00pci_register_read(rt2x00dev, TX_STA_CNT0, &reg); 
     1419        rt2x00pci_register_read(rt2x00dev, TX_STA_CNT1, &reg); 
     1420        rt2x00pci_register_read(rt2x00dev, TX_STA_CNT2, &reg); 
     1421 
     1422        return 0; 
     1423} 
     1424 
     1425static int rt2800pci_wait_bbp_rf_ready(struct rt2x00_dev *rt2x00dev) 
     1426{ 
     1427        unsigned int i; 
     1428        u32 reg; 
     1429 
     1430        for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
     1431                rt2x00pci_register_read(rt2x00dev, MAC_STATUS_CFG, &reg); 
     1432                if (!rt2x00_get_field32(reg, MAC_STATUS_CFG_BBP_RF_BUSY)) 
     1433                        return 0; 
     1434 
     1435                udelay(REGISTER_BUSY_DELAY); 
     1436        } 
     1437 
     1438        ERROR(rt2x00dev, "BBP/RF register access failed, aborting.\n"); 
     1439        return -EACCES; 
     1440} 
     1441 
     1442static int rt2800pci_wait_bbp_ready(struct rt2x00_dev *rt2x00dev) 
     1443{ 
     1444        unsigned int i; 
     1445        u8 value; 
     1446 
     1447        /* 
     1448         * BBP was enabled after firmware was loaded, 
     1449         * but we need to reactivate it now. 
     1450         */ 
     1451        rt2x00pci_register_write(rt2x00dev, H2M_BBP_AGENT, 0x00000000); 
     1452        rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0x00000000); 
     1453        msleep(1); 
     1454 
     1455        for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
     1456                rt2800pci_bbp_read(rt2x00dev, 0, &value); 
     1457                if ((value != 0xff) && (value != 0x00)) 
     1458                        return 0; 
     1459                udelay(REGISTER_BUSY_DELAY); 
     1460        } 
     1461 
     1462        ERROR(rt2x00dev, "BBP register access failed, aborting.\n"); 
     1463        return -EACCES; 
     1464} 
     1465 
     1466static int rt2800pci_init_bbp(struct rt2x00_dev *rt2x00dev) 
     1467{ 
     1468        unsigned int i; 
     1469        u16 eeprom; 
     1470        u8 reg_id; 
     1471        u8 value; 
     1472 
     1473        if (unlikely(rt2800pci_wait_bbp_rf_ready(rt2x00dev) || 
     1474                     rt2800pci_wait_bbp_ready(rt2x00dev))) 
     1475                return -EACCES; 
     1476 
     1477        rt2800pci_bbp_write(rt2x00dev, 65, 0x2c); 
     1478        rt2800pci_bbp_write(rt2x00dev, 66, 0x38); 
     1479        rt2800pci_bbp_write(rt2x00dev, 69, 0x12); 
     1480        rt2800pci_bbp_write(rt2x00dev, 70, 0x0a); 
     1481        rt2800pci_bbp_write(rt2x00dev, 73, 0x10); 
     1482        rt2800pci_bbp_write(rt2x00dev, 81, 0x37); 
     1483        rt2800pci_bbp_write(rt2x00dev, 82, 0x62); 
     1484        rt2800pci_bbp_write(rt2x00dev, 83, 0x6a); 
     1485        rt2800pci_bbp_write(rt2x00dev, 84, 0x99); 
     1486        rt2800pci_bbp_write(rt2x00dev, 86, 0x00); 
     1487        rt2800pci_bbp_write(rt2x00dev, 91, 0x04); 
     1488        rt2800pci_bbp_write(rt2x00dev, 92, 0x00); 
     1489        rt2800pci_bbp_write(rt2x00dev, 103, 0x00); 
     1490        rt2800pci_bbp_write(rt2x00dev, 105, 0x05); 
     1491 
     1492        if (rt2x00_rev(&rt2x00dev->chip) == RT2860_VERSION_C) { 
     1493                rt2800pci_bbp_write(rt2x00dev, 69, 0x16); 
     1494                rt2800pci_bbp_write(rt2x00dev, 73, 0x12); 
     1495        } 
     1496 
     1497        if (rt2x00_rev(&rt2x00dev->chip) == RT2860_VERSION_D) 
     1498                rt2800pci_bbp_write(rt2x00dev, 84, 0x19); 
     1499 
     1500        for (i = 0; i < EEPROM_BBP_SIZE; i++) { 
     1501                rt2x00_eeprom_read(rt2x00dev, EEPROM_BBP_START + i, &eeprom); 
     1502 
     1503                if (eeprom != 0xffff && eeprom != 0x0000) { 
     1504                        reg_id = rt2x00_get_field16(eeprom, EEPROM_BBP_REG_ID); 
     1505                        value = rt2x00_get_field16(eeprom, EEPROM_BBP_VALUE); 
     1506                        rt2800pci_bbp_write(rt2x00dev, reg_id, value); 
     1507                } 
     1508        } 
     1509 
     1510        return 0; 
     1511} 
     1512 
     1513/* 
     1514 * Device state switch handlers. 
     1515 */ 
     1516static void rt2800pci_toggle_rx(struct rt2x00_dev *rt2x00dev, 
     1517                                enum dev_state state) 
     1518{ 
     1519        u32 reg; 
     1520 
     1521        rt2x00pci_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     1522        rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 
     1523                           (state == STATE_RADIO_RX_ON) || 
     1524                           (state == STATE_RADIO_RX_ON_LINK)); 
     1525        rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     1526} 
     1527 
     1528static void rt2800pci_toggle_irq(struct rt2x00_dev *rt2x00dev, 
     1529                                 enum dev_state state) 
     1530{ 
     1531        int mask = (state == STATE_RADIO_IRQ_ON); 
     1532        u32 reg; 
     1533 
     1534        /* 
     1535         * When interrupts are being enabled, the interrupt registers 
     1536         * should clear the register to assure a clean state. 
     1537         */ 
     1538        if (state == STATE_RADIO_IRQ_ON) { 
     1539                rt2x00pci_register_read(rt2x00dev, INT_SOURCE_CSR, &reg); 
     1540                rt2x00pci_register_write(rt2x00dev, INT_SOURCE_CSR, reg); 
     1541        } 
     1542 
     1543        rt2x00pci_register_read(rt2x00dev, INT_MASK_CSR, &reg); 
     1544        rt2x00_set_field32(&reg, INT_MASK_CSR_RXDELAYINT, mask); 
     1545        rt2x00_set_field32(&reg, INT_MASK_CSR_TXDELAYINT, mask); 
     1546        rt2x00_set_field32(&reg, INT_MASK_CSR_RX_DONE, mask); 
     1547        rt2x00_set_field32(&reg, INT_MASK_CSR_AC0_DMA_DONE, mask); 
     1548        rt2x00_set_field32(&reg, INT_MASK_CSR_AC1_DMA_DONE, mask); 
     1549        rt2x00_set_field32(&reg, INT_MASK_CSR_AC2_DMA_DONE, mask); 
     1550        rt2x00_set_field32(&reg, INT_MASK_CSR_AC3_DMA_DONE, mask); 
     1551        rt2x00_set_field32(&reg, INT_MASK_CSR_HCCA_DMA_DONE, mask); 
     1552        rt2x00_set_field32(&reg, INT_MASK_CSR_MGMT_DMA_DONE, mask); 
     1553        rt2x00_set_field32(&reg, INT_MASK_CSR_MCU_COMMAND, mask); 
     1554        rt2x00_set_field32(&reg, INT_MASK_CSR_RXTX_COHERENT, mask); 
     1555        rt2x00_set_field32(&reg, INT_MASK_CSR_TBTT, mask); 
     1556        rt2x00_set_field32(&reg, INT_MASK_CSR_PRE_TBTT, mask); 
     1557        rt2x00_set_field32(&reg, INT_MASK_CSR_TX_FIFO_STATUS, mask); 
     1558        rt2x00_set_field32(&reg, INT_MASK_CSR_AUTO_WAKEUP, mask); 
     1559        rt2x00_set_field32(&reg, INT_MASK_CSR_GPTIMER, mask); 
     1560        rt2x00_set_field32(&reg, INT_MASK_CSR_RX_COHERENT, mask); 
     1561        rt2x00_set_field32(&reg, INT_MASK_CSR_TX_COHERENT, mask); 
     1562        rt2x00pci_register_write(rt2x00dev, INT_MASK_CSR, reg); 
     1563} 
     1564 
     1565static int rt2800pci_wait_wpdma_ready(struct rt2x00_dev *rt2x00dev) 
     1566{ 
     1567        unsigned int i; 
     1568        u32 reg; 
     1569 
     1570        for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
     1571                rt2x00pci_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     1572                if (!rt2x00_get_field32(reg, WPDMA_GLO_CFG_TX_DMA_BUSY) && 
     1573                    !rt2x00_get_field32(reg, WPDMA_GLO_CFG_RX_DMA_BUSY)) 
     1574                        return 0; 
     1575 
     1576                msleep(1); 
     1577        } 
     1578 
     1579        ERROR(rt2x00dev, "WPDMA TX/RX busy, aborting.\n"); 
     1580        return -EACCES; 
     1581} 
     1582 
     1583static int rt2800pci_enable_radio(struct rt2x00_dev *rt2x00dev) 
     1584{ 
     1585        u32 reg; 
     1586        u16 word; 
     1587 
     1588        /* 
     1589         * Initialize all registers. 
     1590         */ 
     1591        if (unlikely(rt2800pci_wait_wpdma_ready(rt2x00dev) || 
     1592                     rt2800pci_init_queues(rt2x00dev) || 
     1593                     rt2800pci_init_registers(rt2x00dev) || 
     1594                     rt2800pci_init_bbp(rt2x00dev))) 
     1595                return -EIO; 
     1596 
     1597        /* 
     1598         * Send signal to firmware during boot time. 
     1599         */ 
     1600        rt2800pci_mcu_request(rt2x00dev, MCU_BOOT_SIGNAL, 0xff, 0, 0); 
     1601 
     1602        /* Wait for DMA, ignore error */ 
     1603        rt2800pci_wait_wpdma_ready(rt2x00dev); 
     1604 
     1605        /* 
     1606         * Enable RX. 
     1607         */ 
     1608        rt2x00pci_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     1609        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 1); 
     1610        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 1); 
     1611        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_WP_DMA_BURST_SIZE, 2); 
     1612        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1); 
     1613        rt2x00pci_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
     1614 
     1615        rt2x00pci_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     1616        rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_TX, 1); 
     1617        rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 1); 
     1618        rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     1619 
     1620        /* 
     1621         * Initialize LED control 
     1622         */ 
     1623        rt2x00_eeprom_read(rt2x00dev, EEPROM_LED1, &word); 
     1624        rt2800pci_mcu_request(rt2x00dev, MCU_LED_1, 0xff, 
     1625                              word & 0xff, (word >> 8) & 0xff); 
     1626 
     1627        rt2x00_eeprom_read(rt2x00dev, EEPROM_LED2, &word); 
     1628        rt2800pci_mcu_request(rt2x00dev, MCU_LED_2, 0xff, 
     1629                              word & 0xff, (word >> 8) & 0xff); 
     1630 
     1631        rt2x00_eeprom_read(rt2x00dev, EEPROM_LED3, &word); 
     1632        rt2800pci_mcu_request(rt2x00dev, MCU_LED_3, 0xff, 
     1633                              word & 0xff, (word >> 8) & 0xff); 
     1634 
     1635        return 0; 
     1636} 
     1637 
     1638static void rt2800pci_disable_radio(struct rt2x00_dev *rt2x00dev) 
     1639{ 
     1640        u32 reg; 
     1641 
     1642        rt2x00pci_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     1643        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0); 
     1644        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_DMA_BUSY, 0); 
     1645        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0); 
     1646        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_RX_DMA_BUSY, 0); 
     1647        rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1); 
     1648        rt2x00pci_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
     1649 
     1650        rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, 0); 
     1651        rt2x00pci_register_write(rt2x00dev, PWR_PIN_CFG, 0); 
     1652        rt2x00pci_register_write(rt2x00dev, TX_PIN_CFG, 0); 
     1653 
     1654        rt2x00pci_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00001280); 
     1655 
     1656        /* Wait for DMA, ignore error */ 
     1657        rt2800pci_wait_wpdma_ready(rt2x00dev); 
     1658} 
     1659 
     1660static int rt2800pci_set_state(struct rt2x00_dev *rt2x00dev, 
     1661                               enum dev_state state) 
     1662{ 
     1663        rt2x00pci_register_write(rt2x00dev, AUTOWAKEUP_CFG, 0); 
     1664 
     1665        if (state == STATE_AWAKE) 
     1666                rt2800pci_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 0); 
     1667        else 
     1668                rt2800pci_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0, 2); 
     1669 
     1670        return 0; 
     1671} 
     1672 
     1673static int rt2800pci_set_device_state(struct rt2x00_dev *rt2x00dev, 
     1674                                      enum dev_state state) 
     1675{ 
     1676        int retval = 0; 
     1677 
     1678        switch (state) { 
     1679        case STATE_RADIO_ON: 
     1680                /* 
     1681                 * Before the radio can be enabled, the device first has 
     1682                 * to be woken up. After that it needs a bit of time 
     1683                 * to be fully awake and the radio can be enabled. 
     1684                 */ 
     1685                rt2800pci_set_state(rt2x00dev, STATE_AWAKE); 
     1686                msleep(1); 
     1687                retval = rt2800pci_enable_radio(rt2x00dev); 
     1688                break; 
     1689        case STATE_RADIO_OFF: 
     1690                /* 
     1691                 * After the radio has been disablee, the device should 
     1692                 * be put to sleep for powersaving. 
     1693                 */ 
     1694                rt2800pci_disable_radio(rt2x00dev); 
     1695                rt2800pci_set_state(rt2x00dev, STATE_SLEEP); 
     1696                break; 
     1697        case STATE_RADIO_RX_ON: 
     1698        case STATE_RADIO_RX_ON_LINK: 
     1699        case STATE_RADIO_RX_OFF: 
     1700        case STATE_RADIO_RX_OFF_LINK: 
     1701                rt2800pci_toggle_rx(rt2x00dev, state); 
     1702                break; 
     1703        case STATE_RADIO_IRQ_ON: 
     1704        case STATE_RADIO_IRQ_OFF: 
     1705                rt2800pci_toggle_irq(rt2x00dev, state); 
     1706                break; 
     1707        case STATE_DEEP_SLEEP: 
     1708        case STATE_SLEEP: 
     1709        case STATE_STANDBY: 
     1710        case STATE_AWAKE: 
     1711                retval = rt2800pci_set_state(rt2x00dev, state); 
     1712                break; 
     1713        default: 
     1714                retval = -ENOTSUPP; 
     1715                break; 
     1716        } 
     1717 
     1718        if (unlikely(retval)) 
     1719                ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n", 
     1720                      state, retval); 
     1721 
     1722        return retval; 
     1723} 
     1724 
     1725/* 
     1726 * TX descriptor initialization 
     1727 */ 
     1728static void rt2800pci_write_tx_desc(struct rt2x00_dev *rt2x00dev, 
     1729                                    struct sk_buff *skb, 
     1730                                    struct txentry_desc *txdesc) 
     1731{ 
     1732        struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb); 
     1733        __le32 *txd = skbdesc->desc; 
     1734        __le32 *txwi = (__le32 *)(skb->data - rt2x00dev->hw->extra_tx_headroom); 
     1735        u32 word; 
     1736 
     1737        /* 
     1738         * Initialize TX Info descriptor 
     1739         */ 
     1740        rt2x00_desc_read(txwi, 0, &word); 
     1741        rt2x00_set_field32(&word, TXWI_W0_FRAG, 
     1742                           test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags) || 
     1743                           test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags)); 
     1744        rt2x00_set_field32(&word, TXWI_W0_MIMO_PS, 0); 
     1745        rt2x00_set_field32(&word, TXWI_W0_CF_ACK, 0); 
     1746        rt2x00_set_field32(&word, TXWI_W0_TS, 
     1747                           test_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc->flags)); 
     1748        rt2x00_set_field32(&word, TXWI_W0_AMPDU, 
     1749                           test_bit(ENTRY_TXD_HT_AMPDU, &txdesc->flags)); 
     1750        rt2x00_set_field32(&word, TXWI_W0_MPDU_DENSITY, txdesc->mpdu_density); 
     1751        rt2x00_set_field32(&word, TXWI_W0_TX_OP, txdesc->ifs); 
     1752        rt2x00_set_field32(&word, TXWI_W0_MCS, txdesc->mcs); 
     1753        rt2x00_set_field32(&word, TXWI_W0_BW, 
     1754                           test_bit(ENTRY_TXD_HT_BW_40, &txdesc->flags)); 
     1755        rt2x00_set_field32(&word, TXWI_W0_SHORT_GI, 
     1756                           test_bit(ENTRY_TXD_HT_SHORT_GI, &txdesc->flags)); 
     1757        rt2x00_set_field32(&word, TXWI_W0_STBC, txdesc->stbc); 
     1758        rt2x00_set_field32(&word, TXWI_W0_PHYMODE, txdesc->rate_mode); 
     1759        rt2x00_desc_write(txwi, 0, word); 
     1760 
     1761        rt2x00_desc_read(txwi, 1, &word); 
     1762        rt2x00_set_field32(&word, TXWI_W1_ACK, 
     1763                           test_bit(ENTRY_TXD_ACK, &txdesc->flags)); 
     1764        rt2x00_set_field32(&word, TXWI_W1_NSEQ, 
     1765                           test_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags)); 
     1766        rt2x00_set_field32(&word, TXWI_W1_BW_WIN_SIZE, txdesc->ba_size); 
     1767        rt2x00_set_field32(&word, TXWI_W1_WIRELESS_CLI_ID, 
     1768                           skbdesc->entry->entry_idx); 
     1769        rt2x00_set_field32(&word, TXWI_W1_MPDU_TOTAL_BYTE_COUNT, skb->len); 
     1770        rt2x00_set_field32(&word, TXWI_W1_PACKETID, 
     1771                           skbdesc->entry->queue->qid); 
     1772        rt2x00_desc_write(txwi, 1, word); 
     1773 
     1774        if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags)) { 
     1775                _rt2x00_desc_write(txwi, 2, skbdesc->iv[0]); 
     1776                _rt2x00_desc_write(txwi, 3, skbdesc->iv[1]); 
     1777        } 
     1778 
     1779        /* 
     1780         * Initialize TX descriptor 
     1781         */ 
     1782        rt2x00_desc_read(txd, 0, &word); 
     1783        rt2x00_set_field32(&word, TXD_W0_SD_PTR0, skbdesc->skb_dma); 
     1784        rt2x00_desc_write(txd, 0, word); 
     1785 
     1786        rt2x00_desc_read(txd, 1, &word); 
     1787        rt2x00_set_field32(&word, TXD_W1_SD_LEN1, skb->len); 
     1788        rt2x00_set_field32(&word, TXD_W1_LAST_SEC1, 1); 
     1789        rt2x00_set_field32(&word, TXD_W1_BURST, 
     1790                           test_bit(ENTRY_TXD_BURST, &txdesc->flags)); 
     1791        rt2x00_set_field32(&word, TXD_W1_SD_LEN0, 
     1792                           rt2x00dev->hw->extra_tx_headroom); 
     1793        rt2x00_set_field32(&word, TXD_W1_LAST_SEC0, 
     1794                           !test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags)); 
     1795        rt2x00_set_field32(&word, TXD_W1_DMA_DONE, 0); 
     1796        rt2x00_desc_write(txd, 1, word); 
     1797 
     1798        rt2x00_desc_read(txd, 2, &word); 
     1799        rt2x00_set_field32(&word, TXD_W2_SD_PTR1, 
     1800                           skbdesc->skb_dma + rt2x00dev->hw->extra_tx_headroom); 
     1801        rt2x00_desc_write(txd, 2, word); 
     1802 
     1803        rt2x00_desc_read(txd, 3, &word); 
     1804        rt2x00_set_field32(&word, TXD_W3_WIV, 1); 
     1805        rt2x00_set_field32(&word, TXD_W3_QSEL, 2); 
     1806        rt2x00_desc_write(txd, 3, word); 
     1807} 
     1808 
     1809/* 
     1810 * TX data initialization 
     1811 */ 
     1812static void rt2800pci_write_beacon(struct queue_entry *entry) 
     1813{ 
     1814        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 
     1815        struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); 
     1816        unsigned int beacon_base; 
     1817        u32 reg; 
     1818 
     1819        /* 
     1820         * Disable beaconing while we are reloading the beacon data, 
     1821         * otherwise we might be sending out invalid data. 
     1822         */ 
     1823        rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     1824        rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0); 
     1825        rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0); 
     1826        rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0); 
     1827        rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     1828 
     1829        /* 
     1830         * Write entire beacon with descriptor to register. 
     1831         */ 
     1832        beacon_base = HW_BEACON_OFFSET(entry->entry_idx); 
     1833        rt2x00pci_register_multiwrite(rt2x00dev, 
     1834                                      beacon_base, 
     1835                                      skbdesc->desc, skbdesc->desc_len); 
     1836        rt2x00pci_register_multiwrite(rt2x00dev, 
     1837                                      beacon_base + skbdesc->desc_len, 
     1838                                      entry->skb->data, entry->skb->len); 
     1839 
     1840        /* 
     1841         * Clean up beacon skb. 
     1842         */ 
     1843        dev_kfree_skb_any(entry->skb); 
     1844        entry->skb = NULL; 
     1845} 
     1846 
     1847static void rt2800pci_kick_tx_queue(struct rt2x00_dev *rt2x00dev, 
     1848                                    const enum data_queue_qid queue_idx) 
     1849{ 
     1850        struct data_queue *queue; 
     1851        unsigned int idx, qidx = 0; 
     1852        u32 reg; 
     1853 
     1854        if (queue_idx == QID_BEACON) { 
     1855                rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     1856                if (!rt2x00_get_field32(reg, BCN_TIME_CFG_BEACON_GEN)) { 
     1857                        rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1); 
     1858                        rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1); 
     1859                        rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 1); 
     1860                        rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     1861                } 
     1862                return; 
     1863        } 
     1864 
     1865        if (queue_idx > QID_HCCA && queue_idx != QID_MGMT) 
     1866                return; 
     1867 
     1868        queue = rt2x00queue_get_queue(rt2x00dev, queue_idx); 
     1869        idx = queue->index[Q_INDEX]; 
     1870 
     1871        if (queue_idx == QID_MGMT) 
     1872                qidx = 5; 
     1873        else 
     1874                qidx = queue_idx; 
     1875 
     1876        rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX(qidx), idx); 
     1877} 
     1878 
     1879/* 
     1880 * RX control handlers 
     1881 */ 
     1882static void rt2800pci_fill_rxdone(struct queue_entry *entry, 
     1883                                  struct rxdone_entry_desc *rxdesc) 
     1884{ 
     1885        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 
     1886        struct queue_entry_priv_pci *entry_priv = entry->priv_data; 
     1887        __le32 *rxd = entry_priv->desc; 
     1888        __le32 *rxwi = (__le32 *)entry->skb->data; 
     1889        u32 rxd3; 
     1890        u32 rxwi0; 
     1891        u32 rxwi1; 
     1892        u32 rxwi2; 
     1893        u32 rxwi3; 
     1894 
     1895        rt2x00_desc_read(rxd, 3, &rxd3); 
     1896        rt2x00_desc_read(rxwi, 0, &rxwi0); 
     1897        rt2x00_desc_read(rxwi, 1, &rxwi1); 
     1898        rt2x00_desc_read(rxwi, 2, &rxwi2); 
     1899        rt2x00_desc_read(rxwi, 3, &rxwi3); 
     1900 
     1901        if (rt2x00_get_field32(rxd3, RXD_W3_CRC_ERROR)) 
     1902                rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC; 
     1903 
     1904        if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags)) { 
     1905                /* 
     1906                 * Unfortunately we don't know the cipher type used during 
     1907                 * decryption. This prevents us from correct providing 
     1908                 * correct statistics through debugfs. 
     1909                 */ 
     1910                rxdesc->cipher = CIPHER_NONE; 
     1911                rxdesc->cipher_status = 
     1912                    rt2x00_get_field32(rxd3, RXD_W3_CIPHER_ERROR); 
     1913        } 
     1914 
     1915        if (rt2x00_get_field32(rxd3, RXD_W3_DECRYPTED)) { 
     1916                /* 
     1917                 * Hardware has stripped IV/EIV data from 802.11 frame during 
     1918                 * decryption. Unfortunately the descriptor doesn't contain 
     1919                 * any fields with the EIV/IV data either, so they can't 
     1920                 * be restored by rt2x00lib. 
     1921                 */ 
     1922                rxdesc->flags |= RX_FLAG_IV_STRIPPED; 
     1923 
     1924                if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS) 
     1925                        rxdesc->flags |= RX_FLAG_DECRYPTED; 
     1926                else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC) 
     1927                        rxdesc->flags |= RX_FLAG_MMIC_ERROR; 
     1928        } 
     1929 
     1930        if (rt2x00_get_field32(rxd3, RXD_W3_MY_BSS)) 
     1931                rxdesc->dev_flags |= RXDONE_MY_BSS; 
     1932 
     1933        if (rt2x00_get_field32(rxwi1, RXWI_W1_SHORT_GI)) 
     1934                rxdesc->flags |= RX_FLAG_SHORT_GI; 
     1935 
     1936        if (rt2x00_get_field32(rxwi1, RXWI_W1_BW)) 
     1937                rxdesc->flags |= RX_FLAG_40MHZ; 
     1938 
     1939        /* 
     1940         * Detect RX rate, always use MCS as signal type. 
     1941         */ 
     1942        rxdesc->dev_flags |= RXDONE_SIGNAL_MCS; 
     1943        rxdesc->rate_mode = rt2x00_get_field32(rxwi1, RXWI_W1_PHYMODE); 
     1944        rxdesc->signal = rt2x00_get_field32(rxwi1, RXWI_W1_MCS); 
     1945 
     1946        /* 
     1947         * Mask of 0x8 bit to remove the short preamble flag. 
     1948         */ 
     1949        if (rxdesc->dev_flags == RATE_MODE_CCK) 
     1950                rxdesc->signal &= ~0x8; 
     1951 
     1952        rxdesc->rssi = 
     1953            (rt2x00_get_field32(rxwi2, RXWI_W2_RSSI0) + 
     1954             rt2x00_get_field32(rxwi2, RXWI_W2_RSSI1) + 
     1955             rt2x00_get_field32(rxwi2, RXWI_W2_RSSI2)) / 3; 
     1956 
     1957        rxdesc->noise = 
     1958            (rt2x00_get_field32(rxwi3, RXWI_W3_SNR0) + 
     1959             rt2x00_get_field32(rxwi3, RXWI_W3_SNR1)) / 2; 
     1960 
     1961        rxdesc->size = rt2x00_get_field32(rxwi0, RXWI_W0_MPDU_TOTAL_BYTE_COUNT); 
     1962 
     1963        /* 
     1964         * Remove TXWI descriptor from start of buffer. 
     1965         */ 
     1966        skb_pull(entry->skb, TXWI_DESC_SIZE); 
     1967        skb_trim(entry->skb, rxdesc->size); 
     1968} 
     1969 
     1970/* 
     1971 * Interrupt functions. 
     1972 */ 
     1973static void rt2800pci_txdone(struct rt2x00_dev *rt2x00dev) 
     1974{ 
     1975        struct data_queue *queue; 
     1976        struct queue_entry *entry; 
     1977        struct queue_entry *entry_done; 
     1978        struct queue_entry_priv_pci *entry_priv; 
     1979        struct txdone_entry_desc txdesc; 
     1980        u32 word; 
     1981        u32 reg; 
     1982        u32 old_reg; 
     1983        int type; 
     1984        int index; 
     1985 
     1986        /* 
     1987         * During each loop we will compare the freshly read 
     1988         * TX_STA_FIFO register value with the value read from 
     1989         * the previous loop. If the 2 values are equal then 
     1990         * we should stop processing because the chance it 
     1991         * quite big that the device has been unplugged and 
     1992         * we risk going into an endless loop. 
     1993         */ 
     1994        old_reg = 0; 
     1995 
     1996        while (1) { 
     1997                rt2x00pci_register_read(rt2x00dev, TX_STA_FIFO, &reg); 
     1998                if (!rt2x00_get_field32(reg, TX_STA_FIFO_VALID)) 
     1999                        break; 
     2000 
     2001                if (old_reg == reg) 
     2002                        break; 
     2003                old_reg = reg; 
     2004 
     2005                /* 
     2006                 * Skip this entry when it contains an invalid 
     2007                 * queue identication number. 
     2008                 */ 
     2009                type = rt2x00_get_field32(reg, TX_STA_FIFO_PID_TYPE); 
     2010                queue = rt2x00queue_get_queue(rt2x00dev, type); 
     2011                if (unlikely(!queue)) 
     2012                        continue; 
     2013 
     2014                /* 
     2015                 * Skip this entry when it contains an invalid 
     2016                 * index number. 
     2017                 */ 
     2018                index = rt2x00_get_field32(reg, TX_STA_FIFO_WCID); 
     2019                if (unlikely(index >= queue->limit)) 
     2020                        continue; 
     2021 
     2022                entry = &queue->entries[index]; 
     2023                entry_priv = entry->priv_data; 
     2024                rt2x00_desc_read((__le32 *)entry->skb->data, 0, &word); 
     2025 
     2026                entry_done = rt2x00queue_get_entry(queue, Q_INDEX_DONE); 
     2027                while (entry != entry_done) { 
     2028                        /* 
     2029                         * Catch up. 
     2030                         * Just report any entries we missed as failed. 
     2031                         */ 
     2032                        WARNING(rt2x00dev, 
     2033                                "TX status report missed for entry %d\n", 
     2034                                entry_done->entry_idx); 
     2035 
     2036                        txdesc.flags = 0; 
     2037                        __set_bit(TXDONE_UNKNOWN, &txdesc.flags); 
     2038                        txdesc.retry = 0; 
     2039 
     2040                        rt2x00lib_txdone(entry_done, &txdesc); 
     2041                        entry_done = rt2x00queue_get_entry(queue, Q_INDEX_DONE); 
     2042                } 
     2043 
     2044                /* 
     2045                 * Obtain the status about this packet. 
     2046                 */ 
     2047                txdesc.flags = 0; 
     2048                if (rt2x00_get_field32(reg, TX_STA_FIFO_TX_SUCCESS)) 
     2049                        __set_bit(TXDONE_SUCCESS, &txdesc.flags); 
     2050                else 
     2051                        __set_bit(TXDONE_FAILURE, &txdesc.flags); 
     2052                txdesc.retry = rt2x00_get_field32(word, TXWI_W0_MCS); 
     2053 
     2054                rt2x00lib_txdone(entry, &txdesc); 
     2055        } 
     2056} 
     2057 
     2058static irqreturn_t rt2800pci_interrupt(int irq, void *dev_instance) 
     2059{ 
     2060        struct rt2x00_dev *rt2x00dev = dev_instance; 
     2061        u32 reg; 
     2062 
     2063        /* Read status and ACK all interrupts */ 
     2064        rt2x00pci_register_read(rt2x00dev, INT_SOURCE_CSR, &reg); 
     2065        rt2x00pci_register_write(rt2x00dev, INT_SOURCE_CSR, reg); 
     2066 
     2067        if (!reg) 
     2068                return IRQ_NONE; 
     2069 
     2070        if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 
     2071                return IRQ_HANDLED; 
     2072 
     2073        /* 
     2074         * 1 - Rx ring done interrupt. 
     2075         */ 
     2076        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE)) 
     2077                rt2x00pci_rxdone(rt2x00dev); 
     2078 
     2079        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TX_FIFO_STATUS)) 
     2080                rt2800pci_txdone(rt2x00dev); 
     2081 
     2082        return IRQ_HANDLED; 
     2083} 
     2084 
     2085/* 
     2086 * Device probe functions. 
     2087 */ 
     2088static int rt2800pci_validate_eeprom(struct rt2x00_dev *rt2x00dev) 
     2089{ 
     2090        struct eeprom_93cx6 eeprom; 
     2091        u32 reg; 
     2092        u16 word; 
     2093        u8 *mac; 
     2094        u8 default_lna_gain; 
     2095 
     2096        rt2x00pci_register_read(rt2x00dev, E2PROM_CSR, &reg); 
     2097 
     2098        eeprom.data = rt2x00dev; 
     2099        eeprom.register_read = rt2800pci_eepromregister_read; 
     2100        eeprom.register_write = rt2800pci_eepromregister_write; 
     2101        eeprom.width = rt2x00_get_field32(reg, E2PROM_CSR_TYPE_93C46) ? 
     2102            PCI_EEPROM_WIDTH_93C46 : PCI_EEPROM_WIDTH_93C66; 
     2103        eeprom.reg_data_in = 0; 
     2104        eeprom.reg_data_out = 0; 
     2105        eeprom.reg_data_clock = 0; 
     2106        eeprom.reg_chip_select = 0; 
     2107 
     2108        eeprom_93cx6_multiread(&eeprom, EEPROM_BASE, rt2x00dev->eeprom, 
     2109                               EEPROM_SIZE / sizeof(u16)); 
     2110 
     2111        /* 
     2112         * Start validation of the data that has been read. 
     2113         */ 
     2114        mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0); 
     2115        if (!is_valid_ether_addr(mac)) { 
     2116                DECLARE_MAC_BUF(macbuf); 
     2117 
     2118                random_ether_addr(mac); 
     2119                EEPROM(rt2x00dev, "MAC: %s\n", print_mac(macbuf, mac)); 
     2120        } 
     2121 
     2122        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &word); 
     2123        if (word == 0xffff) { 
     2124                rt2x00_set_field16(&word, EEPROM_ANTENNA_RXPATH, 2); 
     2125                rt2x00_set_field16(&word, EEPROM_ANTENNA_TXPATH, 1); 
     2126                rt2x00_set_field16(&word, EEPROM_ANTENNA_RF_TYPE, RF2820); 
     2127                rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word); 
     2128                EEPROM(rt2x00dev, "Antenna: 0x%04x\n", word); 
     2129        } 
     2130 
     2131        rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &word); 
     2132        if (word != 0) { 
     2133                /* NIC configuration must always be 0. */ 
     2134                word = 0; 
     2135                rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word); 
     2136                EEPROM(rt2x00dev, "NIC: 0x%04x\n", word); 
     2137        } 
     2138 
     2139        rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &word); 
     2140        if ((word & 0x00ff) == 0x00ff) { 
     2141                rt2x00_set_field16(&word, EEPROM_FREQ_OFFSET, 0); 
     2142                rt2x00_set_field16(&word, EEPROM_FREQ_LED_MODE, 
     2143                                   LED_MODE_TXRX_ACTIVITY); 
     2144                rt2x00_set_field16(&word, EEPROM_FREQ_LED_POLARITY, 0); 
     2145                rt2x00_eeprom_write(rt2x00dev, EEPROM_FREQ, word); 
     2146                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED1, 0x5555); 
     2147                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED2, 0x2221); 
     2148                rt2x00_eeprom_write(rt2x00dev, EEPROM_LED3, 0xa9f8); 
     2149                EEPROM(rt2x00dev, "Freq: 0x%04x\n", word); 
     2150        } 
     2151 
     2152        /* 
     2153         * During the LNA validation we are going to use 
     2154         * lna0 as correct value. Note that EEPROM_LNA 
     2155         * is never validated. 
     2156         */ 
     2157        rt2x00_eeprom_read(rt2x00dev, EEPROM_LNA, &word); 
     2158        default_lna_gain = rt2x00_get_field16(word, EEPROM_LNA_A0); 
     2159 
     2160        rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_BG, &word); 
     2161        if (abs(rt2x00_get_field16(word, EEPROM_RSSI_BG_OFFSET0)) > 10) 
     2162                rt2x00_set_field16(&word, EEPROM_RSSI_BG_OFFSET0, 0); 
     2163        if (abs(rt2x00_get_field16(word, EEPROM_RSSI_BG_OFFSET1)) > 10) 
     2164                rt2x00_set_field16(&word, EEPROM_RSSI_BG_OFFSET1, 0); 
     2165        rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_BG, word); 
     2166 
     2167        rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_BG2, &word); 
     2168        if (abs(rt2x00_get_field16(word, EEPROM_RSSI_BG2_OFFSET2)) > 10) 
     2169                rt2x00_set_field16(&word, EEPROM_RSSI_BG2_OFFSET2, 0); 
     2170        if (rt2x00_get_field16(word, EEPROM_RSSI_BG2_LNA_A1) == 0x00 || 
     2171            rt2x00_get_field16(word, EEPROM_RSSI_BG2_LNA_A1) == 0xff) 
     2172                rt2x00_set_field16(&word, EEPROM_RSSI_BG2_LNA_A1, 
     2173                                   default_lna_gain); 
     2174        rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_BG2, word); 
     2175 
     2176        rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_A, &word); 
     2177        if (abs(rt2x00_get_field16(word, EEPROM_RSSI_A_OFFSET0)) > 10) 
     2178                rt2x00_set_field16(&word, EEPROM_RSSI_A_OFFSET0, 0); 
     2179        if (abs(rt2x00_get_field16(word, EEPROM_RSSI_A_OFFSET1)) > 10) 
     2180                rt2x00_set_field16(&word, EEPROM_RSSI_A_OFFSET1, 0); 
     2181        rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_A, word); 
     2182 
     2183        rt2x00_eeprom_read(rt2x00dev, EEPROM_RSSI_A2, &word); 
     2184        if (abs(rt2x00_get_field16(word, EEPROM_RSSI_A2_OFFSET2)) > 10) 
     2185                rt2x00_set_field16(&word, EEPROM_RSSI_A2_OFFSET2, 0); 
     2186        if (rt2x00_get_field16(word, EEPROM_RSSI_A2_LNA_A2) == 0x00 || 
     2187            rt2x00_get_field16(word, EEPROM_RSSI_A2_LNA_A2) == 0xff) 
     2188                rt2x00_set_field16(&word, EEPROM_RSSI_A2_LNA_A2, 
     2189                                   default_lna_gain); 
     2190        rt2x00_eeprom_write(rt2x00dev, EEPROM_RSSI_A2, word); 
     2191 
     2192        return 0; 
     2193} 
     2194 
     2195static int rt2800pci_init_eeprom(struct rt2x00_dev *rt2x00dev) 
     2196{ 
     2197        u32 reg; 
     2198        u16 value; 
     2199        u16 eeprom; 
     2200        u16 device; 
     2201 
     2202        /* 
     2203         * Read EEPROM word for configuration. 
     2204         */ 
     2205        rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
     2206 
     2207        /* 
     2208         * Identify RF chipset. 
     2209         * To determine the RT chip we have to read the 
     2210         * PCI header of the device. 
     2211         */ 
     2212        pci_read_config_word(to_pci_dev(rt2x00dev->dev), 
     2213                             PCI_CONFIG_HEADER_DEVICE, &device); 
     2214        value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RF_TYPE); 
     2215        rt2x00pci_register_read(rt2x00dev, MAC_CSR0, &reg); 
     2216        reg = rt2x00_get_field32(reg, MAC_CSR0_ASIC_REV); 
     2217        rt2x00_set_chip(rt2x00dev, device, value, reg); 
     2218 
     2219        if (!rt2x00_rf(&rt2x00dev->chip, RF2820) && 
     2220            !rt2x00_rf(&rt2x00dev->chip, RF2850) && 
     2221            !rt2x00_rf(&rt2x00dev->chip, RF2720) && 
     2222            !rt2x00_rf(&rt2x00dev->chip, RF2750)) { 
     2223                ERROR(rt2x00dev, "Invalid RF chipset detected.\n"); 
     2224                return -ENODEV; 
     2225        } 
     2226 
     2227        /* 
     2228         * Read frequency offset and RF programming sequence. 
     2229         */ 
     2230        rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &eeprom); 
     2231        rt2x00dev->freq_offset = rt2x00_get_field16(eeprom, EEPROM_FREQ_OFFSET); 
     2232 
     2233        /* 
     2234         * Read external LNA informations. 
     2235         */ 
     2236        rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &eeprom); 
     2237 
     2238        if (rt2x00_get_field16(eeprom, EEPROM_NIC_EXTERNAL_LNA_A)) 
     2239                __set_bit(CONFIG_EXTERNAL_LNA_A, &rt2x00dev->flags); 
     2240        if (rt2x00_get_field16(eeprom, EEPROM_NIC_EXTERNAL_LNA_BG)) 
     2241                __set_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags); 
     2242 
     2243        /* 
     2244         * Detect if this device has an hardware controlled radio. 
     2245         */ 
     2246#ifdef CONFIG_RT2X00_LIB_RFKILL 
     2247        if (rt2x00_get_field16(eeprom, EEPROM_NIC_HW_RADIO)) 
     2248                __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags); 
     2249#endif /* CONFIG_RT2X00_LIB_RFKILL */ 
     2250 
     2251        /* 
     2252         * Store led settings, for correct led behaviour. 
     2253         */ 
     2254#ifdef CONFIG_RT2X00_LIB_LEDS 
     2255        rt2800pci_init_led(rt2x00dev, &rt2x00dev->led_radio, LED_TYPE_RADIO); 
     2256        rt2800pci_init_led(rt2x00dev, &rt2x00dev->led_assoc, LED_TYPE_ASSOC); 
     2257        rt2800pci_init_led(rt2x00dev, &rt2x00dev->led_qual, LED_TYPE_QUALITY); 
     2258 
     2259        rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &rt2x00dev->led_mcu_reg); 
     2260#endif /* CONFIG_RT2X00_LIB_LEDS */ 
     2261 
     2262        return 0; 
     2263} 
     2264 
     2265/* 
     2266 * RF value list for rt2860 
     2267 * Supports: 2.4 GHz (all) & 5.2 GHz (RF2850 & RF2750) 
     2268 */ 
     2269static const struct rf_channel rf_vals[] = { 
     2270        { 1,  0x18402ecc, 0x184c0786, 0x1816b455, 0x1800510b }, 
     2271        { 2,  0x18402ecc, 0x184c0786, 0x18168a55, 0x1800519f }, 
     2272        { 3,  0x18402ecc, 0x184c078a, 0x18168a55, 0x1800518b }, 
     2273        { 4,  0x18402ecc, 0x184c078a, 0x18168a55, 0x1800519f }, 
     2274        { 5,  0x18402ecc, 0x184c078e, 0x18168a55, 0x1800518b }, 
     2275        { 6,  0x18402ecc, 0x184c078e, 0x18168a55, 0x1800519f }, 
     2276        { 7,  0x18402ecc, 0x184c0792, 0x18168a55, 0x1800518b }, 
     2277        { 8,  0x18402ecc, 0x184c0792, 0x18168a55, 0x1800519f }, 
     2278        { 9,  0x18402ecc, 0x184c0796, 0x18168a55, 0x1800518b }, 
     2279        { 10, 0x18402ecc, 0x184c0796, 0x18168a55, 0x1800519f }, 
     2280        { 11, 0x18402ecc, 0x184c079a, 0x18168a55, 0x1800518b }, 
     2281        { 12, 0x18402ecc, 0x184c079a, 0x18168a55, 0x1800519f }, 
     2282        { 13, 0x18402ecc, 0x184c079e, 0x18168a55, 0x1800518b }, 
     2283        { 14, 0x18402ecc, 0x184c07a2, 0x18168a55, 0x18005193 }, 
     2284 
     2285        /* 802.11 UNI / HyperLan 2 */ 
     2286        { 36, 0x18402ecc, 0x184c099a, 0x18158a55, 0x180ed1a3 }, 
     2287        { 38, 0x18402ecc, 0x184c099e, 0x18158a55, 0x180ed193 }, 
     2288        { 40, 0x18402ec8, 0x184c0682, 0x18158a55, 0x180ed183 }, 
     2289        { 44, 0x18402ec8, 0x184c0682, 0x18158a55, 0x180ed1a3 }, 
     2290        { 46, 0x18402ec8, 0x184c0686, 0x18158a55, 0x180ed18b }, 
     2291        { 48, 0x18402ec8, 0x184c0686, 0x18158a55, 0x180ed19b }, 
     2292        { 52, 0x18402ec8, 0x184c068a, 0x18158a55, 0x180ed193 }, 
     2293        { 54, 0x18402ec8, 0x184c068a, 0x18158a55, 0x180ed1a3 }, 
     2294        { 56, 0x18402ec8, 0x184c068e, 0x18158a55, 0x180ed18b }, 
     2295        { 60, 0x18402ec8, 0x184c0692, 0x18158a55, 0x180ed183 }, 
     2296        { 62, 0x18402ec8, 0x184c0692, 0x18158a55, 0x180ed193 }, 
     2297        { 64, 0x18402ec8, 0x184c0692, 0x18158a55, 0x180ed1a3 }, 
     2298 
     2299        /* 802.11 HyperLan 2 */ 
     2300        { 100, 0x18402ec8, 0x184c06b2, 0x18178a55, 0x180ed783 }, 
     2301        { 102, 0x18402ec8, 0x184c06b2, 0x18578a55, 0x180ed793 }, 
     2302        { 104, 0x18402ec8, 0x184c06b2, 0x18578a55, 0x180ed1a3 }, 
     2303        { 108, 0x18402ecc, 0x184c0a32, 0x18578a55, 0x180ed193 }, 
     2304        { 110, 0x18402ecc, 0x184c0a36, 0x18178a55, 0x180ed183 }, 
     2305        { 112, 0x18402ecc, 0x184c0a36, 0x18178a55, 0x180ed19b }, 
     2306        { 116, 0x18402ecc, 0x184c0a3a, 0x18178a55, 0x180ed1a3 }, 
     2307        { 118, 0x18402ecc, 0x184c0a3e, 0x18178a55, 0x180ed193 }, 
     2308        { 120, 0x18402ec4, 0x184c0382, 0x18178a55, 0x180ed183 }, 
     2309        { 124, 0x18402ec4, 0x184c0382, 0x18178a55, 0x180ed193 }, 
     2310        { 126, 0x18402ec4, 0x184c0382, 0x18178a55, 0x180ed15b }, 
     2311        { 128, 0x18402ec4, 0x184c0382, 0x18178a55, 0x180ed1a3 }, 
     2312        { 132, 0x18402ec4, 0x184c0386, 0x18178a55, 0x180ed18b }, 
     2313        { 134, 0x18402ec4, 0x184c0386, 0x18178a55, 0x180ed193 }, 
     2314        { 136, 0x18402ec4, 0x184c0386, 0x18178a55, 0x180ed19b }, 
     2315        { 140, 0x18402ec4, 0x184c038a, 0x18178a55, 0x180ed183 }, 
     2316 
     2317        /* 802.11 UNII */ 
     2318        { 149, 0x18402ec4, 0x184c038a, 0x18178a55, 0x180ed1a7 }, 
     2319        { 151, 0x18402ec4, 0x184c038e, 0x18178a55, 0x180ed187 }, 
     2320        { 153, 0x18402ec4, 0x184c038e, 0x18178a55, 0x180ed18f }, 
     2321        { 157, 0x18402ec4, 0x184c038e, 0x18178a55, 0x180ed19f }, 
     2322        { 159, 0x18402ec4, 0x184c038e, 0x18178a55, 0x180ed1a7 }, 
     2323        { 161, 0x18402ec4, 0x184c0392, 0x18178a55, 0x180ed187 }, 
     2324        { 165, 0x18402ec4, 0x184c0392, 0x18178a55, 0x180ed197 }, 
     2325 
     2326        /* 802.11 Japan */ 
     2327        { 184, 0x15002ccc, 0x1500491e, 0x1509be55, 0x150c0a0b }, 
     2328        { 188, 0x15002ccc, 0x15004922, 0x1509be55, 0x150c0a13 }, 
     2329        { 192, 0x15002ccc, 0x15004926, 0x1509be55, 0x150c0a1b }, 
     2330        { 196, 0x15002ccc, 0x1500492a, 0x1509be55, 0x150c0a23 }, 
     2331        { 208, 0x15002ccc, 0x1500493a, 0x1509be55, 0x150c0a13 }, 
     2332        { 212, 0x15002ccc, 0x1500493e, 0x1509be55, 0x150c0a1b }, 
     2333        { 216, 0x15002ccc, 0x15004982, 0x1509be55, 0x150c0a23 }, 
     2334}; 
     2335 
     2336static int rt2800pci_probe_hw_mode(struct rt2x00_dev *rt2x00dev) 
     2337{ 
     2338        struct hw_mode_spec *spec = &rt2x00dev->spec; 
     2339        struct channel_info *info; 
     2340        char *tx_power1; 
     2341        char *tx_power2; 
     2342        unsigned int i; 
     2343 
     2344        /* 
     2345         * Initialize all hw fields. 
     2346         */ 
     2347        rt2x00dev->hw->flags = 
     2348            IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING | 
     2349            IEEE80211_HW_SIGNAL_DBM; 
     2350        rt2x00dev->hw->extra_tx_headroom = TXWI_DESC_SIZE; 
     2351 
     2352        SET_IEEE80211_DEV(rt2x00dev->hw, rt2x00dev->dev); 
     2353        SET_IEEE80211_PERM_ADDR(rt2x00dev->hw, 
     2354                                rt2x00_eeprom_addr(rt2x00dev, 
     2355                                                   EEPROM_MAC_ADDR_0)); 
     2356 
     2357        /* 
     2358         * Initialize hw_mode information. 
     2359         */ 
     2360        spec->supported_bands = SUPPORT_BAND_2GHZ; 
     2361        spec->supported_rates = SUPPORT_RATE_CCK | SUPPORT_RATE_OFDM; 
     2362 
     2363        if (rt2x00_rf(&rt2x00dev->chip, RF2820) || 
     2364            rt2x00_rf(&rt2x00dev->chip, RF2720)) { 
     2365                spec->num_channels = 14; 
     2366                spec->channels = rf_vals; 
     2367        } else if (rt2x00_rf(&rt2x00dev->chip, RF2850) || 
     2368                   rt2x00_rf(&rt2x00dev->chip, RF2750)) { 
     2369                spec->supported_bands |= SUPPORT_BAND_5GHZ; 
     2370                spec->num_channels = ARRAY_SIZE(rf_vals); 
     2371                spec->channels = rf_vals; 
     2372        } 
     2373 
     2374        /* 
     2375         * Initialize HT information. 
     2376         */ 
     2377        spec->ht.ht_supported = true; 
     2378        spec->ht.cap = 
     2379            IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 
     2380            IEEE80211_HT_CAP_GRN_FLD | 
     2381            IEEE80211_HT_CAP_SGI_20 | 
     2382            IEEE80211_HT_CAP_SGI_40 | 
     2383            IEEE80211_HT_CAP_TX_STBC | 
     2384            IEEE80211_HT_CAP_RX_STBC | 
     2385            IEEE80211_HT_CAP_PSMP_SUPPORT; 
     2386        spec->ht.ampdu_factor = 3; 
     2387        spec->ht.ampdu_density = 4; 
     2388        spec->ht.mcs.rx_mask[0] = 0xff; 
     2389        spec->ht.mcs.rx_mask[1] = 0xff; 
     2390        spec->ht.mcs.tx_params = 
     2391            IEEE80211_HT_MCS_TX_DEFINED; 
     2392 
     2393        /* 
     2394         * Create channel information array 
     2395         */ 
     2396        info = kzalloc(spec->num_channels * sizeof(*info), GFP_KERNEL); 
     2397        if (!info) 
     2398                return -ENOMEM; 
     2399 
     2400        spec->channels_info = info; 
     2401 
     2402        tx_power1 = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_BG1); 
     2403        tx_power2 = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_BG2); 
     2404 
     2405        for (i = 0; i < 14; i++) { 
     2406                info[i].tx_power1 = TXPOWER_G_FROM_DEV(tx_power1[i]); 
     2407                info[i].tx_power2 = TXPOWER_G_FROM_DEV(tx_power2[i]); 
     2408        } 
     2409 
     2410        if (spec->num_channels > 14) { 
     2411                tx_power1 = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_A1); 
     2412                tx_power2 = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_A2); 
     2413 
     2414                for (i = 14; i < spec->num_channels; i++) { 
     2415                        info[i].tx_power1 = TXPOWER_A_FROM_DEV(tx_power1[i]); 
     2416                        info[i].tx_power2 = TXPOWER_A_FROM_DEV(tx_power2[i]); 
     2417                } 
     2418        } 
     2419 
     2420        return 0; 
     2421} 
     2422 
     2423static int rt2800pci_probe_hw(struct rt2x00_dev *rt2x00dev) 
     2424{ 
     2425        int retval; 
     2426 
     2427        /* 
     2428         * Allocate eeprom data. 
     2429         */ 
     2430        retval = rt2800pci_validate_eeprom(rt2x00dev); 
     2431        if (retval) 
     2432                return retval; 
     2433 
     2434        retval = rt2800pci_init_eeprom(rt2x00dev); 
     2435        if (retval) 
     2436                return retval; 
     2437 
     2438        /* 
     2439         * Initialize hw specifications. 
     2440         */ 
     2441        retval = rt2800pci_probe_hw_mode(rt2x00dev); 
     2442        if (retval) 
     2443                return retval; 
     2444 
     2445        /* 
     2446         * This device requires firmware. 
     2447         */ 
     2448        __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags); 
     2449        if (!modparam_nohwcrypt) 
     2450                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags); 
     2451 
     2452        /* 
     2453         * Set the rssi offset. 
     2454         */ 
     2455        rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET; 
     2456 
     2457        return 0; 
     2458} 
     2459 
     2460/* 
     2461 * IEEE80211 stack callback functions. 
     2462 */ 
     2463static int rt2800pci_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 
     2464{ 
     2465        struct rt2x00_dev *rt2x00dev = hw->priv; 
     2466        u32 reg; 
     2467 
     2468        rt2x00pci_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
     2469        rt2x00_set_field32(&reg, TX_RTS_CFG_RTS_THRES, value); 
     2470        rt2x00pci_register_write(rt2x00dev, TX_RTS_CFG, reg); 
     2471 
     2472        rt2x00pci_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
     2473        rt2x00_set_field32(&reg, CCK_PROT_CFG_RTS_TH_EN, 1); 
     2474        rt2x00pci_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
     2475 
     2476        rt2x00pci_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
     2477        rt2x00_set_field32(&reg, OFDM_PROT_CFG_RTS_TH_EN, 1); 
     2478        rt2x00pci_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
     2479 
     2480        rt2x00pci_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
     2481        rt2x00_set_field32(&reg, MM20_PROT_CFG_RTS_TH_EN, 1); 
     2482        rt2x00pci_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
     2483 
     2484        rt2x00pci_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
     2485        rt2x00_set_field32(&reg, MM40_PROT_CFG_RTS_TH_EN, 1); 
     2486        rt2x00pci_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
     2487 
     2488        rt2x00pci_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
     2489        rt2x00_set_field32(&reg, GF20_PROT_CFG_RTS_TH_EN, 1); 
     2490        rt2x00pci_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
     2491 
     2492        rt2x00pci_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
     2493        rt2x00_set_field32(&reg, GF40_PROT_CFG_RTS_TH_EN, 1); 
     2494        rt2x00pci_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
     2495 
     2496        return 0; 
     2497} 
     2498 
     2499static int rt2800pci_conf_tx(struct ieee80211_hw *hw, u16 queue_idx, 
     2500                             const struct ieee80211_tx_queue_params *params) 
     2501{ 
     2502        struct rt2x00_dev *rt2x00dev = hw->priv; 
     2503        struct data_queue *queue; 
     2504        struct rt2x00_field32 field; 
     2505        int retval; 
     2506        u32 reg; 
     2507        u32 offset; 
     2508 
     2509        /* 
     2510         * First pass the configuration through rt2x00lib, that will 
     2511         * update the queue settings and validate the input. After that 
     2512         * we are free to update the registers based on the value 
     2513         * in the queue parameter. 
     2514         */ 
     2515        retval = rt2x00mac_conf_tx(hw, queue_idx, params); 
     2516        if (retval) 
     2517                return retval; 
     2518 
     2519        queue = rt2x00queue_get_queue(rt2x00dev, queue_idx); 
     2520 
     2521        /* Update WMM TXOP register */ 
     2522        if (queue_idx < 2) { 
     2523                field.bit_offset = queue_idx * 16; 
     2524                field.bit_mask = 0xffff << field.bit_offset; 
     2525 
     2526                rt2x00pci_register_read(rt2x00dev, WMM_TXOP0_CFG, &reg); 
     2527                rt2x00_set_field32(&reg, field, queue->txop); 
     2528                rt2x00pci_register_write(rt2x00dev, WMM_TXOP0_CFG, reg); 
     2529        } else if (queue_idx < 4) { 
     2530                field.bit_offset = (queue_idx - 2) * 16; 
     2531                field.bit_mask = 0xffff << field.bit_offset; 
     2532 
     2533                rt2x00pci_register_read(rt2x00dev, WMM_TXOP1_CFG, &reg); 
     2534                rt2x00_set_field32(&reg, field, queue->txop); 
     2535                rt2x00pci_register_write(rt2x00dev, WMM_TXOP1_CFG, reg); 
     2536        } 
     2537 
     2538        /* Update WMM registers */ 
     2539        field.bit_offset = queue_idx * 4; 
     2540        field.bit_mask = 0xf << field.bit_offset; 
     2541 
     2542        rt2x00pci_register_read(rt2x00dev, WMM_AIFSN_CFG, &reg); 
     2543        rt2x00_set_field32(&reg, field, queue->aifs); 
     2544        rt2x00pci_register_write(rt2x00dev, WMM_AIFSN_CFG, reg); 
     2545 
     2546        rt2x00pci_register_read(rt2x00dev, WMM_CWMIN_CFG, &reg); 
     2547        rt2x00_set_field32(&reg, field, queue->cw_min); 
     2548        rt2x00pci_register_write(rt2x00dev, WMM_CWMIN_CFG, reg); 
     2549 
     2550        rt2x00pci_register_read(rt2x00dev, WMM_CWMAX_CFG, &reg); 
     2551        rt2x00_set_field32(&reg, field, queue->cw_max); 
     2552        rt2x00pci_register_write(rt2x00dev, WMM_CWMAX_CFG, reg); 
     2553 
     2554        /* Update EDCA registers */ 
     2555        if (queue_idx < 4) { 
     2556                offset = EDCA_AC0_CFG + (sizeof(u32) * queue_idx); 
     2557 
     2558                rt2x00pci_register_read(rt2x00dev, offset, &reg); 
     2559                rt2x00_set_field32(&reg, EDCA_AC0_CFG_AIFSN, queue->aifs); 
     2560                rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMIN, queue->cw_min); 
     2561                rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMAX, queue->cw_max); 
     2562                rt2x00pci_register_write(rt2x00dev, offset, reg); 
     2563        } 
     2564 
     2565        return 0; 
     2566} 
     2567 
     2568static u64 rt2800pci_get_tsf(struct ieee80211_hw *hw) 
     2569{ 
     2570        struct rt2x00_dev *rt2x00dev = hw->priv; 
     2571        u64 tsf; 
     2572        u32 reg; 
     2573 
     2574        rt2x00pci_register_read(rt2x00dev, TSF_TIMER_DW1, &reg); 
     2575        tsf = (u64) rt2x00_get_field32(reg, TSF_TIMER_DW1_HIGH_WORD) << 32; 
     2576        rt2x00pci_register_read(rt2x00dev, TSF_TIMER_DW0, &reg); 
     2577        tsf |= rt2x00_get_field32(reg, TSF_TIMER_DW0_LOW_WORD); 
     2578 
     2579        return tsf; 
     2580} 
     2581 
     2582static const struct ieee80211_ops rt2800pci_mac80211_ops = { 
     2583        .tx                     = rt2x00mac_tx, 
     2584        .start                  = rt2x00mac_start, 
     2585        .stop                   = rt2x00mac_stop, 
     2586        .add_interface          = rt2x00mac_add_interface, 
     2587        .remove_interface       = rt2x00mac_remove_interface, 
     2588        .config                 = rt2x00mac_config, 
     2589        .config_interface       = rt2x00mac_config_interface, 
     2590        .configure_filter       = rt2x00mac_configure_filter, 
     2591        .set_key                = rt2x00mac_set_key, 
     2592        .get_stats              = rt2x00mac_get_stats, 
     2593        .set_rts_threshold      = rt2800pci_set_rts_threshold, 
     2594        .bss_info_changed       = rt2x00mac_bss_info_changed, 
     2595        .conf_tx                = rt2800pci_conf_tx, 
     2596        .get_tx_stats           = rt2x00mac_get_tx_stats, 
     2597        .get_tsf                = rt2800pci_get_tsf, 
     2598}; 
     2599 
     2600static const struct rt2x00lib_ops rt2800pci_rt2x00_ops = { 
     2601        .irq_handler            = rt2800pci_interrupt, 
     2602        .probe_hw               = rt2800pci_probe_hw, 
     2603        .get_firmware_name      = rt2800pci_get_firmware_name, 
     2604        .get_firmware_crc       = rt2800pci_get_firmware_crc, 
     2605        .load_firmware          = rt2800pci_load_firmware, 
     2606        .initialize             = rt2x00pci_initialize, 
     2607        .uninitialize           = rt2x00pci_uninitialize, 
     2608        .get_entry_state        = rt2800pci_get_entry_state, 
     2609        .clear_entry            = rt2800pci_clear_entry, 
     2610        .set_device_state       = rt2800pci_set_device_state, 
     2611        .rfkill_poll            = rt2800pci_rfkill_poll, 
     2612        .link_stats             = rt2800pci_link_stats, 
     2613        .reset_tuner            = rt2800pci_reset_tuner, 
     2614        .link_tuner             = rt2800pci_link_tuner, 
     2615        .write_tx_desc          = rt2800pci_write_tx_desc, 
     2616        .write_tx_data          = rt2x00pci_write_tx_data, 
     2617        .write_beacon           = rt2800pci_write_beacon, 
     2618        .kick_tx_queue          = rt2800pci_kick_tx_queue, 
     2619        .fill_rxdone            = rt2800pci_fill_rxdone, 
     2620        .config_shared_key      = rt2800pci_config_shared_key, 
     2621        .config_pairwise_key    = rt2800pci_config_pairwise_key, 
     2622        .config_filter          = rt2800pci_config_filter, 
     2623        .config_intf            = rt2800pci_config_intf, 
     2624        .config_erp             = rt2800pci_config_erp, 
     2625        .config_ant             = rt2800pci_config_ant, 
     2626        .config                 = rt2800pci_config, 
     2627}; 
     2628 
     2629static const struct data_queue_desc rt2800pci_queue_rx = { 
     2630        .entry_num              = RX_ENTRIES, 
     2631        .data_size              = DATA_FRAME_SIZE, 
     2632        .desc_size              = RXD_DESC_SIZE, 
     2633        .priv_size              = sizeof(struct queue_entry_priv_pci), 
     2634}; 
     2635 
     2636static const struct data_queue_desc rt2800pci_queue_tx = { 
     2637        .entry_num              = TX_ENTRIES, 
     2638        .data_size              = DATA_FRAME_SIZE, 
     2639        .desc_size              = TXD_DESC_SIZE, 
     2640        .priv_size              = sizeof(struct queue_entry_priv_pci), 
     2641}; 
     2642 
     2643static const struct data_queue_desc rt2800pci_queue_bcn = { 
     2644        .entry_num              = 8 * BEACON_ENTRIES, 
     2645        .data_size              = 0, /* No DMA required for beacons */ 
     2646        .desc_size              = TXWI_DESC_SIZE, 
     2647        .priv_size              = sizeof(struct queue_entry_priv_pci), 
     2648}; 
     2649 
     2650static const struct rt2x00_ops rt2800pci_ops = { 
     2651        .name           = KBUILD_MODNAME, 
     2652        .max_sta_intf   = 1, 
     2653        .max_ap_intf    = 8, 
     2654        .eeprom_size    = EEPROM_SIZE, 
     2655        .rf_size        = RF_SIZE, 
     2656        .tx_queues      = NUM_TX_QUEUES, 
     2657        .rx             = &rt2800pci_queue_rx, 
     2658        .tx             = &rt2800pci_queue_tx, 
     2659        .bcn            = &rt2800pci_queue_bcn, 
     2660        .lib            = &rt2800pci_rt2x00_ops, 
     2661        .hw             = &rt2800pci_mac80211_ops, 
     2662#ifdef CONFIG_RT2X00_LIB_DEBUGFS 
     2663        .debugfs        = &rt2800pci_rt2x00debug, 
     2664#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 
     2665}; 
     2666 
     2667/* 
     2668 * RT2800pci module information. 
     2669 */ 
     2670static struct pci_device_id rt2800pci_device_table[] = { 
     2671        { PCI_DEVICE(0x1814, 0x0601), PCI_DEVICE_DATA(&rt2800pci_ops) }, 
     2672        { PCI_DEVICE(0x1814, 0x0681), PCI_DEVICE_DATA(&rt2800pci_ops) }, 
     2673        { PCI_DEVICE(0x1814, 0x0701), PCI_DEVICE_DATA(&rt2800pci_ops) }, 
     2674        { PCI_DEVICE(0x1814, 0x0781), PCI_DEVICE_DATA(&rt2800pci_ops) }, 
     2675        { PCI_DEVICE(0x1a3b, 0x1059), PCI_DEVICE_DATA(&rt2800pci_ops) }, 
     2676        { 0, } 
     2677}; 
     2678 
     2679MODULE_AUTHOR(DRV_PROJECT); 
     2680MODULE_VERSION(DRV_VERSION); 
     2681MODULE_DESCRIPTION("Ralink RT2800 PCI & PCMCIA Wireless LAN driver."); 
     2682MODULE_SUPPORTED_DEVICE("Ralink RT2860 PCI & PCMCIA chipset based cards"); 
     2683MODULE_DEVICE_TABLE(pci, rt2800pci_device_table); 
     2684MODULE_FIRMWARE(FIRMWARE_RT2860); 
     2685MODULE_LICENSE("GPL"); 
     2686 
     2687static struct pci_driver rt2800pci_driver = { 
     2688        .name           = KBUILD_MODNAME, 
     2689        .id_table       = rt2800pci_device_table, 
     2690        .probe          = rt2x00pci_probe, 
     2691        .remove         = __devexit_p(rt2x00pci_remove), 
     2692        .suspend        = rt2x00pci_suspend, 
     2693        .resume         = rt2x00pci_resume, 
     2694}; 
     2695 
     2696static int __init rt2800pci_init(void) 
     2697{ 
     2698        return pci_register_driver(&rt2800pci_driver); 
     2699} 
     2700 
     2701static void __exit rt2800pci_exit(void) 
     2702{ 
     2703        pci_unregister_driver(&rt2800pci_driver); 
     2704} 
     2705 
     2706module_init(rt2800pci_init); 
     2707module_exit(rt2800pci_exit); 
  • new file drivers/net/wireless/rt2x00/rt2800pci.h

    - +  
     1/* 
     2        Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     3        <http://rt2x00.serialmonkey.com> 
     4 
     5        This program is free software; you can redistribute it and/or modify 
     6        it under the terms of the GNU General Public License as published by 
     7        the Free Software Foundation; either version 2 of the License, or 
     8        (at your option) any later version. 
     9 
     10        This program is distributed in the hope that it will be useful, 
     11        but WITHOUT ANY WARRANTY; without even the implied warranty of 
     12        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
     13        GNU General Public License for more details. 
     14 
     15        You should have received a copy of the GNU General Public License 
     16        along with this program; if not, write to the 
     17        Free Software Foundation, Inc., 
     18        59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
     19 */ 
     20 
     21/* 
     22        Module: rt2800pci 
     23        Abstract: Data structures and registers for the rt2800pci module. 
     24        Supported chipsets: RT2800E & RT2800ED. 
     25 */ 
     26 
     27#ifndef RT2800PCI_H 
     28#define RT2800PCI_H 
     29 
     30/* 
     31 * RF chip defines. 
     32 * 
     33 * RF2820 2.4G 2T3R 
     34 * RF2850 2.4G/5G 2T3R 
     35 * RF2720 2.4G 1T2R 
     36 * RF2750 2.4G/5G 1T2R 
     37 * RF3020 2.4G 1T1R 
     38 * RF2020 2.4G B/G 
     39 */ 
     40#define RF2820                          0x0001 
     41#define RF2850                          0x0002 
     42#define RF2720                          0x0003 
     43#define RF2750                          0x0004 
     44#define RF3020                          0x0005 
     45#define RF2020                          0x0006 
     46 
     47/* 
     48 * RT2860 version 
     49 */ 
     50#define RT2860_VERSION_C                0x0100 
     51#define RT2860_VERSION_D                0x0101 
     52#define RT2860_VERSION_E                0x0200 
     53 
     54/* 
     55 * Signal information. 
     56 * Defaul offset is required for RSSI <-> dBm conversion. 
     57 */ 
     58#define DEFAULT_RSSI_OFFSET             120 /* FIXME */ 
     59 
     60/* 
     61 * Register layout information. 
     62 */ 
     63#define CSR_REG_BASE                    0x1000 
     64#define CSR_REG_SIZE                    0x0800 
     65#define EEPROM_BASE                     0x0000 
     66#define EEPROM_SIZE                     0x0110 
     67#define BBP_BASE                        0x0000 
     68#define BBP_SIZE                        0x0080 
     69#define RF_BASE                         0x0000 
     70#define RF_SIZE                         0x0014 
     71 
     72/* 
     73 * Number of TX queues. 
     74 */ 
     75#define NUM_TX_QUEUES                   4 
     76 
     77/* 
     78 * PCI registers. 
     79 */ 
     80 
     81/* 
     82 * PCI Configuration Header 
     83 */ 
     84#define PCI_CONFIG_HEADER_VENDOR        0x0000 
     85#define PCI_CONFIG_HEADER_DEVICE        0x0002 
     86 
     87/* 
     88 * E2PROM_CSR: EEPROM control register. 
     89 * RELOAD: Write 1 to reload eeprom content. 
     90 * TYPE_93C46: 1: 93c46, 0:93c66. 
     91 * LOAD_STATUS: 1:loading, 0:done. 
     92 */ 
     93#define E2PROM_CSR                      0x0004 
     94#define E2PROM_CSR_DATA_CLOCK           FIELD32(0x00000001) 
     95#define E2PROM_CSR_CHIP_SELECT          FIELD32(0x00000002) 
     96#define E2PROM_CSR_DATA_IN              FIELD32(0x00000004) 
     97#define E2PROM_CSR_DATA_OUT             FIELD32(0x00000008) 
     98#define E2PROM_CSR_TYPE_93C46           FIELD32(0x00000020) 
     99#define E2PROM_CSR_LOAD_STATUS          FIELD32(0x00000040) 
     100#define E2PROM_CSR_RELOAD               FIELD32(0x00000080) 
     101 
     102/* 
     103 * HOST-MCU shared memory 
     104 */ 
     105#define HOST_CMD_CSR                    0x0404 
     106#define HOST_CMD_CSR_HOST_COMMAND       FIELD32(0x000000ff) 
     107 
     108/* 
     109 * INT_SOURCE_CSR: Interrupt source register. 
     110 * Write one to clear corresponding bit. 
     111 * TX_FIFO_STATUS: FIFO Statistics is full, sw should read 0x171c 
     112 */ 
     113#define INT_SOURCE_CSR                  0x0200 
     114#define INT_SOURCE_CSR_RXDELAYINT       FIELD32(0x00000001) 
     115#define INT_SOURCE_CSR_TXDELAYINT       FIELD32(0x00000002) 
     116#define INT_SOURCE_CSR_RX_DONE          FIELD32(0x00000004) 
     117#define INT_SOURCE_CSR_AC0_DMA_DONE     FIELD32(0x00000008) 
     118#define INT_SOURCE_CSR_AC1_DMA_DONE     FIELD32(0x00000010) 
     119#define INT_SOURCE_CSR_AC2_DMA_DONE     FIELD32(0x00000020) 
     120#define INT_SOURCE_CSR_AC3_DMA_DONE     FIELD32(0x00000040) 
     121#define INT_SOURCE_CSR_HCCA_DMA_DONE    FIELD32(0x00000080) 
     122#define INT_SOURCE_CSR_MGMT_DMA_DONE    FIELD32(0x00000100) 
     123#define INT_SOURCE_CSR_MCU_COMMAND      FIELD32(0x00000200) 
     124#define INT_SOURCE_CSR_RXTX_COHERENT    FIELD32(0x00000400) 
     125#define INT_SOURCE_CSR_TBTT             FIELD32(0x00000800) 
     126#define INT_SOURCE_CSR_PRE_TBTT         FIELD32(0x00001000) 
     127#define INT_SOURCE_CSR_TX_FIFO_STATUS   FIELD32(0x00002000) 
     128#define INT_SOURCE_CSR_AUTO_WAKEUP      FIELD32(0x00004000) 
     129#define INT_SOURCE_CSR_GPTIMER          FIELD32(0x00008000) 
     130#define INT_SOURCE_CSR_RX_COHERENT      FIELD32(0x00010000) 
     131#define INT_SOURCE_CSR_TX_COHERENT      FIELD32(0x00020000) 
     132 
     133/* 
     134 * INT_MASK_CSR: Interrupt MASK register. 1: the interrupt is mask OFF. 
     135 */ 
     136#define INT_MASK_CSR                    0x0204 
     137#define INT_MASK_CSR_RXDELAYINT         FIELD32(0x00000001) 
     138#define INT_MASK_CSR_TXDELAYINT         FIELD32(0x00000002) 
     139#define INT_MASK_CSR_RX_DONE            FIELD32(0x00000004) 
     140#define INT_MASK_CSR_AC0_DMA_DONE       FIELD32(0x00000008) 
     141#define INT_MASK_CSR_AC1_DMA_DONE       FIELD32(0x00000010) 
     142#define INT_MASK_CSR_AC2_DMA_DONE       FIELD32(0x00000020) 
     143#define INT_MASK_CSR_AC3_DMA_DONE       FIELD32(0x00000040) 
     144#define INT_MASK_CSR_HCCA_DMA_DONE      FIELD32(0x00000080) 
     145#define INT_MASK_CSR_MGMT_DMA_DONE      FIELD32(0x00000100) 
     146#define INT_MASK_CSR_MCU_COMMAND        FIELD32(0x00000200) 
     147#define INT_MASK_CSR_RXTX_COHERENT      FIELD32(0x00000400) 
     148#define INT_MASK_CSR_TBTT               FIELD32(0x00000800) 
     149#define INT_MASK_CSR_PRE_TBTT           FIELD32(0x00001000) 
     150#define INT_MASK_CSR_TX_FIFO_STATUS     FIELD32(0x00002000) 
     151#define INT_MASK_CSR_AUTO_WAKEUP        FIELD32(0x00004000) 
     152#define INT_MASK_CSR_GPTIMER            FIELD32(0x00008000) 
     153#define INT_MASK_CSR_RX_COHERENT        FIELD32(0x00010000) 
     154#define INT_MASK_CSR_TX_COHERENT        FIELD32(0x00020000) 
     155 
     156/* 
     157 * WPDMA_GLO_CFG 
     158 */ 
     159#define WPDMA_GLO_CFG                   0x0208 
     160#define WPDMA_GLO_CFG_ENABLE_TX_DMA     FIELD32(0x00000001) 
     161#define WPDMA_GLO_CFG_TX_DMA_BUSY       FIELD32(0x00000002) 
     162#define WPDMA_GLO_CFG_ENABLE_RX_DMA     FIELD32(0x00000004) 
     163#define WPDMA_GLO_CFG_RX_DMA_BUSY       FIELD32(0x00000008) 
     164#define WPDMA_GLO_CFG_WP_DMA_BURST_SIZE FIELD32(0x00000030) 
     165#define WPDMA_GLO_CFG_TX_WRITEBACK_DONE FIELD32(0x00000040) 
     166#define WPDMA_GLO_CFG_BIG_ENDIAN        FIELD32(0x00000080) 
     167#define WPDMA_GLO_CFG_RX_HDR_SCATTER    FIELD32(0x0000ff00) 
     168#define WPDMA_GLO_CFG_HDR_SEG_LEN       FIELD32(0xffff0000) 
     169 
     170/* 
     171 * WPDMA_RST_IDX 
     172 */ 
     173#define WPDMA_RST_IDX                   0x020c 
     174#define WPDMA_RST_IDX_DTX_IDX0          FIELD32(0x00000001) 
     175#define WPDMA_RST_IDX_DTX_IDX1          FIELD32(0x00000002) 
     176#define WPDMA_RST_IDX_DTX_IDX2          FIELD32(0x00000004) 
     177#define WPDMA_RST_IDX_DTX_IDX3          FIELD32(0x00000008) 
     178#define WPDMA_RST_IDX_DTX_IDX4          FIELD32(0x00000010) 
     179#define WPDMA_RST_IDX_DTX_IDX5          FIELD32(0x00000020) 
     180#define WPDMA_RST_IDX_DRX_IDX0          FIELD32(0x00010000) 
     181 
     182/* 
     183 * DELAY_INT_CFG 
     184 */ 
     185#define DELAY_INT_CFG                   0x0210 
     186#define DELAY_INT_CFG_RXMAX_PTIME       FIELD32(0x000000ff) 
     187#define DELAY_INT_CFG_RXMAX_PINT        FIELD32(0x00007f00) 
     188#define DELAY_INT_CFG_RXDLY_INT_EN      FIELD32(0x00008000) 
     189#define DELAY_INT_CFG_TXMAX_PTIME       FIELD32(0x00ff0000) 
     190#define DELAY_INT_CFG_TXMAX_PINT        FIELD32(0x7f000000) 
     191#define DELAY_INT_CFG_TXDLY_INT_EN      FIELD32(0x80000000) 
     192 
     193/* 
     194 * WMM_AIFSN_CFG: Aifsn for each EDCA AC 
     195 * AIFSN0: AC_BE 
     196 * AIFSN1: AC_BK 
     197 * AIFSN1: AC_VI 
     198 * AIFSN1: AC_VO 
     199 */ 
     200#define WMM_AIFSN_CFG                   0x0214 
     201#define WMM_AIFSN_CFG_AIFSN0            FIELD32(0x0000000f) 
     202#define WMM_AIFSN_CFG_AIFSN1            FIELD32(0x000000f0) 
     203#define WMM_AIFSN_CFG_AIFSN2            FIELD32(0x00000f00) 
     204#define WMM_AIFSN_CFG_AIFSN3            FIELD32(0x0000f000) 
     205 
     206/* 
     207 * WMM_CWMIN_CSR: CWmin for each EDCA AC 
     208 * CWMIN0: AC_BE 
     209 * CWMIN1: AC_BK 
     210 * CWMIN1: AC_VI 
     211 * CWMIN1: AC_VO 
     212 */ 
     213#define WMM_CWMIN_CFG                   0x0218 
     214#define WMM_CWMIN_CFG_CWMIN0            FIELD32(0x0000000f) 
     215#define WMM_CWMIN_CFG_CWMIN1            FIELD32(0x000000f0) 
     216#define WMM_CWMIN_CFG_CWMIN2            FIELD32(0x00000f00) 
     217#define WMM_CWMIN_CFG_CWMIN3            FIELD32(0x0000f000) 
     218 
     219/* 
     220 * WMM_CWMAX_CSR: CWmax for each EDCA AC 
     221 * CWMAX0: AC_BE 
     222 * CWMAX1: AC_BK 
     223 * CWMAX1: AC_VI 
     224 * CWMAX1: AC_VO 
     225 */ 
     226#define WMM_CWMAX_CFG                   0x021c 
     227#define WMM_CWMAX_CFG_CWMAX0            FIELD32(0x0000000f) 
     228#define WMM_CWMAX_CFG_CWMAX1            FIELD32(0x000000f0) 
     229#define WMM_CWMAX_CFG_CWMAX2            FIELD32(0x00000f00) 
     230#define WMM_CWMAX_CFG_CWMAX3            FIELD32(0x0000f000) 
     231 
     232/* 
     233 * AC_TXOP0: AC_BK/AC_BE TXOP register 
     234 * AC0TXOP: AC_BK in unit of 32us 
     235 * AC1TXOP: AC_BE in unit of 32us 
     236 */ 
     237#define WMM_TXOP0_CFG                   0x0220 
     238#define WMM_TXOP0_CFG_AC0TXOP           FIELD32(0x0000ffff) 
     239#define WMM_TXOP0_CFG_AC1TXOP           FIELD32(0xffff0000) 
     240 
     241/* 
     242 * AC_TXOP1: AC_VO/AC_VI TXOP register 
     243 * AC2TXOP: AC_VI in unit of 32us 
     244 * AC3TXOP: AC_VO in unit of 32us 
     245 */ 
     246#define WMM_TXOP1_CFG                   0x0224 
     247#define WMM_TXOP1_CFG_AC2TXOP           FIELD32(0x0000ffff) 
     248#define WMM_TXOP1_CFG_AC3TXOP           FIELD32(0xffff0000) 
     249 
     250/* 
     251 * RINGREG_DIFF 
     252 */ 
     253#define RINGREG_DIFF                    0x0010 
     254 
     255/* 
     256 * GPIO_CTRL_CFG: 
     257 */ 
     258#define GPIO_CTRL_CFG                   0x0228 
     259#define GPIO_CTRL_CFG_BIT0              FIELD32(0x00000001) 
     260#define GPIO_CTRL_CFG_BIT1              FIELD32(0x00000002) 
     261#define GPIO_CTRL_CFG_BIT2              FIELD32(0x00000004) 
     262#define GPIO_CTRL_CFG_BIT3              FIELD32(0x00000008) 
     263#define GPIO_CTRL_CFG_BIT4              FIELD32(0x00000010) 
     264#define GPIO_CTRL_CFG_BIT5              FIELD32(0x00000020) 
     265#define GPIO_CTRL_CFG_BIT6              FIELD32(0x00000040) 
     266#define GPIO_CTRL_CFG_BIT7              FIELD32(0x00000080) 
     267#define GPIO_CTRL_CFG_BIT8              FIELD32(0x00000100) 
     268 
     269/* 
     270 * MCU_CMD_CFG 
     271 */ 
     272#define MCU_CMD_CFG                     0x022c 
     273 
     274/* 
     275 * AC_BK register offsets 
     276 */ 
     277#define TX_BASE_PTR0                    0x0230 
     278#define TX_MAX_CNT0                     0x0234 
     279#define TX_CTX_IDX0                     0x0238 
     280#define TX_DTX_IDX0                     0x023c 
     281 
     282/* 
     283 * AC_BE register offsets 
     284 */ 
     285#define TX_BASE_PTR1                    0x0240 
     286#define TX_MAX_CNT1                     0x0244 
     287#define TX_CTX_IDX1                     0x0248 
     288#define TX_DTX_IDX1                     0x024c 
     289 
     290/* 
     291 * AC_VI register offsets 
     292 */ 
     293#define TX_BASE_PTR2                    0x0250 
     294#define TX_MAX_CNT2                     0x0254 
     295#define TX_CTX_IDX2                     0x0258 
     296#define TX_DTX_IDX2                     0x025c 
     297 
     298/* 
     299 * AC_VO register offsets 
     300 */ 
     301#define TX_BASE_PTR3                    0x0260 
     302#define TX_MAX_CNT3                     0x0264 
     303#define TX_CTX_IDX3                     0x0268 
     304#define TX_DTX_IDX3                     0x026c 
     305 
     306/* 
     307 * HCCA register offsets 
     308 */ 
     309#define TX_BASE_PTR4                    0x0270 
     310#define TX_MAX_CNT4                     0x0274 
     311#define TX_CTX_IDX4                     0x0278 
     312#define TX_DTX_IDX4                     0x027c 
     313 
     314/* 
     315 * MGMT register offsets 
     316 */ 
     317#define TX_BASE_PTR5                    0x0280 
     318#define TX_MAX_CNT5                     0x0284 
     319#define TX_CTX_IDX5                     0x0288 
     320#define TX_DTX_IDX5                     0x028c 
     321 
     322/* 
     323 * Queue register offset macros 
     324 */ 
     325#define TX_QUEUE_REG_OFFSET             0x10 
     326#define TX_BASE_PTR(__x)                TX_BASE_PTR0 + ((__x) * TX_QUEUE_REG_OFFSET) 
     327#define TX_MAX_CNT(__x)                 TX_MAX_CNT0 + ((__x) * TX_QUEUE_REG_OFFSET) 
     328#define TX_CTX_IDX(__x)                 TX_CTX_IDX0 + ((__x) * TX_QUEUE_REG_OFFSET) 
     329#define TX_DTX_IDX(__x)                 TX_DTX_IDX0 + ((__x) * TX_QUEUE_REG_OFFSET) 
     330 
     331/* 
     332 * RX register offsets 
     333 */ 
     334#define RX_BASE_PTR                     0x0290 
     335#define RX_MAX_CNT                      0x0294 
     336#define RX_CRX_IDX                      0x0298 
     337#define RX_DRX_IDX                      0x029c 
     338 
     339/* 
     340 * PBF_SYS_CTRL 
     341 * HOST_RAM_WRITE: enable Host program ram write selection 
     342 */ 
     343#define PBF_SYS_CTRL                    0x0400 
     344#define PBF_SYS_CTRL_READY              FIELD32(0x00000080) 
     345#define PBF_SYS_CTRL_HOST_RAM_WRITE     FIELD32(0x00010000) 
     346 
     347/* 
     348 * PBF  registers 
     349 * Most are for debug. Driver doesn't touch PBF register. 
     350 */ 
     351#define PBF_CFG                         0x0408 
     352#define PBF_MAX_PCNT                    0x040c 
     353#define PBF_CTRL                        0x0410 
     354#define PBF_INT_STA                     0x0414 
     355#define PBF_INT_ENA                     0x0418 
     356 
     357/* 
     358 * BCN_OFFSET0: 
     359 */ 
     360#define BCN_OFFSET0                     0x042c 
     361#define BCN_OFFSET0_BCN0                FIELD32(0x000000ff) 
     362#define BCN_OFFSET0_BCN1                FIELD32(0x0000ff00) 
     363#define BCN_OFFSET0_BCN2                FIELD32(0x00ff0000) 
     364#define BCN_OFFSET0_BCN3                FIELD32(0xff000000) 
     365 
     366/* 
     367 * BCN_OFFSET1: 
     368 */ 
     369#define BCN_OFFSET1                     0x0430 
     370#define BCN_OFFSET1_BCN4                FIELD32(0x000000ff) 
     371#define BCN_OFFSET1_BCN5                FIELD32(0x0000ff00) 
     372#define BCN_OFFSET1_BCN6                FIELD32(0x00ff0000) 
     373#define BCN_OFFSET1_BCN7                FIELD32(0xff000000) 
     374 
     375/* 
     376 * PBF  registers 
     377 * Most are for debug. Driver doesn't touch PBF register. 
     378 */ 
     379#define TXRXQ_PCNT                      0x0438 
     380#define PBF_DBG                         0x043c 
     381 
     382/* 
     383 * MAC Control/Status Registers(CSR). 
     384 * Some values are set in TU, whereas 1 TU == 1024 us. 
     385 */ 
     386 
     387/* 
     388 * MAC_CSR0: ASIC revision number. 
     389 * ASIC_REV: 0 
     390 * ASIC_VER: 2860 
     391 */ 
     392#define MAC_CSR0                        0x1000 
     393#define MAC_CSR0_ASIC_REV               FIELD32(0x0000ffff) 
     394#define MAC_CSR0_ASIC_VER               FIELD32(0xffff0000) 
     395 
     396/* 
     397 * MAC_SYS_CTRL: 
     398 */ 
     399#define MAC_SYS_CTRL                    0x1004 
     400#define MAC_SYS_CTRL_RESET_CSR          FIELD32(0x00000001) 
     401#define MAC_SYS_CTRL_RESET_BBP          FIELD32(0x00000002) 
     402#define MAC_SYS_CTRL_ENABLE_TX          FIELD32(0x00000004) 
     403#define MAC_SYS_CTRL_ENABLE_RX          FIELD32(0x00000008) 
     404#define MAC_SYS_CTRL_CONTINUOUS_TX      FIELD32(0x00000010) 
     405#define MAC_SYS_CTRL_LOOPBACK           FIELD32(0x00000020) 
     406#define MAC_SYS_CTRL_WLAN_HALT          FIELD32(0x00000040) 
     407#define MAC_SYS_CTRL_RX_TIMESTAMP       FIELD32(0x00000080) 
     408 
     409/* 
     410 * MAC_ADDR_DW0: STA MAC register 0 
     411 */ 
     412#define MAC_ADDR_DW0                    0x1008 
     413#define MAC_ADDR_DW0_BYTE0              FIELD32(0x000000ff) 
     414#define MAC_ADDR_DW0_BYTE1              FIELD32(0x0000ff00) 
     415#define MAC_ADDR_DW0_BYTE2              FIELD32(0x00ff0000) 
     416#define MAC_ADDR_DW0_BYTE3              FIELD32(0xff000000) 
     417 
     418/* 
     419 * MAC_ADDR_DW1: STA MAC register 1 
     420 * UNICAST_TO_ME_MASK: 
     421 * Used to mask off bits from byte 5 of the MAC address 
     422 * to determine the UNICAST_TO_ME bit for RX frames. 
     423 * The full mask is complemented by BSS_ID_MASK: 
     424 *    MASK = BSS_ID_MASK & UNICAST_TO_ME_MASK 
     425 */ 
     426#define MAC_ADDR_DW1                    0x100c 
     427#define MAC_ADDR_DW1_BYTE4              FIELD32(0x000000ff) 
     428#define MAC_ADDR_DW1_BYTE5              FIELD32(0x0000ff00) 
     429#define MAC_ADDR_DW1_UNICAST_TO_ME_MASK FIELD32(0x00ff0000) 
     430 
     431/* 
     432 * MAC_BSSID_DW0: BSSID register 0 
     433 */ 
     434#define MAC_BSSID_DW0                   0x1010 
     435#define MAC_BSSID_DW0_BYTE0             FIELD32(0x000000ff) 
     436#define MAC_BSSID_DW0_BYTE1             FIELD32(0x0000ff00) 
     437#define MAC_BSSID_DW0_BYTE2             FIELD32(0x00ff0000) 
     438#define MAC_BSSID_DW0_BYTE3             FIELD32(0xff000000) 
     439 
     440/* 
     441 * MAC_BSSID_DW1: BSSID register 1 
     442 * BSS_ID_MASK: 
     443 *     0: 1-BSSID mode (BSS index = 0) 
     444 *     1: 2-BSSID mode (BSS index: Byte5, bit 0) 
     445 *     2: 4-BSSID mode (BSS index: byte5, bit 0 - 1) 
     446 *     3: 8-BSSID mode (BSS index: byte5, bit 0 - 2) 
     447 * This mask is used to mask off bits 0, 1 and 2 of byte 5 of the 
     448 * BSSID. This will make sure that those bits will be ignored 
     449 * when determining the MY_BSS of RX frames. 
     450 */ 
     451#define MAC_BSSID_DW1                   0x1014 
     452#define MAC_BSSID_DW1_BYTE4             FIELD32(0x000000ff) 
     453#define MAC_BSSID_DW1_BYTE5             FIELD32(0x0000ff00) 
     454#define MAC_BSSID_DW1_BSS_ID_MASK       FIELD32(0x00030000) 
     455#define MAC_BSSID_DW1_BSS_BCN_NUM       FIELD32(0x001c0000) 
     456 
     457/* 
     458 * MAX_LEN_CFG: Maximum frame length register. 
     459 * MAX_MPDU: rt2860b max 16k bytes 
     460 * MAX_PSDU: Maximum PSDU length 
     461 *      (power factor) 0:2^13, 1:2^14, 2:2^15, 3:2^16 
     462 */ 
     463#define MAX_LEN_CFG                     0x1018 
     464#define MAX_LEN_CFG_MAX_MPDU            FIELD32(0x00000fff) 
     465#define MAX_LEN_CFG_MAX_PSDU            FIELD32(0x00003000) 
     466#define MAX_LEN_CFG_MIN_PSDU            FIELD32(0x0000c000) 
     467#define MAX_LEN_CFG_MIN_MPDU            FIELD32(0x000f0000) 
     468 
     469/* 
     470 * BBP_CSR_CFG: BBP serial control register 
     471 * VALUE: Register value to program into BBP 
     472 * REG_NUM: Selected BBP register 
     473 * READ_CONTROL: 0 write BBP, 1 read BBP 
     474 * BUSY: ASIC is busy executing BBP commands 
     475 * BBP_PAR_DUR: 0 4 MAC clocks, 1 8 MAC clocks 
     476 * BBP_RW_MODE: 0 serial, 1 paralell 
     477 */ 
     478#define BBP_CSR_CFG                     0x101c 
     479#define BBP_CSR_CFG_VALUE               FIELD32(0x000000ff) 
     480#define BBP_CSR_CFG_REGNUM              FIELD32(0x0000ff00) 
     481#define BBP_CSR_CFG_READ_CONTROL        FIELD32(0x00010000) 
     482#define BBP_CSR_CFG_BUSY                FIELD32(0x00020000) 
     483#define BBP_CSR_CFG_BBP_PAR_DUR         FIELD32(0x00040000) 
     484#define BBP_CSR_CFG_BBP_RW_MODE         FIELD32(0x00080000) 
     485 
     486/* 
     487 * RF_CSR_CFG0: RF control register 
     488 * REGID_AND_VALUE: Register value to program into RF 
     489 * BITWIDTH: Selected RF register 
     490 * STANDBYMODE: 0 high when standby, 1 low when standby 
     491 * SEL: 0 RF_LE0 activate, 1 RF_LE1 activate 
     492 * BUSY: ASIC is busy executing RF commands 
     493 */ 
     494#define RF_CSR_CFG0                     0x1020 
     495#define RF_CSR_CFG0_REGID_AND_VALUE     FIELD32(0x00ffffff) 
     496#define RF_CSR_CFG0_BITWIDTH            FIELD32(0x1f000000) 
     497#define RF_CSR_CFG0_REG_VALUE_BW        FIELD32(0x1fffffff) 
     498#define RF_CSR_CFG0_STANDBYMODE         FIELD32(0x20000000) 
     499#define RF_CSR_CFG0_SEL                 FIELD32(0x40000000) 
     500#define RF_CSR_CFG0_BUSY                FIELD32(0x80000000) 
     501 
     502/* 
     503 * RF_CSR_CFG1: RF control register 
     504 * REGID_AND_VALUE: Register value to program into RF 
     505 * RFGAP: Gap between BB_CONTROL_RF and RF_LE 
     506 *        0: 3 system clock cycle (37.5usec) 
     507 *        1: 5 system clock cycle (62.5usec) 
     508 */ 
     509#define RF_CSR_CFG1                     0x1024 
     510#define RF_CSR_CFG1_REGID_AND_VALUE     FIELD32(0x00ffffff) 
     511#define RF_CSR_CFG1_RFGAP               FIELD32(0x1f000000) 
     512 
     513/* 
     514 * RF_CSR_CFG2: RF control register 
     515 * VALUE: Register value to program into RF 
     516 * RFGAP: Gap between BB_CONTROL_RF and RF_LE 
     517 *        0: 3 system clock cycle (37.5usec) 
     518 *        1: 5 system clock cycle (62.5usec) 
     519 */ 
     520#define RF_CSR_CFG2                     0x1028 
     521#define RF_CSR_CFG2_VALUE               FIELD32(0x00ffffff) 
     522 
     523/* 
     524 * LED_CFG: LED control 
     525 * color LED's: 
     526 *   0: off 
     527 *   1: blinking upon TX2 
     528 *   2: periodic slow blinking 
     529 *   3: always on 
     530 * LED polarity: 
     531 *   0: active low 
     532 *   1: active high 
     533 */ 
     534#define LED_CFG                         0x102c 
     535#define LED_CFG_ON_PERIOD               FIELD32(0x000000ff) 
     536#define LED_CFG_OFF_PERIOD              FIELD32(0x0000ff00) 
     537#define LED_CFG_SLOW_BLINK_PERIOD       FIELD32(0x003f0000) 
     538#define LED_CFG_R_LED_MODE              FIELD32(0x03000000) 
     539#define LED_CFG_G_LED_MODE              FIELD32(0x0c000000) 
     540#define LED_CFG_Y_LED_MODE              FIELD32(0x30000000) 
     541#define LED_CFG_LED_POLAR               FIELD32(0x40000000) 
     542 
     543/* 
     544 * XIFS_TIME_CFG: MAC timing 
     545 * CCKM_SIFS_TIME: unit 1us. Applied after CCK RX/TX 
     546 * OFDM_SIFS_TIME: unit 1us. Applied after OFDM RX/TX 
     547 * OFDM_XIFS_TIME: unit 1us. Applied after OFDM RX 
     548 *      when MAC doesn't reference BBP signal BBRXEND 
     549 * EIFS: unit 1us 
     550 * BB_RXEND_ENABLE: reference RXEND signal to begin XIFS defer 
     551 * 
     552 */ 
     553#define XIFS_TIME_CFG                   0x1100 
     554#define XIFS_TIME_CFG_CCKM_SIFS_TIME    FIELD32(0x000000ff) 
     555#define XIFS_TIME_CFG_OFDM_SIFS_TIME    FIELD32(0x0000ff00) 
     556#define XIFS_TIME_CFG_OFDM_XIFS_TIME    FIELD32(0x000f0000) 
     557#define XIFS_TIME_CFG_EIFS              FIELD32(0x1ff00000) 
     558#define XIFS_TIME_CFG_BB_RXEND_ENABLE   FIELD32(0x20000000) 
     559 
     560/* 
     561 * BKOFF_SLOT_CFG: 
     562 */ 
     563#define BKOFF_SLOT_CFG                  0x1104 
     564#define BKOFF_SLOT_CFG_SLOT_TIME        FIELD32(0x000000ff) 
     565#define BKOFF_SLOT_CFG_CC_DELAY_TIME    FIELD32(0x0000ff00) 
     566 
     567/* 
     568 * NAV_TIME_CFG: 
     569 */ 
     570#define NAV_TIME_CFG                    0x1108 
     571#define NAV_TIME_CFG_SIFS               FIELD32(0x000000ff) 
     572#define NAV_TIME_CFG_SLOT_TIME          FIELD32(0x0000ff00) 
     573#define NAV_TIME_CFG_EIFS               FIELD32(0x01ff0000) 
     574#define NAV_TIME_ZERO_SIFS              FIELD32(0x02000000) 
     575 
     576/* 
     577 * CH_TIME_CFG: count as channel busy 
     578 */ 
     579#define CH_TIME_CFG                     0x110c 
     580 
     581/* 
     582 * PBF_LIFE_TIMER: TX/RX MPDU timestamp timer (free run) Unit: 1us 
     583 */ 
     584#define PBF_LIFE_TIMER                  0x1110 
     585 
     586/* 
     587 * BCN_TIME_CFG: 
     588 * BEACON_INTERVAL: in unit of 1/16 TU 
     589 * TSF_TICKING: Enable TSF auto counting 
     590 * TSF_SYNC: Enable TSF sync, 00: disable, 01: infra mode, 10: ad-hoc mode 
     591 * BEACON_GEN: Enable beacon generator 
     592 */ 
     593#define BCN_TIME_CFG                    0x1114 
     594#define BCN_TIME_CFG_BEACON_INTERVAL    FIELD32(0x0000ffff) 
     595#define BCN_TIME_CFG_TSF_TICKING        FIELD32(0x00010000) 
     596#define BCN_TIME_CFG_TSF_SYNC           FIELD32(0x00060000) 
     597#define BCN_TIME_CFG_TBTT_ENABLE        FIELD32(0x00080000) 
     598#define BCN_TIME_CFG_BEACON_GEN         FIELD32(0x00100000) 
     599#define BCN_TIME_CFG_TX_TIME_COMPENSATE FIELD32(0xf0000000) 
     600 
     601/* 
     602 * TBTT_SYNC_CFG: 
     603 */ 
     604#define TBTT_SYNC_CFG                   0x1118 
     605 
     606/* 
     607 * TSF_TIMER_DW0: Local lsb TSF timer, read-only 
     608 */ 
     609#define TSF_TIMER_DW0                   0x111c 
     610#define TSF_TIMER_DW0_LOW_WORD          FIELD32(0xffffffff) 
     611 
     612/* 
     613 * TSF_TIMER_DW1: Local msb TSF timer, read-only 
     614 */ 
     615#define TSF_TIMER_DW1                   0x1120 
     616#define TSF_TIMER_DW1_HIGH_WORD         FIELD32(0xffffffff) 
     617 
     618/* 
     619 * TBTT_TIMER: TImer remains till next TBTT, read-only 
     620 */ 
     621#define TBTT_TIMER                      0x1124 
     622 
     623/* 
     624 * INT_TIMER_CFG: 
     625 */ 
     626#define INT_TIMER_CFG                   0x1128 
     627 
     628/* 
     629 * INT_TIMER_EN: GP-timer and pre-tbtt Int enable 
     630 */ 
     631#define INT_TIMER_EN                    0x112c 
     632 
     633/* 
     634 * CH_IDLE_STA: channel idle time 
     635 */ 
     636#define CH_IDLE_STA                     0x1130 
     637 
     638/* 
     639 * CH_BUSY_STA: channel busy time 
     640 */ 
     641#define CH_BUSY_STA                     0x1134 
     642 
     643/* 
     644 * MAC_STATUS_CFG: 
     645 * BBP_RF_BUSY: When set to 0, BBP and RF are stable. 
     646 *      if 1 or higher one of the 2 registers is busy. 
     647 */ 
     648#define MAC_STATUS_CFG                  0x1200 
     649#define MAC_STATUS_CFG_BBP_RF_BUSY      FIELD32(0x00000003) 
     650 
     651/* 
     652 * PWR_PIN_CFG: 
     653 */ 
     654#define PWR_PIN_CFG                     0x1204 
     655 
     656/* 
     657 * AUTOWAKEUP_CFG: Manual power control / status register 
     658 * TBCN_BEFORE_WAKE: ForceWake has high privilege than PutToSleep when both set 
     659 * AUTOWAKE: 0:sleep, 1:awake 
     660 */ 
     661#define AUTOWAKEUP_CFG                  0x1208 
     662#define AUTOWAKEUP_CFG_AUTO_LEAD_TIME   FIELD32(0x000000ff) 
     663#define AUTOWAKEUP_CFG_TBCN_BEFORE_WAKE FIELD32(0x00007f00) 
     664#define AUTOWAKEUP_CFG_AUTOWAKE         FIELD32(0x00008000) 
     665 
     666/* 
     667 * EDCA_AC0_CFG: 
     668 */ 
     669#define EDCA_AC0_CFG                    0x1300 
     670#define EDCA_AC0_CFG_AC_TX_OP           FIELD32(0x000000ff) 
     671#define EDCA_AC0_CFG_AIFSN              FIELD32(0x00000f00) 
     672#define EDCA_AC0_CFG_CWMIN              FIELD32(0x0000f000) 
     673#define EDCA_AC0_CFG_CWMAX              FIELD32(0x000f0000) 
     674 
     675/* 
     676 * EDCA_AC1_CFG: 
     677 */ 
     678#define EDCA_AC1_CFG                    0x1304 
     679#define EDCA_AC1_CFG_AC_TX_OP           FIELD32(0x000000ff) 
     680#define EDCA_AC1_CFG_AIFSN              FIELD32(0x00000f00) 
     681#define EDCA_AC1_CFG_CWMIN              FIELD32(0x0000f000) 
     682#define EDCA_AC1_CFG_CWMAX              FIELD32(0x000f0000) 
     683 
     684/* 
     685 * EDCA_AC2_CFG: 
     686 */ 
     687#define EDCA_AC2_CFG                    0x1308 
     688#define EDCA_AC2_CFG_AC_TX_OP           FIELD32(0x000000ff) 
     689#define EDCA_AC2_CFG_AIFSN              FIELD32(0x00000f00) 
     690#define EDCA_AC2_CFG_CWMIN              FIELD32(0x0000f000) 
     691#define EDCA_AC2_CFG_CWMAX              FIELD32(0x000f0000) 
     692 
     693/* 
     694 * EDCA_AC3_CFG: 
     695 */ 
     696#define EDCA_AC3_CFG                    0x130c 
     697#define EDCA_AC3_CFG_AC_TX_OP           FIELD32(0x000000ff) 
     698#define EDCA_AC3_CFG_AIFSN              FIELD32(0x00000f00) 
     699#define EDCA_AC3_CFG_CWMIN              FIELD32(0x0000f000) 
     700#define EDCA_AC3_CFG_CWMAX              FIELD32(0x000f0000) 
     701 
     702/* 
     703 * EDCA_TID_AC_MAP: 
     704 */ 
     705#define EDCA_TID_AC_MAP                 0x1310 
     706 
     707/* 
     708 * TX_PWR_CFG_0: 
     709 */ 
     710#define TX_PWR_CFG_0                    0x1314 
     711#define TX_PWR_CFG_0_1MBS               FIELD32(0x0000000f) 
     712#define TX_PWR_CFG_0_2MBS               FIELD32(0x000000f0) 
     713#define TX_PWR_CFG_0_55MBS              FIELD32(0x00000f00) 
     714#define TX_PWR_CFG_0_11MBS              FIELD32(0x0000f000) 
     715#define TX_PWR_CFG_0_6MBS               FIELD32(0x000f0000) 
     716#define TX_PWR_CFG_0_9MBS               FIELD32(0x00f00000) 
     717#define TX_PWR_CFG_0_12MBS              FIELD32(0x0f000000) 
     718#define TX_PWR_CFG_0_18MBS              FIELD32(0xf0000000) 
     719 
     720/* 
     721 * TX_PWR_CFG_1: 
     722 */ 
     723#define TX_PWR_CFG_1                    0x1318 
     724#define TX_PWR_CFG_1_24MBS              FIELD32(0x0000000f) 
     725#define TX_PWR_CFG_1_36MBS              FIELD32(0x000000f0) 
     726#define TX_PWR_CFG_1_48MBS              FIELD32(0x00000f00) 
     727#define TX_PWR_CFG_1_54MBS              FIELD32(0x0000f000) 
     728#define TX_PWR_CFG_1_MCS0               FIELD32(0x000f0000) 
     729#define TX_PWR_CFG_1_MCS1               FIELD32(0x00f00000) 
     730#define TX_PWR_CFG_1_MCS2               FIELD32(0x0f000000) 
     731#define TX_PWR_CFG_1_MCS3               FIELD32(0xf0000000) 
     732 
     733/* 
     734 * TX_PWR_CFG_2: 
     735 */ 
     736#define TX_PWR_CFG_2                    0x131c 
     737#define TX_PWR_CFG_2_MCS4               FIELD32(0x0000000f) 
     738#define TX_PWR_CFG_2_MCS5               FIELD32(0x000000f0) 
     739#define TX_PWR_CFG_2_MCS6               FIELD32(0x00000f00) 
     740#define TX_PWR_CFG_2_MCS7               FIELD32(0x0000f000) 
     741#define TX_PWR_CFG_2_MCS8               FIELD32(0x000f0000) 
     742#define TX_PWR_CFG_2_MCS9               FIELD32(0x00f00000) 
     743#define TX_PWR_CFG_2_MCS10              FIELD32(0x0f000000) 
     744#define TX_PWR_CFG_2_MCS11              FIELD32(0xf0000000) 
     745 
     746/* 
     747 * TX_PWR_CFG_3: 
     748 */ 
     749#define TX_PWR_CFG_3                    0x1320 
     750#define TX_PWR_CFG_3_MCS12              FIELD32(0x0000000f) 
     751#define TX_PWR_CFG_3_MCS13              FIELD32(0x000000f0) 
     752#define TX_PWR_CFG_3_MCS14              FIELD32(0x00000f00) 
     753#define TX_PWR_CFG_3_MCS15              FIELD32(0x0000f000) 
     754#define TX_PWR_CFG_3_UKNOWN1            FIELD32(0x000f0000) 
     755#define TX_PWR_CFG_3_UKNOWN2            FIELD32(0x00f00000) 
     756#define TX_PWR_CFG_3_UKNOWN3            FIELD32(0x0f000000) 
     757#define TX_PWR_CFG_3_UKNOWN4            FIELD32(0xf0000000) 
     758 
     759/* 
     760 * TX_PWR_CFG_4: 
     761 */ 
     762#define TX_PWR_CFG_4                    0x1324 
     763#define TX_PWR_CFG_4_UKNOWN5            FIELD32(0x0000000f) 
     764#define TX_PWR_CFG_4_UKNOWN6            FIELD32(0x000000f0) 
     765#define TX_PWR_CFG_4_UKNOWN7            FIELD32(0x00000f00) 
     766#define TX_PWR_CFG_4_UKNOWN8            FIELD32(0x0000f000) 
     767 
     768/* 
     769 * TX_PIN_CFG: 
     770 */ 
     771#define TX_PIN_CFG                      0x1328 
     772#define TX_PIN_CFG_PA_PE_A0_EN          FIELD32(0x00000001) 
     773#define TX_PIN_CFG_PA_PE_G0_EN          FIELD32(0x00000002) 
     774#define TX_PIN_CFG_PA_PE_A1_EN          FIELD32(0x00000004) 
     775#define TX_PIN_CFG_PA_PE_G1_EN          FIELD32(0x00000008) 
     776#define TX_PIN_CFG_PA_PE_A0_POL         FIELD32(0x00000010) 
     777#define TX_PIN_CFG_PA_PE_G0_POL         FIELD32(0x00000020) 
     778#define TX_PIN_CFG_PA_PE_A1_POL         FIELD32(0x00000040) 
     779#define TX_PIN_CFG_PA_PE_G1_POL         FIELD32(0x00000080) 
     780#define TX_PIN_CFG_LNA_PE_A0_EN         FIELD32(0x00000100) 
     781#define TX_PIN_CFG_LNA_PE_G0_EN         FIELD32(0x00000200) 
     782#define TX_PIN_CFG_LNA_PE_A1_EN         FIELD32(0x00000400) 
     783#define TX_PIN_CFG_LNA_PE_G1_EN         FIELD32(0x00000800) 
     784#define TX_PIN_CFG_LNA_PE_A0_POL        FIELD32(0x00001000) 
     785#define TX_PIN_CFG_LNA_PE_G0_POL        FIELD32(0x00002000) 
     786#define TX_PIN_CFG_LNA_PE_A1_POL        FIELD32(0x00004000) 
     787#define TX_PIN_CFG_LNA_PE_G1_POL        FIELD32(0x00008000) 
     788#define TX_PIN_CFG_RFTR_EN              FIELD32(0x00010000) 
     789#define TX_PIN_CFG_RFTR_POL             FIELD32(0x00020000) 
     790#define TX_PIN_CFG_TRSW_EN              FIELD32(0x00040000) 
     791#define TX_PIN_CFG_TRSW_POL             FIELD32(0x00080000) 
     792 
     793/* 
     794 * TX_BAND_CFG: 0x1 use upper 20MHz, 0x0 use lower 20MHz 
     795 */ 
     796#define TX_BAND_CFG                     0x132c 
     797#define TX_BAND_CFG_A                   FIELD32(0x00000002) 
     798#define TX_BAND_CFG_BG                  FIELD32(0x00000004) 
     799 
     800/* 
     801 * TX_SW_CFG0: 
     802 */ 
     803#define TX_SW_CFG0                      0x1330 
     804 
     805/* 
     806 * TX_SW_CFG1: 
     807 */ 
     808#define TX_SW_CFG1                      0x1334 
     809 
     810/* 
     811 * TX_SW_CFG2: 
     812 */ 
     813#define TX_SW_CFG2                      0x1338 
     814 
     815/* 
     816 * TXOP_THRES_CFG: 
     817 */ 
     818#define TXOP_THRES_CFG                  0x133c 
     819 
     820/* 
     821 * TXOP_CTRL_CFG: 
     822 */ 
     823#define TXOP_CTRL_CFG                   0x1340 
     824 
     825/* 
     826 * TX_RTS_CFG: 
     827 * RTS_THRES: unit:byte 
     828 * RTS_FBK_EN: enable rts rate fallback 
     829 */ 
     830#define TX_RTS_CFG                      0x1344 
     831#define TX_RTS_CFG_AUTO_RTS_RETRY_LIMIT FIELD32(0x000000ff) 
     832#define TX_RTS_CFG_RTS_THRES            FIELD32(0x00ffff00) 
     833#define TX_RTS_CFG_RTS_FBK_EN           FIELD32(0x01000000) 
     834 
     835/* 
     836 * TX_TIMEOUT_CFG: 
     837 * MPDU_LIFETIME: expiration time = 2^(9+MPDU LIFE TIME) us 
     838 * RX_ACK_TIMEOUT: unit:slot. Used for TX procedure 
     839 * TX_OP_TIMEOUT: TXOP timeout value for TXOP truncation. 
     840 *                it is recommended that: 
     841 *                (SLOT_TIME) > (TX_OP_TIMEOUT) > (RX_ACK_TIMEOUT) 
     842 */ 
     843#define TX_TIMEOUT_CFG                  0x1348 
     844#define TX_TIMEOUT_CFG_MPDU_LIFETIME    FIELD32(0x000000f0) 
     845#define TX_TIMEOUT_CFG_RX_ACK_TIMEOUT   FIELD32(0x0000ff00) 
     846#define TX_TIMEOUT_CFG_TX_OP_TIMEOUT    FIELD32(0x00ff0000) 
     847 
     848/* 
     849 * TX_RTY_CFG: 
     850 * SHORT_RTY_LIMIT: short retry limit 
     851 * LONG_RTY_LIMIT: long retry limit 
     852 * LONG_RTY_THRE: Long retry threshoold 
     853 * NON_AGG_RTY_MODE: Non-Aggregate MPDU retry mode 
     854 *                   0:expired by retry limit, 1: expired by mpdu life timer 
     855 * AGG_RTY_MODE: Aggregate MPDU retry mode 
     856 *               0:expired by retry limit, 1: expired by mpdu life timer 
     857 * TX_AUTO_FB_ENABLE: Tx retry PHY rate auto fallback enable 
     858 */ 
     859#define TX_RTY_CFG                      0x134c 
     860#define TX_RTY_CFG_SHORT_RTY_LIMIT      FIELD32(0x000000ff) 
     861#define TX_RTY_CFG_LONG_RTY_LIMIT       FIELD32(0x0000ff00) 
     862#define TX_RTY_CFG_LONG_RTY_THRE        FIELD32(0x0fff0000) 
     863#define TX_RTY_CFG_NON_AGG_RTY_MODE     FIELD32(0x10000000) 
     864#define TX_RTY_CFG_AGG_RTY_MODE         FIELD32(0x20000000) 
     865#define TX_RTY_CFG_TX_AUTO_FB_ENABLE    FIELD32(0x40000000) 
     866 
     867/* 
     868 * TX_LINK_CFG: 
     869 * REMOTE_MFB_LIFETIME: remote MFB life time. unit: 32us 
     870 * MFB_ENABLE: TX apply remote MFB 1:enable 
     871 * REMOTE_UMFS_ENABLE: remote unsolicit  MFB enable 
     872 *                     0: not apply remote remote unsolicit (MFS=7) 
     873 * TX_MRQ_EN: MCS request TX enable 
     874 * TX_RDG_EN: RDG TX enable 
     875 * TX_CF_ACK_EN: Piggyback CF-ACK enable 
     876 * REMOTE_MFB: remote MCS feedback 
     877 * REMOTE_MFS: remote MCS feedback sequence number 
     878 */ 
     879#define TX_LINK_CFG                     0x1350 
     880#define TX_LINK_CFG_REMOTE_MFB_LIFETIME FIELD32(0x000000ff) 
     881#define TX_LINK_CFG_MFB_ENABLE          FIELD32(0x00000100) 
     882#define TX_LINK_CFG_REMOTE_UMFS_ENABLE  FIELD32(0x00000200) 
     883#define TX_LINK_CFG_TX_MRQ_EN           FIELD32(0x00000400) 
     884#define TX_LINK_CFG_TX_RDG_EN           FIELD32(0x00000800) 
     885#define TX_LINK_CFG_TX_CF_ACK_EN        FIELD32(0x00001000) 
     886#define TX_LINK_CFG_REMOTE_MFB          FIELD32(0x00ff0000) 
     887#define TX_LINK_CFG_REMOTE_MFS          FIELD32(0xff000000) 
     888 
     889/* 
     890 * HT_FBK_CFG0: 
     891 */ 
     892#define HT_FBK_CFG0                     0x1354 
     893#define HT_FBK_CFG0_HTMCS0FBK           FIELD32(0x0000000f) 
     894#define HT_FBK_CFG0_HTMCS1FBK           FIELD32(0x000000f0) 
     895#define HT_FBK_CFG0_HTMCS2FBK           FIELD32(0x00000f00) 
     896#define HT_FBK_CFG0_HTMCS3FBK           FIELD32(0x0000f000) 
     897#define HT_FBK_CFG0_HTMCS4FBK           FIELD32(0x000f0000) 
     898#define HT_FBK_CFG0_HTMCS5FBK           FIELD32(0x00f00000) 
     899#define HT_FBK_CFG0_HTMCS6FBK           FIELD32(0x0f000000) 
     900#define HT_FBK_CFG0_HTMCS7FBK           FIELD32(0xf0000000) 
     901 
     902/* 
     903 * HT_FBK_CFG1: 
     904 */ 
     905#define HT_FBK_CFG1                     0x1358 
     906#define HT_FBK_CFG1_HTMCS8FBK           FIELD32(0x0000000f) 
     907#define HT_FBK_CFG1_HTMCS9FBK           FIELD32(0x000000f0) 
     908#define HT_FBK_CFG1_HTMCS10FBK          FIELD32(0x00000f00) 
     909#define HT_FBK_CFG1_HTMCS11FBK          FIELD32(0x0000f000) 
     910#define HT_FBK_CFG1_HTMCS12FBK          FIELD32(0x000f0000) 
     911#define HT_FBK_CFG1_HTMCS13FBK          FIELD32(0x00f00000) 
     912#define HT_FBK_CFG1_HTMCS14FBK          FIELD32(0x0f000000) 
     913#define HT_FBK_CFG1_HTMCS15FBK          FIELD32(0xf0000000) 
     914 
     915/* 
     916 * LG_FBK_CFG0: 
     917 */ 
     918#define LG_FBK_CFG0                     0x135c 
     919#define LG_FBK_CFG0_OFDMMCS0FBK         FIELD32(0x0000000f) 
     920#define LG_FBK_CFG0_OFDMMCS1FBK         FIELD32(0x000000f0) 
     921#define LG_FBK_CFG0_OFDMMCS2FBK         FIELD32(0x00000f00) 
     922#define LG_FBK_CFG0_OFDMMCS3FBK         FIELD32(0x0000f000) 
     923#define LG_FBK_CFG0_OFDMMCS4FBK         FIELD32(0x000f0000) 
     924#define LG_FBK_CFG0_OFDMMCS5FBK         FIELD32(0x00f00000) 
     925#define LG_FBK_CFG0_OFDMMCS6FBK         FIELD32(0x0f000000) 
     926#define LG_FBK_CFG0_OFDMMCS7FBK         FIELD32(0xf0000000) 
     927 
     928/* 
     929 * LG_FBK_CFG1: 
     930 */ 
     931#define LG_FBK_CFG1                     0x1360 
     932#define LG_FBK_CFG0_CCKMCS0FBK          FIELD32(0x0000000f) 
     933#define LG_FBK_CFG0_CCKMCS1FBK          FIELD32(0x000000f0) 
     934#define LG_FBK_CFG0_CCKMCS2FBK          FIELD32(0x00000f00) 
     935#define LG_FBK_CFG0_CCKMCS3FBK          FIELD32(0x0000f000) 
     936 
     937/* 
     938 * CCK_PROT_CFG: CCK Protection 
     939 * PROTECT_RATE: Protection control frame rate for CCK TX(RTS/CTS/CFEnd) 
     940 * PROTECT_CTRL: Protection control frame type for CCK TX 
     941 *               0:none, 1:RTS/CTS, 2:CTS-to-self 
     942 * PROTECT_NAV: TXOP protection type for CCK TX 
     943 *              0:none, 1:ShortNAVprotect, 2:LongNAVProtect 
     944 * TX_OP_ALLOW_CCK: CCK TXOP allowance, 0:disallow 
     945 * TX_OP_ALLOW_OFDM: CCK TXOP allowance, 0:disallow 
     946 * TX_OP_ALLOW_MM20: CCK TXOP allowance, 0:disallow 
     947 * TX_OP_ALLOW_MM40: CCK TXOP allowance, 0:disallow 
     948 * TX_OP_ALLOW_GF20: CCK TXOP allowance, 0:disallow 
     949 * TX_OP_ALLOW_GF40: CCK TXOP allowance, 0:disallow 
     950 * RTS_TH_EN: RTS threshold enable on CCK TX 
     951 */ 
     952#define CCK_PROT_CFG                    0x1364 
     953#define CCK_PROT_CFG_PROTECT_RATE       FIELD32(0x0000ffff) 
     954#define CCK_PROT_CFG_PROTECT_CTRL       FIELD32(0x00030000) 
     955#define CCK_PROT_CFG_PROTECT_NAV        FIELD32(0x000c0000) 
     956#define CCK_PROT_CFG_TX_OP_ALLOW_CCK    FIELD32(0x00100000) 
     957#define CCK_PROT_CFG_TX_OP_ALLOW_OFDM   FIELD32(0x00200000) 
     958#define CCK_PROT_CFG_TX_OP_ALLOW_MM20   FIELD32(0x00400000) 
     959#define CCK_PROT_CFG_TX_OP_ALLOW_MM40   FIELD32(0x00800000) 
     960#define CCK_PROT_CFG_TX_OP_ALLOW_GF20   FIELD32(0x01000000) 
     961#define CCK_PROT_CFG_TX_OP_ALLOW_GF40   FIELD32(0x02000000) 
     962#define CCK_PROT_CFG_RTS_TH_EN          FIELD32(0x04000000) 
     963 
     964/* 
     965 * OFDM_PROT_CFG: OFDM Protection 
     966 */ 
     967#define OFDM_PROT_CFG                   0x1368 
     968#define OFDM_PROT_CFG_PROTECT_RATE      FIELD32(0x0000ffff) 
     969#define OFDM_PROT_CFG_PROTECT_CTRL      FIELD32(0x00030000) 
     970#define OFDM_PROT_CFG_PROTECT_NAV       FIELD32(0x000c0000) 
     971#define OFDM_PROT_CFG_TX_OP_ALLOW_CCK   FIELD32(0x00100000) 
     972#define OFDM_PROT_CFG_TX_OP_ALLOW_OFDM  FIELD32(0x00200000) 
     973#define OFDM_PROT_CFG_TX_OP_ALLOW_MM20  FIELD32(0x00400000) 
     974#define OFDM_PROT_CFG_TX_OP_ALLOW_MM40  FIELD32(0x00800000) 
     975#define OFDM_PROT_CFG_TX_OP_ALLOW_GF20  FIELD32(0x01000000) 
     976#define OFDM_PROT_CFG_TX_OP_ALLOW_GF40  FIELD32(0x02000000) 
     977#define OFDM_PROT_CFG_RTS_TH_EN         FIELD32(0x04000000) 
     978 
     979/* 
     980 * MM20_PROT_CFG: MM20 Protection 
     981 */ 
     982#define MM20_PROT_CFG                   0x136c 
     983#define MM20_PROT_CFG_PROTECT_RATE      FIELD32(0x0000ffff) 
     984#define MM20_PROT_CFG_PROTECT_CTRL      FIELD32(0x00030000) 
     985#define MM20_PROT_CFG_PROTECT_NAV       FIELD32(0x000c0000) 
     986#define MM20_PROT_CFG_TX_OP_ALLOW_CCK   FIELD32(0x00100000) 
     987#define MM20_PROT_CFG_TX_OP_ALLOW_OFDM  FIELD32(0x00200000) 
     988#define MM20_PROT_CFG_TX_OP_ALLOW_MM20  FIELD32(0x00400000) 
     989#define MM20_PROT_CFG_TX_OP_ALLOW_MM40  FIELD32(0x00800000) 
     990#define MM20_PROT_CFG_TX_OP_ALLOW_GF20  FIELD32(0x01000000) 
     991#define MM20_PROT_CFG_TX_OP_ALLOW_GF40  FIELD32(0x02000000) 
     992#define MM20_PROT_CFG_RTS_TH_EN         FIELD32(0x04000000) 
     993 
     994/* 
     995 * MM40_PROT_CFG: MM40 Protection 
     996 */ 
     997#define MM40_PROT_CFG                   0x1370 
     998#define MM40_PROT_CFG_PROTECT_RATE      FIELD32(0x0000ffff) 
     999#define MM40_PROT_CFG_PROTECT_CTRL      FIELD32(0x00030000) 
     1000#define MM40_PROT_CFG_PROTECT_NAV       FIELD32(0x000c0000) 
     1001#define MM40_PROT_CFG_TX_OP_ALLOW_CCK   FIELD32(0x00100000) 
     1002#define MM40_PROT_CFG_TX_OP_ALLOW_OFDM  FIELD32(0x00200000) 
     1003#define MM40_PROT_CFG_TX_OP_ALLOW_MM20  FIELD32(0x00400000) 
     1004#define MM40_PROT_CFG_TX_OP_ALLOW_MM40  FIELD32(0x00800000) 
     1005#define MM40_PROT_CFG_TX_OP_ALLOW_GF20  FIELD32(0x01000000) 
     1006#define MM40_PROT_CFG_TX_OP_ALLOW_GF40  FIELD32(0x02000000) 
     1007#define MM40_PROT_CFG_RTS_TH_EN         FIELD32(0x04000000) 
     1008 
     1009/* 
     1010 * GF20_PROT_CFG: GF20 Protection 
     1011 */ 
     1012#define GF20_PROT_CFG                   0x1374 
     1013#define GF20_PROT_CFG_PROTECT_RATE      FIELD32(0x0000ffff) 
     1014#define GF20_PROT_CFG_PROTECT_CTRL      FIELD32(0x00030000) 
     1015#define GF20_PROT_CFG_PROTECT_NAV       FIELD32(0x000c0000) 
     1016#define GF20_PROT_CFG_TX_OP_ALLOW_CCK   FIELD32(0x00100000) 
     1017#define GF20_PROT_CFG_TX_OP_ALLOW_OFDM  FIELD32(0x00200000) 
     1018#define GF20_PROT_CFG_TX_OP_ALLOW_MM20  FIELD32(0x00400000) 
     1019#define GF20_PROT_CFG_TX_OP_ALLOW_MM40  FIELD32(0x00800000) 
     1020#define GF20_PROT_CFG_TX_OP_ALLOW_GF20  FIELD32(0x01000000) 
     1021#define GF20_PROT_CFG_TX_OP_ALLOW_GF40  FIELD32(0x02000000) 
     1022#define GF20_PROT_CFG_RTS_TH_EN         FIELD32(0x04000000) 
     1023 
     1024/* 
     1025 * GF40_PROT_CFG: GF40 Protection 
     1026 */ 
     1027#define GF40_PROT_CFG                   0x1378 
     1028#define GF40_PROT_CFG_PROTECT_RATE      FIELD32(0x0000ffff) 
     1029#define GF40_PROT_CFG_PROTECT_CTRL      FIELD32(0x00030000) 
     1030#define GF40_PROT_CFG_PROTECT_NAV       FIELD32(0x000c0000) 
     1031#define GF40_PROT_CFG_TX_OP_ALLOW_CCK   FIELD32(0x00100000) 
     1032#define GF40_PROT_CFG_TX_OP_ALLOW_OFDM  FIELD32(0x00200000) 
     1033#define GF40_PROT_CFG_TX_OP_ALLOW_MM20  FIELD32(0x00400000) 
     1034#define GF40_PROT_CFG_TX_OP_ALLOW_MM40  FIELD32(0x00800000) 
     1035#define GF40_PROT_CFG_TX_OP_ALLOW_GF20  FIELD32(0x01000000) 
     1036#define GF40_PROT_CFG_TX_OP_ALLOW_GF40  FIELD32(0x02000000) 
     1037#define GF40_PROT_CFG_RTS_TH_EN         FIELD32(0x04000000) 
     1038 
     1039/* 
     1040 * EXP_CTS_TIME: 
     1041 */ 
     1042#define EXP_CTS_TIME                    0x137c 
     1043 
     1044/* 
     1045 * EXP_ACK_TIME: 
     1046 */ 
     1047#define EXP_ACK_TIME                    0x1380 
     1048 
     1049/* 
     1050 * RX_FILTER_CFG: RX configuration register. 
     1051 */ 
     1052#define RX_FILTER_CFG                   0x1400 
     1053#define RX_FILTER_CFG_DROP_CRC_ERROR    FIELD32(0x00000001) 
     1054#define RX_FILTER_CFG_DROP_PHY_ERROR    FIELD32(0x00000002) 
     1055#define RX_FILTER_CFG_DROP_NOT_TO_ME    FIELD32(0x00000004) 
     1056#define RX_FILTER_CFG_DROP_NOT_MY_BSSD  FIELD32(0x00000008) 
     1057#define RX_FILTER_CFG_DROP_VER_ERROR    FIELD32(0x00000010) 
     1058#define RX_FILTER_CFG_DROP_MULTICAST    FIELD32(0x00000020) 
     1059#define RX_FILTER_CFG_DROP_BROADCAST    FIELD32(0x00000040) 
     1060#define RX_FILTER_CFG_DROP_DUPLICATE    FIELD32(0x00000080) 
     1061#define RX_FILTER_CFG_DROP_CF_END_ACK   FIELD32(0x00000100) 
     1062#define RX_FILTER_CFG_DROP_CF_END       FIELD32(0x00000200) 
     1063#define RX_FILTER_CFG_DROP_ACK          FIELD32(0x00000400) 
     1064#define RX_FILTER_CFG_DROP_CTS          FIELD32(0x00000800) 
     1065#define RX_FILTER_CFG_DROP_RTS          FIELD32(0x00001000) 
     1066#define RX_FILTER_CFG_DROP_PSPOLL       FIELD32(0x00002000) 
     1067#define RX_FILTER_CFG_DROP_BA           FIELD32(0x00004000) 
     1068#define RX_FILTER_CFG_DROP_BAR          FIELD32(0x00008000) 
     1069#define RX_FILTER_CFG_DROP_CNTL         FIELD32(0x00010000) 
     1070 
     1071/* 
     1072 * AUTO_RSP_CFG: 
     1073 * AUTORESPONDER: 0: disable, 1: enable 
     1074 * BAC_ACK_POLICY: 0:long, 1:short preamble 
     1075 * CTS_40_MMODE: Response CTS 40MHz duplicate mode 
     1076 * CTS_40_MREF: Response CTS 40MHz duplicate mode 
     1077 * AR_PREAMBLE: Auto responder preamble 0:long, 1:short preamble 
     1078 * DUAL_CTS_EN: Power bit value in control frame 
     1079 * ACK_CTS_PSM_BIT:Power bit value in control frame 
     1080 */ 
     1081#define AUTO_RSP_CFG                    0x1404 
     1082#define AUTO_RSP_CFG_AUTORESPONDER      FIELD32(0x00000001) 
     1083#define AUTO_RSP_CFG_BAC_ACK_POLICY     FIELD32(0x00000002) 
     1084#define AUTO_RSP_CFG_CTS_40_MMODE       FIELD32(0x00000004) 
     1085#define AUTO_RSP_CFG_CTS_40_MREF        FIELD32(0x00000008) 
     1086#define AUTO_RSP_CFG_AR_PREAMBLE        FIELD32(0x00000010) 
     1087#define AUTO_RSP_CFG_DUAL_CTS_EN        FIELD32(0x00000040) 
     1088#define AUTO_RSP_CFG_ACK_CTS_PSM_BIT    FIELD32(0x00000080) 
     1089 
     1090/* 
     1091 * LEGACY_BASIC_RATE: 
     1092 */ 
     1093#define LEGACY_BASIC_RATE               0x1408 
     1094 
     1095/* 
     1096 * HT_BASIC_RATE: 
     1097 */ 
     1098#define HT_BASIC_RATE                   0x140c 
     1099 
     1100/* 
     1101 * HT_CTRL_CFG: 
     1102 */ 
     1103#define HT_CTRL_CFG                     0x1410 
     1104 
     1105/* 
     1106 * SIFS_COST_CFG: 
     1107 */ 
     1108#define SIFS_COST_CFG                   0x1414 
     1109 
     1110/* 
     1111 * RX_PARSER_CFG: 
     1112 * Set NAV for all received frames 
     1113 */ 
     1114#define RX_PARSER_CFG                   0x1418 
     1115 
     1116/* 
     1117 * TX_SEC_CNT0: 
     1118 */ 
     1119#define TX_SEC_CNT0                     0x1500 
     1120 
     1121/* 
     1122 * RX_SEC_CNT0: 
     1123 */ 
     1124#define RX_SEC_CNT0                     0x1504 
     1125 
     1126/* 
     1127 * CCMP_FC_MUTE: 
     1128 */ 
     1129#define CCMP_FC_MUTE                    0x1508 
     1130 
     1131/* 
     1132 * TXOP_HLDR_ADDR0: 
     1133 */ 
     1134#define TXOP_HLDR_ADDR0                 0x1600 
     1135 
     1136/* 
     1137 * TXOP_HLDR_ADDR1: 
     1138 */ 
     1139#define TXOP_HLDR_ADDR1                 0x1604 
     1140 
     1141/* 
     1142 * TXOP_HLDR_ET: 
     1143 */ 
     1144#define TXOP_HLDR_ET                    0x1608 
     1145 
     1146/* 
     1147 * QOS_CFPOLL_RA_DW0: 
     1148 */ 
     1149#define QOS_CFPOLL_RA_DW0               0x160c 
     1150 
     1151/* 
     1152 * QOS_CFPOLL_RA_DW1: 
     1153 */ 
     1154#define QOS_CFPOLL_RA_DW1               0x1610 
     1155 
     1156/* 
     1157 * QOS_CFPOLL_QC: 
     1158 */ 
     1159#define QOS_CFPOLL_QC                   0x1614 
     1160 
     1161/* 
     1162 * RX_STA_CNT0: RX PLCP error count & RX CRC error count 
     1163 */ 
     1164#define RX_STA_CNT0                     0x1700 
     1165#define RX_STA_CNT0_CRC_ERR             FIELD32(0x0000ffff) 
     1166#define RX_STA_CNT0_PHY_ERR             FIELD32(0xffff0000) 
     1167 
     1168/* 
     1169 * RX_STA_CNT1: RX False CCA count & RX LONG frame count 
     1170 */ 
     1171#define RX_STA_CNT1                     0x1704 
     1172#define RX_STA_CNT1_FALSE_CCA           FIELD32(0x0000ffff) 
     1173#define RX_STA_CNT1_PLCP_ERR            FIELD32(0xffff0000) 
     1174 
     1175/* 
     1176 * RX_STA_CNT2: 
     1177 */ 
     1178#define RX_STA_CNT2                     0x1708 
     1179#define RX_STA_CNT2_RX_DUPLI_COUNT      FIELD32(0x0000ffff) 
     1180#define RX_STA_CNT2_RX_FIFO_OVERFLOW    FIELD32(0xffff0000) 
     1181 
     1182/* 
     1183 * TX_STA_CNT0: TX Beacon count 
     1184 */ 
     1185#define TX_STA_CNT0                     0x170c 
     1186#define TX_STA_CNT0_TX_FAIL_COUNT       FIELD32(0x0000ffff) 
     1187#define TX_STA_CNT0_TX_BEACON_COUNT     FIELD32(0xffff0000) 
     1188 
     1189/* 
     1190 * TX_STA_CNT1: TX tx count 
     1191 */ 
     1192#define TX_STA_CNT1                     0x1710 
     1193#define TX_STA_CNT1_TX_SUCCESS          FIELD32(0x0000ffff) 
     1194#define TX_STA_CNT1_TX_RETRANSMIT       FIELD32(0xffff0000) 
     1195 
     1196/* 
     1197 * TX_STA_CNT2: TX tx count 
     1198 */ 
     1199#define TX_STA_CNT2                     0x1714 
     1200#define TX_STA_CNT2_TX_ZERO_LEN_COUNT   FIELD32(0x0000ffff) 
     1201#define TX_STA_CNT2_TX_UNDER_FLOW_COUNT FIELD32(0xffff0000) 
     1202 
     1203/* 
     1204 * TX_STA_FIFO: TX Result for specific PID status fifo register 
     1205 */ 
     1206#define TX_STA_FIFO                     0x1718 
     1207#define TX_STA_FIFO_VALID               FIELD32(0x00000001) 
     1208#define TX_STA_FIFO_PID_TYPE            FIELD32(0x0000001e) 
     1209#define TX_STA_FIFO_TX_SUCCESS          FIELD32(0x00000020) 
     1210#define TX_STA_FIFO_TX_AGGRE            FIELD32(0x00000040) 
     1211#define TX_STA_FIFO_TX_ACK_REQUIRED     FIELD32(0x00000080) 
     1212#define TX_STA_FIFO_WCID                FIELD32(0x0000ff00) 
     1213#define TX_STA_FIFO_SUCCESS_RATE        FIELD32(0xffff0000) 
     1214 
     1215/* 
     1216 * TX_AGG_CNT: Debug counter 
     1217 */ 
     1218#define TX_AGG_CNT                      0x171c 
     1219#define TX_AGG_CNT_NON_AGG_TX_COUNT     FIELD32(0x0000ffff) 
     1220#define TX_AGG_CNT_AGG_TX_COUNT         FIELD32(0xffff0000) 
     1221 
     1222/* 
     1223 * TX_AGG_CNT0: 
     1224 */ 
     1225#define TX_AGG_CNT0                     0x1720 
     1226#define TX_AGG_CNT0_AGG_SIZE_1_COUNT    FIELD32(0x0000ffff) 
     1227#define TX_AGG_CNT0_AGG_SIZE_2_COUNT    FIELD32(0xffff0000) 
     1228 
     1229/* 
     1230 * TX_AGG_CNT1: 
     1231 */ 
     1232#define TX_AGG_CNT1                     0x1724 
     1233#define TX_AGG_CNT1_AGG_SIZE_3_COUNT    FIELD32(0x0000ffff) 
     1234#define TX_AGG_CNT1_AGG_SIZE_4_COUNT    FIELD32(0xffff0000) 
     1235 
     1236/* 
     1237 * TX_AGG_CNT2: 
     1238 */ 
     1239#define TX_AGG_CNT2                     0x1728 
     1240#define TX_AGG_CNT2_AGG_SIZE_5_COUNT    FIELD32(0x0000ffff) 
     1241#define TX_AGG_CNT2_AGG_SIZE_6_COUNT    FIELD32(0xffff0000) 
     1242 
     1243/* 
     1244 * TX_AGG_CNT3: 
     1245 */ 
     1246#define TX_AGG_CNT3                     0x172c 
     1247#define TX_AGG_CNT3_AGG_SIZE_7_COUNT    FIELD32(0x0000ffff) 
     1248#define TX_AGG_CNT3_AGG_SIZE_8_COUNT    FIELD32(0xffff0000) 
     1249 
     1250/* 
     1251 * TX_AGG_CNT4: 
     1252 */ 
     1253#define TX_AGG_CNT4                     0x1730 
     1254#define TX_AGG_CNT4_AGG_SIZE_9_COUNT    FIELD32(0x0000ffff) 
     1255#define TX_AGG_CNT4_AGG_SIZE_10_COUNT   FIELD32(0xffff0000) 
     1256 
     1257/* 
     1258 * TX_AGG_CNT5: 
     1259 */ 
     1260#define TX_AGG_CNT5                     0x1734 
     1261#define TX_AGG_CNT5_AGG_SIZE_11_COUNT   FIELD32(0x0000ffff) 
     1262#define TX_AGG_CNT5_AGG_SIZE_12_COUNT   FIELD32(0xffff0000) 
     1263 
     1264/* 
     1265 * TX_AGG_CNT6: 
     1266 */ 
     1267#define TX_AGG_CNT6                     0x1738 
     1268#define TX_AGG_CNT6_AGG_SIZE_13_COUNT   FIELD32(0x0000ffff) 
     1269#define TX_AGG_CNT6_AGG_SIZE_14_COUNT   FIELD32(0xffff0000) 
     1270 
     1271/* 
     1272 * TX_AGG_CNT7: 
     1273 */ 
     1274#define TX_AGG_CNT7                     0x173c 
     1275#define TX_AGG_CNT7_AGG_SIZE_15_COUNT   FIELD32(0x0000ffff) 
     1276#define TX_AGG_CNT7_AGG_SIZE_16_COUNT   FIELD32(0xffff0000) 
     1277 
     1278/* 
     1279 * MPDU_DENSITY_CNT: 
     1280 * TX_ZERO_DEL: TX zero length delimiter count 
     1281 * RX_ZERO_DEL: RX zero length delimiter count 
     1282 */ 
     1283#define MPDU_DENSITY_CNT                0x1740 
     1284#define MPDU_DENSITY_CNT_TX_ZERO_DEL    FIELD32(0x0000ffff) 
     1285#define MPDU_DENSITY_CNT_RX_ZERO_DEL    FIELD32(0xffff0000) 
     1286 
     1287/* 
     1288 * Security key table memory, base address = 0x1800 
     1289 */ 
     1290struct hw_pairwise_ta_entry { 
     1291        u8 address[6]; 
     1292        u8 reserved[2]; 
     1293} __attribute__ ((packed)); 
     1294 
     1295struct wcid_entry { 
     1296        u8 rx_ba_bitmat7; 
     1297        u8 rx_ba_bitmat0; 
     1298        u8 mac[6]; 
     1299} __attribute__ ((packed)); 
     1300 
     1301struct hw_key_entry { 
     1302        u8 key[16]; 
     1303        u8 tx_mic[8]; 
     1304        u8 rx_mic[8]; 
     1305} __attribute__ ((packed)); 
     1306 
     1307/* 
     1308 * Security key table memory. 
     1309 * MAC_WCID_BASE: 8-bytes (use only 6 bytes) * 256 entry 
     1310 * PAIRWISE_KEY_TABLE_BASE: 32-byte * 256 entry 
     1311 * PAIRWISE_IVEIV_TABLE_BASE: 8-byte * 256-entry 
     1312 * MAC_IVEIV_TABLE_BASE: 8-byte * 256-entry 
     1313 * MAC_WCID_ATTRIBUTE_BASE: 4-byte * 256-entry 
     1314 * SHARED_KEY_TABLE_BASE: 32-byte * 16-entry 
     1315 * SHARED_KEY_MODE_BASE: 32-byte * 16-entry 
     1316 */ 
     1317#define MAC_WCID_BASE                   0x1800 
     1318#define PAIRWISE_KEY_TABLE_BASE         0x4000 
     1319#define PAIRWISE_IVEIV_TABLE_BASE       0x6000 
     1320#define MAC_IVEIV_TABLE_BASE            0x6000 
     1321#define MAC_WCID_ATTRIBUTE_BASE         0x6800 
     1322#define SHARED_KEY_TABLE_BASE           0x6c00 
     1323#define SHARED_KEY_MODE_BASE            0x7000 
     1324 
     1325#define SHARED_KEY_ENTRY(__idx) \ 
     1326        ( SHARED_KEY_TABLE_BASE + \ 
     1327                ((__idx) * sizeof(struct hw_key_entry)) ) 
     1328#define SHARED_KEY_MODE_ENTRY(__idx) \ 
     1329        ( SHARED_KEY_MODE_BASE + ((__idx) * sizeof(u32)) ) 
     1330#define PAIRWISE_KEY_ENTRY(__idx) \ 
     1331        ( PAIRWISE_KEY_TABLE_BASE + \ 
     1332                ((__idx) * sizeof(struct hw_key_entry)) ) 
     1333 
     1334#define MAC_WCID_ENTRY(__idx) \ 
     1335        ( MAC_WCID_BASE + (2 * sizeof(u32) * (__idx)) ) 
     1336#define MAC_WCID_ATTR_ENTRY(__idx) \ 
     1337        ( MAC_WCID_ATTRIBUTE_BASE + ((__idx) * sizeof(u32)) ) 
     1338 
     1339/* 
     1340 * MAC_WCID_ATTRIBUTE: 
     1341 * KEYTAB: 0: shared key table, 1: pairwise key table 
     1342 * BSS_IDX: multipleBSS index for the WCID 
     1343 */ 
     1344#define MAC_WCID_ATTRIBUTE_KEYTAB       FIELD32(0x00000001) 
     1345#define MAC_WCID_ATTRIBUTE_PAIRKEY_MODE FIELD32(0x0000000e) 
     1346#define MAC_WCID_ATTRIBUTE_BSS_IDX      FIELD32(0x00000070) 
     1347#define MAC_WCID_ATTRIBUTE_RX_WIUDF     FIELD32(0x00000380) 
     1348 
     1349/* 
     1350 * SHARED_KEY_MODE: 
     1351 */ 
     1352#define SHARED_KEY_MODE_BSS0_KEY0       FIELD32(0x00000007) 
     1353#define SHARED_KEY_MODE_BSS0_KEY1       FIELD32(0x00000070) 
     1354#define SHARED_KEY_MODE_BSS0_KEY2       FIELD32(0x00000700) 
     1355#define SHARED_KEY_MODE_BSS0_KEY3       FIELD32(0x00007000) 
     1356#define SHARED_KEY_MODE_BSS1_KEY0       FIELD32(0x00070000) 
     1357#define SHARED_KEY_MODE_BSS1_KEY1       FIELD32(0x00700000) 
     1358#define SHARED_KEY_MODE_BSS1_KEY2       FIELD32(0x07000000) 
     1359#define SHARED_KEY_MODE_BSS1_KEY3       FIELD32(0x70000000) 
     1360 
     1361/* 
     1362 * HOST-MCU communication 
     1363 */ 
     1364 
     1365/* 
     1366 * H2M_MAILBOX_CSR: Host-to-MCU Mailbox. 
     1367 */ 
     1368#define H2M_MAILBOX_CSR                 0x7010 
     1369#define H2M_MAILBOX_CSR_ARG0            FIELD32(0x000000ff) 
     1370#define H2M_MAILBOX_CSR_ARG1            FIELD32(0x0000ff00) 
     1371#define H2M_MAILBOX_CSR_CMD_TOKEN       FIELD32(0x00ff0000) 
     1372#define H2M_MAILBOX_CSR_OWNER           FIELD32(0xff000000) 
     1373 
     1374/* 
     1375 * H2M_MAILBOX_CID: 
     1376 */ 
     1377#define H2M_MAILBOX_CID                 0x7014 
     1378 
     1379/* 
     1380 * H2M_MAILBOX_STATUS: 
     1381 */ 
     1382#define H2M_MAILBOX_STATUS              0x701c 
     1383 
     1384/* 
     1385 * H2M_INT_SRC: 
     1386 */ 
     1387#define H2M_INT_SRC                     0x7024 
     1388 
     1389/* 
     1390 * H2M_BBP_AGENT: 
     1391 */ 
     1392#define H2M_BBP_AGENT                   0x7028 
     1393 
     1394/* 
     1395 * MCU_LEDCS: LED control for MCU Mailbox. 
     1396 */ 
     1397#define MCU_LEDCS_LED_MODE              FIELD8(0x1f) 
     1398#define MCU_LEDCS_POLARITY              FIELD8(0x01) 
     1399 
     1400/* 
     1401 * HW_CS_CTS_BASE: 
     1402 * Carrier-sense CTS frame base address. 
     1403 * It's where mac stores carrier-sense frame for carrier-sense function. 
     1404 */ 
     1405#define HW_CS_CTS_BASE                  0x7700 
     1406 
     1407/* 
     1408 * HW_DFS_CTS_BASE: 
     1409 * FS CTS frame base address. It's where mac stores CTS frame for DFS. 
     1410 */ 
     1411#define HW_DFS_CTS_BASE                 0x7780 
     1412 
     1413/* 
     1414 * TXRX control registers - base address 0x3000 
     1415 */ 
     1416 
     1417/* 
     1418 * TXRX_CSR1: 
     1419 * rt2860b  UNKNOWN reg use R/O Reg Addr 0x77d0 first.. 
     1420 */ 
     1421#define TXRX_CSR1                       0x77d0 
     1422 
     1423/* 
     1424 * HW_DEBUG_SETTING_BASE: 
     1425 * since NULL frame won't be that long (256 byte) 
     1426 * We steal 16 tail bytes to save debugging settings 
     1427 */ 
     1428#define HW_DEBUG_SETTING_BASE           0x77f0 
     1429#define HW_DEBUG_SETTING_BASE2          0x7770 
     1430 
     1431/* 
     1432 * HW_BEACON_BASE 
     1433 * In order to support maximum 8 MBSS and its maximum length 
     1434 * is 512 bytes for each beacon 
     1435 * Three section discontinue memory segments will be used. 
     1436 * 1. The original region for BCN 0~3 
     1437 * 2. Extract memory from FCE table for BCN 4~5 
     1438 * 3. Extract memory from Pair-wise key table for BCN 6~7 
     1439 *    It occupied those memory of wcid 238~253 for BCN 6 
     1440 *    and wcid 222~237 for BCN 7 
     1441 * 
     1442 * IMPORTANT NOTE: Not sure why legacy driver does this, 
     1443 * but HW_BEACON_BASE7 is 0x0200 bytes below HW_BEACON_BASE6. 
     1444 */ 
     1445#define HW_BEACON_BASE0                 0x7800 
     1446#define HW_BEACON_BASE1                 0x7a00 
     1447#define HW_BEACON_BASE2                 0x7c00 
     1448#define HW_BEACON_BASE3                 0x7e00 
     1449#define HW_BEACON_BASE4                 0x7200 
     1450#define HW_BEACON_BASE5                 0x7400 
     1451#define HW_BEACON_BASE6                 0x5dc0 
     1452#define HW_BEACON_BASE7                 0x5bc0 
     1453 
     1454#define HW_BEACON_OFFSET(__index) \ 
     1455        ( ((__index) < 4) ? ( HW_BEACON_BASE0 + (__index * 0x0200) ) : \ 
     1456          (((__index) < 6) ? ( HW_BEACON_BASE4 + ((__index - 4) * 0x0200) ) : \ 
     1457          (HW_BEACON_BASE6 - ((__index - 6) * 0x0200))) ) 
     1458 
     1459/* 
     1460 * 8051 firmware image. 
     1461 */ 
     1462#define FIRMWARE_RT2860                 "rt2860.bin" 
     1463#define FIRMWARE_IMAGE_BASE             0x2000 
     1464 
     1465/* 
     1466 * BBP registers. 
     1467 * The wordsize of the BBP is 8 bits. 
     1468 */ 
     1469 
     1470/* 
     1471 * BBP 1: TX Antenna 
     1472 */ 
     1473#define BBP1_TX_POWER                   FIELD8(0x07) 
     1474#define BBP1_TX_ANTENNA                 FIELD8(0x18) 
     1475 
     1476/* 
     1477 * BBP 3: RX Antenna 
     1478 */ 
     1479#define BBP3_RX_ANTENNA                 FIELD8(0x18) 
     1480 
     1481/* 
     1482 * RF registers 
     1483 */ 
     1484 
     1485/* 
     1486 * RF 2 
     1487 */ 
     1488#define RF2_ANTENNA_RX2                 FIELD32(0x00000040) 
     1489#define RF2_ANTENNA_TX1                 FIELD32(0x00004000) 
     1490#define RF2_ANTENNA_RX1                 FIELD32(0x00020000) 
     1491 
     1492/* 
     1493 * RF 3 
     1494 */ 
     1495#define RF3_TXPOWER_G                   FIELD32(0x00003e00) 
     1496#define RF3_TXPOWER_A_7DBM_BOOST        FIELD32(0x00000200) 
     1497#define RF3_TXPOWER_A                   FIELD32(0x00003c00) 
     1498 
     1499/* 
     1500 * RF 4 
     1501 */ 
     1502#define RF4_TXPOWER_G                   FIELD32(0x000007c0) 
     1503#define RF4_TXPOWER_A_7DBM_BOOST        FIELD32(0x00000040) 
     1504#define RF4_TXPOWER_A                   FIELD32(0x00000780) 
     1505#define RF4_FREQ_OFFSET                 FIELD32(0x001f8000) 
     1506#define RF4_BW40                        FIELD32(0x00200000) 
     1507 
     1508/* 
     1509 * EEPROM content. 
     1510 * The wordsize of the EEPROM is 16 bits. 
     1511 */ 
     1512 
     1513/* 
     1514 * EEPROM Version 
     1515 */ 
     1516#define EEPROM_VERSION                  0x0001 
     1517#define EEPROM_VERSION_FAE              FIELD16(0x00ff) 
     1518#define EEPROM_VERSION_VERSION          FIELD16(0xff00) 
     1519 
     1520/* 
     1521 * HW MAC address. 
     1522 */ 
     1523#define EEPROM_MAC_ADDR_0               0x0002 
     1524#define EEPROM_MAC_ADDR_BYTE0           FIELD16(0x00ff) 
     1525#define EEPROM_MAC_ADDR_BYTE1           FIELD16(0xff00) 
     1526#define EEPROM_MAC_ADDR_1               0x0003 
     1527#define EEPROM_MAC_ADDR_BYTE2           FIELD16(0x00ff) 
     1528#define EEPROM_MAC_ADDR_BYTE3           FIELD16(0xff00) 
     1529#define EEPROM_MAC_ADDR_2               0x0004 
     1530#define EEPROM_MAC_ADDR_BYTE4           FIELD16(0x00ff) 
     1531#define EEPROM_MAC_ADDR_BYTE5           FIELD16(0xff00) 
     1532 
     1533/* 
     1534 * EEPROM ANTENNA config 
     1535 * RXPATH: 1: 1R, 2: 2R, 3: 3R 
     1536 * TXPATH: 1: 1T, 2: 2T 
     1537 */ 
     1538#define EEPROM_ANTENNA                  0x001a 
     1539#define EEPROM_ANTENNA_RXPATH           FIELD16(0x000f) 
     1540#define EEPROM_ANTENNA_TXPATH           FIELD16(0x00f0) 
     1541#define EEPROM_ANTENNA_RF_TYPE          FIELD16(0x0f00) 
     1542 
     1543/* 
     1544 * EEPROM NIC config 
     1545 * CARDBUS_ACCEL: 0 - enable, 1 - disable 
     1546 */ 
     1547#define EEPROM_NIC                      0x001b 
     1548#define EEPROM_NIC_HW_RADIO             FIELD16(0x0001) 
     1549#define EEPROM_NIC_DYNAMIC_TX_AGC       FIELD16(0x0002) 
     1550#define EEPROM_NIC_EXTERNAL_LNA_BG      FIELD16(0x0004) 
     1551#define EEPROM_NIC_EXTERNAL_LNA_A       FIELD16(0x0008) 
     1552#define EEPROM_NIC_CARDBUS_ACCEL        FIELD16(0x0010) 
     1553#define EEPROM_NIC_BW40M_SB_BG          FIELD16(0x0020) 
     1554#define EEPROM_NIC_BW40M_SB_A           FIELD16(0x0040) 
     1555#define EEPROM_NIC_WPS_PBC              FIELD16(0x0080) 
     1556#define EEPROM_NIC_BW40M_BG             FIELD16(0x0100) 
     1557#define EEPROM_NIC_BW40M_A              FIELD16(0x0200) 
     1558 
     1559/* 
     1560 * EEPROM frequency 
     1561 */ 
     1562#define EEPROM_FREQ                     0x001d 
     1563#define EEPROM_FREQ_OFFSET              FIELD16(0x00ff) 
     1564#define EEPROM_FREQ_LED_MODE            FIELD16(0x7f00) 
     1565#define EEPROM_FREQ_LED_POLARITY        FIELD16(0x1000) 
     1566 
     1567/* 
     1568 * EEPROM LED 
     1569 * POLARITY_RDY_G: Polarity RDY_G setting. 
     1570 * POLARITY_RDY_A: Polarity RDY_A setting. 
     1571 * POLARITY_ACT: Polarity ACT setting. 
     1572 * POLARITY_GPIO_0: Polarity GPIO0 setting. 
     1573 * POLARITY_GPIO_1: Polarity GPIO1 setting. 
     1574 * POLARITY_GPIO_2: Polarity GPIO2 setting. 
     1575 * POLARITY_GPIO_3: Polarity GPIO3 setting. 
     1576 * POLARITY_GPIO_4: Polarity GPIO4 setting. 
     1577 * LED_MODE: Led mode. 
     1578 */ 
     1579#define EEPROM_LED1                     0x001e 
     1580#define EEPROM_LED2                     0x001f 
     1581#define EEPROM_LED3                     0x0020 
     1582#define EEPROM_LED_POLARITY_RDY_BG      FIELD16(0x0001) 
     1583#define EEPROM_LED_POLARITY_RDY_A       FIELD16(0x0002) 
     1584#define EEPROM_LED_POLARITY_ACT         FIELD16(0x0004) 
     1585#define EEPROM_LED_POLARITY_GPIO_0      FIELD16(0x0008) 
     1586#define EEPROM_LED_POLARITY_GPIO_1      FIELD16(0x0010) 
     1587#define EEPROM_LED_POLARITY_GPIO_2      FIELD16(0x0020) 
     1588#define EEPROM_LED_POLARITY_GPIO_3      FIELD16(0x0040) 
     1589#define EEPROM_LED_POLARITY_GPIO_4      FIELD16(0x0080) 
     1590#define EEPROM_LED_LED_MODE             FIELD16(0x1f00) 
     1591 
     1592/* 
     1593 * EEPROM LNA 
     1594 */ 
     1595#define EEPROM_LNA                      0x0022 
     1596#define EEPROM_LNA_BG                   FIELD16(0x00ff) 
     1597#define EEPROM_LNA_A0                   FIELD16(0xff00) 
     1598 
     1599/* 
     1600 * EEPROM RSSI BG offset 
     1601 */ 
     1602#define EEPROM_RSSI_BG                  0x0023 
     1603#define EEPROM_RSSI_BG_OFFSET0          FIELD16(0x00ff) 
     1604#define EEPROM_RSSI_BG_OFFSET1          FIELD16(0xff00) 
     1605 
     1606/* 
     1607 * EEPROM RSSI BG2 offset 
     1608 */ 
     1609#define EEPROM_RSSI_BG2                 0x0024 
     1610#define EEPROM_RSSI_BG2_OFFSET2         FIELD16(0x00ff) 
     1611#define EEPROM_RSSI_BG2_LNA_A1          FIELD16(0xff00) 
     1612 
     1613/* 
     1614 * EEPROM RSSI A offset 
     1615 */ 
     1616#define EEPROM_RSSI_A                   0x0025 
     1617#define EEPROM_RSSI_A_OFFSET0           FIELD16(0x00ff) 
     1618#define EEPROM_RSSI_A_OFFSET1           FIELD16(0xff00) 
     1619 
     1620/* 
     1621 * EEPROM RSSI A2 offset 
     1622 */ 
     1623#define EEPROM_RSSI_A2                  0x0026 
     1624#define EEPROM_RSSI_A2_OFFSET2          FIELD16(0x00ff) 
     1625#define EEPROM_RSSI_A2_LNA_A2           FIELD16(0xff00) 
     1626 
     1627/* 
     1628 * EEPROM TXpower delta: 20MHZ AND 40 MHZ use different power. 
     1629 *      This is delta in 40MHZ. 
     1630 * VALUE: Tx Power dalta value (MAX=4) 
     1631 * TYPE: 1: Plus the delta value, 0: minus the delta value 
     1632 * TXPOWER: Enable: 
     1633 */ 
     1634#define EEPROM_TXPOWER_DELTA            0x0028 
     1635#define EEPROM_TXPOWER_DELTA_VALUE      FIELD16(0x003f) 
     1636#define EEPROM_TXPOWER_DELTA_TYPE       FIELD16(0x0040) 
     1637#define EEPROM_TXPOWER_DELTA_TXPOWER    FIELD16(0x0080) 
     1638 
     1639/* 
     1640 * EEPROM TXPOWER 802.11G 
     1641 */ 
     1642#define EEPROM_TXPOWER_BG1              0x0029 
     1643#define EEPROM_TXPOWER_BG2              0x0030 
     1644#define EEPROM_TXPOWER_BG_SIZE          7 
     1645#define EEPROM_TXPOWER_BG_1             FIELD16(0x00ff) 
     1646#define EEPROM_TXPOWER_BG_2             FIELD16(0xff00) 
     1647 
     1648/* 
     1649 * EEPROM TXPOWER 802.11A 
     1650 */ 
     1651#define EEPROM_TXPOWER_A1               0x003c 
     1652#define EEPROM_TXPOWER_A2               0x0053 
     1653#define EEPROM_TXPOWER_A_SIZE           6 
     1654#define EEPROM_TXPOWER_A_1              FIELD16(0x00ff) 
     1655#define EEPROM_TXPOWER_A_2              FIELD16(0xff00) 
     1656 
     1657/* 
     1658 * EEPROM TXpower byrate: 20MHZ power 
     1659 */ 
     1660#define EEPROM_TXPOWER_BYRATE           0x006f 
     1661 
     1662/* 
     1663 * EEPROM BBP. 
     1664 */ 
     1665#define EEPROM_BBP_START                0x0078 
     1666#define EEPROM_BBP_SIZE                 16 
     1667#define EEPROM_BBP_VALUE                FIELD16(0x00ff) 
     1668#define EEPROM_BBP_REG_ID               FIELD16(0xff00) 
     1669 
     1670/* 
     1671 * MCU mailbox commands. 
     1672 */ 
     1673#define MCU_SLEEP                       0x30 
     1674#define MCU_WAKEUP                      0x31 
     1675#define MCU_LED                         0x50 
     1676#define MCU_LED_STRENGTH                0x51 
     1677#define MCU_LED_1                       0x52 
     1678#define MCU_LED_2                       0x53 
     1679#define MCU_LED_3                       0x54 
     1680#define MCU_RADAR                       0x60 
     1681#define MCU_BOOT_SIGNAL                 0x72 
     1682 
     1683/* 
     1684 * DMA descriptor defines. 
     1685 */ 
     1686#define TXD_DESC_SIZE                   ( 4 * sizeof(__le32) ) 
     1687#define TXWI_DESC_SIZE                  ( 4 * sizeof(__le32) ) 
     1688#define RXD_DESC_SIZE                   ( 4 * sizeof(__le32) ) 
     1689#define RXWI_DESC_SIZE                  ( 4 * sizeof(__le32) ) 
     1690 
     1691/* 
     1692 * TX descriptor format for TX, PRIO and Beacon Ring. 
     1693 */ 
     1694 
     1695/* 
     1696 * Word0 
     1697 */ 
     1698#define TXD_W0_SD_PTR0                  FIELD32(0xffffffff) 
     1699 
     1700/* 
     1701 * Word1 
     1702 */ 
     1703#define TXD_W1_SD_LEN1                  FIELD32(0x00003fff) 
     1704#define TXD_W1_LAST_SEC1                FIELD32(0x00004000) 
     1705#define TXD_W1_BURST                    FIELD32(0x00008000) 
     1706#define TXD_W1_SD_LEN0                  FIELD32(0x3fff0000) 
     1707#define TXD_W1_LAST_SEC0                FIELD32(0x40000000) 
     1708#define TXD_W1_DMA_DONE                 FIELD32(0x80000000) 
     1709 
     1710/* 
     1711 * Word2 
     1712 */ 
     1713#define TXD_W2_SD_PTR1                  FIELD32(0xffffffff) 
     1714 
     1715/* 
     1716 * Word3 
     1717 * WIV: Wireless Info Valid. 1: Driver filled WI,  0: DMA needs to copy WI 
     1718 * QSEL: Select on-chip FIFO ID for 2nd-stage output scheduler. 
     1719 *       0:MGMT, 1:HCCA 2:EDCA 
     1720 */ 
     1721#define TXD_W3_WIV                      FIELD32(0x01000000) 
     1722#define TXD_W3_QSEL                     FIELD32(0x06000000) 
     1723#define TXD_W3_TCO                      FIELD32(0x20000000) 
     1724#define TXD_W3_UCO                      FIELD32(0x40000000) 
     1725#define TXD_W3_ICO                      FIELD32(0x80000000) 
     1726 
     1727/* 
     1728 * TX WI structure 
     1729 */ 
     1730 
     1731/* 
     1732 * Word0 
     1733 * FRAG: 1 To inform TKIP engine this is a fragment. 
     1734 * MIMO_PS: The remote peer is in dynamic MIMO-PS mode 
     1735 * TX_OP: 0:HT TXOP rule , 1:PIFS TX ,2:Backoff, 3:sifs 
     1736 * BW: Channel bandwidth 20MHz or 40 MHz 
     1737 * STBC: 1: STBC support MCS =0-7, 2,3 : RESERVED 
     1738 */ 
     1739#define TXWI_W0_FRAG                    FIELD32(0x00000001) 
     1740#define TXWI_W0_MIMO_PS                 FIELD32(0x00000002) 
     1741#define TXWI_W0_CF_ACK                  FIELD32(0x00000004) 
     1742#define TXWI_W0_TS                      FIELD32(0x00000008) 
     1743#define TXWI_W0_AMPDU                   FIELD32(0x00000010) 
     1744#define TXWI_W0_MPDU_DENSITY            FIELD32(0x000000e0) 
     1745#define TXWI_W0_TX_OP                   FIELD32(0x00000300) 
     1746#define TXWI_W0_MCS                     FIELD32(0x007f0000) 
     1747#define TXWI_W0_BW                      FIELD32(0x00800000) 
     1748#define TXWI_W0_SHORT_GI                FIELD32(0x01000000) 
     1749#define TXWI_W0_STBC                    FIELD32(0x06000000) 
     1750#define TXWI_W0_IFS                     FIELD32(0x08000000) 
     1751#define TXWI_W0_PHYMODE                 FIELD32(0xc0000000) 
     1752 
     1753/* 
     1754 * Word1 
     1755 */ 
     1756#define TXWI_W1_ACK                     FIELD32(0x00000001) 
     1757#define TXWI_W1_NSEQ                    FIELD32(0x00000002) 
     1758#define TXWI_W1_BW_WIN_SIZE             FIELD32(0x000000fc) 
     1759#define TXWI_W1_WIRELESS_CLI_ID         FIELD32(0x0000ff00) 
     1760#define TXWI_W1_MPDU_TOTAL_BYTE_COUNT   FIELD32(0x0fff0000) 
     1761#define TXWI_W1_PACKETID                FIELD32(0xf0000000) 
     1762 
     1763/* 
     1764 * Word2 
     1765 */ 
     1766#define TXWI_W2_IV                      FIELD32(0xffffffff) 
     1767 
     1768/* 
     1769 * Word3 
     1770 */ 
     1771#define TXWI_W3_EIV                     FIELD32(0xffffffff) 
     1772 
     1773/* 
     1774 * RX descriptor format for RX Ring. 
     1775 */ 
     1776 
     1777/* 
     1778 * Word0 
     1779 */ 
     1780#define RXD_W0_SDP0                     FIELD32(0xffffffff) 
     1781 
     1782/* 
     1783 * Word1 
     1784 */ 
     1785#define RXD_W1_SDL1                     FIELD32(0x00003fff) 
     1786#define RXD_W1_SDL0                     FIELD32(0x3fff0000) 
     1787#define RXD_W1_LS0                      FIELD32(0x40000000) 
     1788#define RXD_W1_DMA_DONE                 FIELD32(0x80000000) 
     1789 
     1790/* 
     1791 * Word2 
     1792 */ 
     1793#define RXD_W2_SDP1                     FIELD32(0xffffffff) 
     1794 
     1795/* 
     1796 * Word3 
     1797 * AMSDU: RX with 802.3 header, not 802.11 header. 
     1798 * DECRYPTED: This frame is being decrypted. 
     1799 */ 
     1800#define RXD_W3_BA                       FIELD32(0x00000001) 
     1801#define RXD_W3_DATA                     FIELD32(0x00000002) 
     1802#define RXD_W3_NULLDATA                 FIELD32(0x00000004) 
     1803#define RXD_W3_FRAG                     FIELD32(0x00000008) 
     1804#define RXD_W3_UNICAST_TO_ME            FIELD32(0x00000010) 
     1805#define RXD_W3_MULTICAST                FIELD32(0x00000020) 
     1806#define RXD_W3_BROADCAST                FIELD32(0x00000040) 
     1807#define RXD_W3_MY_BSS                   FIELD32(0x00000080) 
     1808#define RXD_W3_CRC_ERROR                FIELD32(0x00000100) 
     1809#define RXD_W3_CIPHER_ERROR             FIELD32(0x00000600) 
     1810#define RXD_W3_AMSDU                    FIELD32(0x00000800) 
     1811#define RXD_W3_HTC                      FIELD32(0x00001000) 
     1812#define RXD_W3_RSSI                     FIELD32(0x00002000) 
     1813#define RXD_W3_L2PAD                    FIELD32(0x00004000) 
     1814#define RXD_W3_AMPDU                    FIELD32(0x00008000) 
     1815#define RXD_W3_DECRYPTED                FIELD32(0x00010000) 
     1816#define RXD_W3_PLCP_SIGNAL              FIELD32(0x00020000) 
     1817#define RXD_W3_PLCP_RSSI                FIELD32(0x00040000) 
     1818 
     1819/* 
     1820 * RX WI structure 
     1821 */ 
     1822 
     1823/* 
     1824 * Word0 
     1825 */ 
     1826#define RXWI_W0_WIRELESS_CLI_ID         FIELD32(0x000000ff) 
     1827#define RXWI_W0_KEY_INDEX               FIELD32(0x00000300) 
     1828#define RXWI_W0_BSSID                   FIELD32(0x00001c00) 
     1829#define RXWI_W0_UDF                     FIELD32(0x0000e000) 
     1830#define RXWI_W0_MPDU_TOTAL_BYTE_COUNT   FIELD32(0x0fff0000) 
     1831#define RXWI_W0_TID                     FIELD32(0xf0000000) 
     1832 
     1833/* 
     1834 * Word1 
     1835 */ 
     1836#define RXWI_W1_FRAG                    FIELD32(0x0000000f) 
     1837#define RXWI_W1_SEQUENCE                FIELD32(0x0000fff0) 
     1838#define RXWI_W1_MCS                     FIELD32(0x007f0000) 
     1839#define RXWI_W1_BW                      FIELD32(0x00800000) 
     1840#define RXWI_W1_SHORT_GI                FIELD32(0x01000000) 
     1841#define RXWI_W1_STBC                    FIELD32(0x06000000) 
     1842#define RXWI_W1_PHYMODE                 FIELD32(0xc0000000) 
     1843 
     1844/* 
     1845 * Word2 
     1846 */ 
     1847#define RXWI_W2_RSSI0                   FIELD32(0x000000ff) 
     1848#define RXWI_W2_RSSI1                   FIELD32(0x0000ff00) 
     1849#define RXWI_W2_RSSI2                   FIELD32(0x00ff0000) 
     1850 
     1851/* 
     1852 * Word3 
     1853 */ 
     1854#define RXWI_W3_SNR0                    FIELD32(0x000000ff) 
     1855#define RXWI_W3_SNR1                    FIELD32(0x0000ff00) 
     1856 
     1857/* 
     1858 * Macro's for converting txpower from EEPROM to mac80211 value 
     1859 * and from mac80211 value to register value. 
     1860 */ 
     1861#define MIN_G_TXPOWER   0 
     1862#define MIN_A_TXPOWER   -7 
     1863#define MAX_G_TXPOWER   31 
     1864#define MAX_A_TXPOWER   15 
     1865#define DEFAULT_TXPOWER 5 
     1866 
     1867#define TXPOWER_G_FROM_DEV(__txpower) \ 
     1868        ((__txpower) > MAX_G_TXPOWER) ? DEFAULT_TXPOWER : (__txpower) 
     1869 
     1870#define TXPOWER_G_TO_DEV(__txpower) \ 
     1871        clamp_t(char, __txpower, MIN_G_TXPOWER, MAX_G_TXPOWER) 
     1872 
     1873#define TXPOWER_A_FROM_DEV(__txpower) \ 
     1874        ((__txpower) > MAX_A_TXPOWER) ? DEFAULT_TXPOWER : (__txpower) 
     1875 
     1876#define TXPOWER_A_TO_DEV(__txpower) \ 
     1877        clamp_t(char, __txpower, MIN_A_TXPOWER, MAX_A_TXPOWER) 
     1878 
     1879#endif /* RT2800PCI_H */ 
  • drivers/net/wireless/rt2x00/rt2x00.h

    a b struct rt2x00_chip { 
    139139#define RT2561          0x0302 
    140140#define RT2661          0x0401 
    141141#define RT2571          0x1300 
     142#define RT2860          0x0601  /* 2.4GHz PCI/CB */ 
     143#define RT2860D         0x0681  /* 2.4GHz, 5GHz PCI/CB */ 
     144#define RT2890          0x0701  /* 2.4GHz PCIe */ 
     145#define RT2890D         0x0781  /* 2.4GHz, 5GHz PCIe */ 
    142146 
    143147        u16 rf; 
    144148        u32 rev; 
Note: See TracBrowser for help on using the repository browser.