Changeset 13431


Ignore:
Timestamp:
2008-11-29T16:48:42+01:00 (8 years ago)
Author:
florian
Message:

[PATCH] Update mac80211 and make b43 driver build and load on targets other than brcm47xx (#4266)

Signed-off-by: Hauke Mehrtens <hauke@…>

Location:
trunk/package/mac80211
Files:
4 added
6 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/mac80211/Makefile

    r13320 r13431  
    1414 
    1515ifneq ($(CONFIG_LINUX_2_6_27),) 
    16   PKG_VERSION:=2008-11-03 
    17   PKG_SOURCE_URL:=http://www.orbit-lab.org/kernel/compat-wireless-2.6/2008/11 
     16  PKG_VERSION:=2008-11-29 
     17  PKG_SOURCE_URL:=http://wireless.kernel.org/download/compat-wireless-2.6/ 
    1818else 
    1919  PKG_VERSION:=2008-08-06 
    2020  PKG_SOURCE_URL:=http://www.orbit-lab.org/kernel/compat-wireless-2.6/2008/08 
    21   PATCH_DIR:=$(if $(CONFIG_TARGET_brcm47xx),./patches-brcm,./patches-old) 
     21  PATCH_DIR:=./patches-old 
    2222endif 
    2323 
     
    289289  TITLE:=Generic stuff for Broadcom wireless devices 
    290290  URL:=http://linuxwireless.org/en/users/Drivers/b43 
    291   DEPENDS:=+kmod-mac80211 +!TARGET_brcm47xx:kmod-ssb 
     291  DEPENDS:=+kmod-mac80211 +!TARGET_brcm47xx:kmod-ssb @LINUX_2_6_25||@LINUX_2_6_26||@LINUX_2_6_27||@LINUX_2_6_28 
    292292endef 
    293293 
     
    317317        -I$(PKG_BUILD_DIR)/include \ 
    318318        $(foreach opt,$(CONFOPTS),-DCONFIG_$(opt)) \ 
    319         $(if $(CONFIG_LEDS_TRIGGERS), -DCONFIG_MAC80211_LEDS -DCONFIG_LEDS_TRIGGERS) \ 
     319        $(if $(CONFIG_LEDS_TRIGGERS), -DCONFIG_MAC80211_LEDS -DCONFIG_LEDS_TRIGGERS -DCONFIG_B43_LEDS -DCONFIG_B43LEGACY_LEDS) \ 
     320        $(if $(CONFIG_RFKILL),-DCONFIG_B43_RFKILL -DCONFIG_B43LEGACY_RFKILL) \ 
     321        $(if $(CONFIG_PCMCIA),-DCONFIG_B43_PCMCIA) \ 
    320322        $(if $(CONFIG_DEBUG_FS), -DCONFIG_MAC80211_DEBUGFS) \ 
    321323        -D__CONFIG_MAC80211_RC_DEFAULT=minstrel \ 
     
    331333        CONFIG_MAC80211_LEDS=$(CONFIG_LEDS_TRIGGERS) \ 
    332334        CONFIG_MAC80211_DEBUGFS=$(CONFIG_DEBUG_FS) \ 
     335        CONFIG_B43_PCMCIA=$(CONFIG_PCMCIA) \ 
     336        CONFIG_B43_RFKILL=$(CONFIG_RFKILL) \ 
     337        CONFIG_B43LEGACY_RFKILL=$(CONFIG_RFKILL) \ 
     338        CONFIG_B43LEGACY_LEDS=$(CONFIG_LEDS_TRIGGERS) \ 
     339        CONFIG_B43_LEDS=$(CONFIG_LEDS_TRIGGERS) \ 
     340        $(if $(CONFIG_PACKAGE_kmod-b43),CONFIG_B43=m) \ 
     341        $(if $(CONFIG_PACKAGE_kmod-b43legacy),CONFIG_B43LEGACY=m) \ 
    333342        KLIB_BUILD="$(LINUX_DIR)" \ 
    334343        MODPROBE=: 
     
    344353        -unzip -jod $(PKG_BUILD_DIR) $(DL_DIR)/$(RT2860FW) 
    345354        $(TAR) -C $(PKG_BUILD_DIR) -xjf $(DL_DIR)/$(ZD1211FW_NAME)-$(ZD1211FW_VERSION).tar.bz2 
    346         $(if $(CONFIG_TARGET_brcm47xx),rm -rf $(PKG_BUILD_DIR)/include/linux/ssb) 
    347         rm $(PKG_BUILD_DIR)/include/net/ieee80211_crypt.h 
     355        rm -rf $(PKG_BUILD_DIR)/include/linux/ssb 
    348356        rm $(PKG_BUILD_DIR)/include/net/ieee80211.h 
    349357        rm $(PKG_BUILD_DIR)/include/net/ieee80211_radiotap.h 
  • trunk/package/mac80211/patches-old/001-disable_drivers.patch

    r13206 r13431  
    1 diff -urN compat-wireless-2008-08-06/config.mk compat-wireless-2008-08-06.new/config.mk 
    21--- compat-wireless-2008-08-06/config.mk        2008-07-18 06:11:03.000000000 +0200 
    3 +++ compat-wireless-2008-08-06.new/config.mk    2008-11-15 00:21:17.000000000 +0100 
    4 @@ -72,70 +72,8 @@ 
     2+++ compat-wireless-2008-08-06.new/config.mk    2008-11-28 21:10:31.000000000 +0100 
     3@@ -72,70 +72,34 @@ 
    54 CONFIG_ATH5K=m 
    65 CONFIG_ATH5K_DEBUG=n 
     
    1413-CONFIG_IWL4965_HT=y 
    1514-CONFIG_B43=m 
    16 -# B43 uses PCMCIA only for Compact Flash. The Cardbus cards uses PCI 
    17 -# Example, bcm4318: 
    18 -# http://www.multicap.biz/wireless-lan/indoor-wlan-hardware/sdc-cf10g-80211g-compact-flash-module 
     15+# CONFIG_B43=m 
     16+CONFIG_B43_NPHY=y 
     17 # B43 uses PCMCIA only for Compact Flash. The Cardbus cards uses PCI 
     18 # Example, bcm4318: 
     19 # http://www.multicap.biz/wireless-lan/indoor-wlan-hardware/sdc-cf10g-80211g-compact-flash-module 
    1920-CONFIG_B43_PCMCIA=y 
    20 -CONFIG_B43_DMA=y 
     21+# CONFIG_B43_PCMCIA=y 
     22 CONFIG_B43_DMA=y 
    2123-CONFIG_B43_PIO=y 
    22 -# B43_PIO selects SSB_BLOCKIO 
     24+# CONFIG_B43_PIO=y 
     25 # B43_PIO selects SSB_BLOCKIO 
    2326-CONFIG_SSB_BLOCKIO=y 
    2427-CONFIG_B43_DMA_AND_PIO_MODE=y 
     
    2730-#CONFIG_B43_RFKILL=n 
    2831-CONFIG_B43_LEDS=y 
    29 -# CONFIG_B43_DEBUG is not set 
    30 - 
     32+# CONFIG_SSB_BLOCKIO=y 
     33+# CONFIG_B43_DMA_AND_PIO_MODE=y 
     34+# CONFIG_B43_PCI_AUTOSELECT=y 
     35+# CONFIG_B43_PCICORE_AUTOSELECT=y 
     36+# CONFIG_B43_RFKILL=y 
     37+# CONFIG_B43_LEDS=y 
     38 # CONFIG_B43_DEBUG is not set 
     39  
    3140-CONFIG_B43LEGACY=m 
    3241-CONFIG_B43LEGACY_PCI_AUTOSELECT=y 
    3342-CONFIG_B43LEGACY_PCICORE_AUTOSELECT=y 
    34 -CONFIG_B43LEGACY_DMA=y 
     43+# CONFIG_B43LEGACY=m 
     44+# CONFIG_B43LEGACY_RFKILL=y 
     45+# CONFIG_B43LEGACY_LEDS=y 
     46+# CONFIG_B43LEGACY_PCI_AUTOSELECT=y 
     47+# CONFIG_B43LEGACY_PCICORE_AUTOSELECT=y 
     48 CONFIG_B43LEGACY_DMA=y 
    3549-CONFIG_B43LEGACY_PIO=y 
    3650-CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y 
     
    5872- 
    5973-NEED_IEEE80211=y 
    60 - 
     74+# CONFIG_B43LEGACY_PIO=y 
     75+# CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y 
     76  
    6177 CONFIG_P54_PCI=m 
    6278  
     
    7389 CONFIG_RT2400PCI=m 
    7490 CONFIG_RT2500PCI=m 
    75 @@ -159,31 +97,7 @@ 
     91@@ -159,31 +123,7 @@ 
    7692 ifneq ($(CONFIG_USB),) 
    7793 CONFIG_ZD1211RW=m 
     
    105121 # RT2500USB does not require firmware 
    106122 CONFIG_RT2500USB=m 
    107 @@ -212,36 +126,6 @@ 
     123@@ -212,36 +152,6 @@ 
    108124 # p54 
    109125 CONFIG_P54_COMMON=m 
  • trunk/package/mac80211/patches/210-remove_unused_stuff.patch

    r13114 r13431  
     1diff --git a/config.mk b/config.mk 
     2index d94a976..39fcaea 100644 
    13--- a/config.mk 
    24+++ b/config.mk 
    3 @@ -108,12 +108,12 @@ CONFIG_B43LEGACY_PIO=y 
     5@@ -69,10 +69,10 @@ CONFIG_MAC80211_LEDS=y 
     6 CONFIG_MAC80211_MESH=y 
     7  
     8 CONFIG_CFG80211=m 
     9-CONFIG_LIB80211=m 
     10-CONFIG_LIB80211_CRYPT_WEP=m 
     11-CONFIG_LIB80211_CRYPT_CCMP=m 
     12-CONFIG_LIB80211_CRYPT_TKIP=m 
     13+#CONFIG_LIB80211=m 
     14+#CONFIG_LIB80211_CRYPT_WEP=m 
     15+#CONFIG_LIB80211_CRYPT_CCMP=m 
     16+#CONFIG_LIB80211_CRYPT_TKIP=m 
     17  
     18 CONFIG_NL80211=y 
     19 # We'll disable this as soon major distributions 
     20@@ -101,14 +101,14 @@ CONFIG_B43=m 
     21 # B43 uses PCMCIA only for Compact Flash. The Cardbus cards uses PCI 
     22 # Example, bcm4318: 
     23 # http://www.multicap.biz/wireless-lan/indoor-wlan-hardware/sdc-cf10g-80211g-compact-flash-module 
     24-CONFIG_B43_PCMCIA=y 
     25+#CONFIG_B43_PCMCIA=y 
     26 CONFIG_B43_PIO=y 
     27 # B43_PIO selects SSB_BLOCKIO 
     28 CONFIG_SSB_BLOCKIO=y 
     29 CONFIG_B43_PCI_AUTOSELECT=y 
     30 CONFIG_B43_PCICORE_AUTOSELECT=y 
     31 #CONFIG_B43_RFKILL=n 
     32-CONFIG_B43_LEDS=y 
     33+#CONFIG_B43_LEDS=y 
     34 # CONFIG_B43_DEBUG is not set 
     35  
     36 CONFIG_B43LEGACY=m 
     37@@ -119,13 +119,13 @@ CONFIG_B43LEGACY_PIO=y 
    438 CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y 
    539  
    640 # The Intel ipws 
     41-CONFIG_LIBIPW=m 
    742-CONFIG_IPW2100=m 
    843-CONFIG_IPW2100_MONITOR=y 
     
    1146-CONFIG_IPW2200_RADIOTAP=y 
    1247-CONFIG_IPW2200_PROMISCUOUS=y 
    13 +# CONFIG_IPW2100=m 
    14 +# CONFIG_IPW2100_MONITOR=y 
    15 +# CONFIG_IPW2200=m 
    16 +# CONFIG_IPW2200_MONITOR=y 
    17 +# CONFIG_IPW2200_RADIOTAP=y 
    18 +# CONFIG_IPW2200_PROMISCUOUS=y 
     48+#CONFIG_LIBIPW=m 
     49+#CONFIG_IPW2100=m 
     50+#CONFIG_IPW2100_MONITOR=y 
     51+#CONFIG_IPW2200=m 
     52+#CONFIG_IPW2200_MONITOR=y 
     53+#CONFIG_IPW2200_RADIOTAP=y 
     54+#CONFIG_IPW2200_PROMISCUOUS=y 
    1955 # The above enables use a second interface prefixed 'rtap'. 
    2056 #           Example usage: 
    2157 # 
    22 @@ -126,9 +126,9 @@ CONFIG_IPW2200_PROMISCUOUS=y 
     58@@ -138,7 +138,7 @@ CONFIG_IPW2200_PROMISCUOUS=y 
    2359 # it on via sysfs: 
    2460 # 
    2561 # % echo 1 > /sys/bus/pci/drivers/ipw2200/*/rtap_iface 
    2662-CONFIG_IPW2200_QOS=y 
    27 +# CONFIG_IPW2200_QOS=y 
    28   
    29 -NEED_IEEE80211=y 
    30 +# NEED_IEEE80211=y 
     63+#CONFIG_IPW2200_QOS=y 
    3164  
    3265 CONFIG_P54_PCI=m 
    3366  
    34 @@ -227,8 +227,8 @@ CONFIG_SSB_PCICORE_HOSTMODE=n 
    35  # CONFIG_SSB_DRIVER_EXTIF=y 
    36   
     67@@ -239,15 +239,15 @@ CONFIG_SSB_PCICORE_HOSTMODE=n 
    3768 ifneq ($(CONFIG_USB),) 
    38 -CONFIG_LIBERTAS_USB=m 
     69 ifneq ($(CONFIG_LIBERTAS_THINFIRM_USB),m) 
     70 CONFIG_LIBERTAS_USB=m 
    3971-NEED_LIBERTAS=y 
    40 +#CONFIG_LIBERTAS_USB=m 
    4172+#NEED_LIBERTAS=y 
     73 endif 
    4274 endif 
    4375 ifneq ($(CONFIG_PCMCIA),) 
    4476 CONFIG_LIBERTAS_CS=m 
     77-NEED_LIBERTAS=y 
     78+#NEED_LIBERTAS=y 
     79 endif 
     80 ifeq ($(NEED_LIBERTAS),y) 
     81-CONFIG_LIBERTAS=m 
     82+#CONFIG_LIBERTAS=m 
     83 # Libertas uses the old stack but not fully, it will soon  
     84 # be cleaned. 
     85 endif 
  • trunk/package/mac80211/patches/310-rt2800_experimental.patch

    r13114 r13431  
    1 automatically generated from wireless-testing..rt2x00/experimental 
    2 do not edit 
     1From: Ivo van Doorn <IvDoorn@gmail.com> 
     2Date: Thu, 20 Nov 2008 22:42:04 +0000 (+0100) 
     3Subject: rt2x00: Add rt2800pci and rt2800usb (BROKEN) 
     4X-Git-Url: http://git.kernel.org/?p=linux%2Fkernel%2Fgit%2Fivd%2Frt2x00.git;a=commitdiff_plain;h=760e9f904b54ab91cd78aac6188851cfaac5c795 
    35 
     6rt2x00: Add rt2800pci and rt2800usb (BROKEN) 
     7 
     8incomplete code... 
     9 
     10Signed-off-by: Mattias Nissler <mattias.nissler@gmx.de> 
     11Signed-off-by: Felix Fietkau <nbd@openwrt.org> 
     12Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com> 
     13--- 
     14 
     15diff --git a/drivers/net/wireless/rt2x00/Makefile b/drivers/net/wireless/rt2x00/Makefile 
     16index 917cb4f..99cec67 100644 
    417--- a/drivers/net/wireless/rt2x00/Makefile 
    518+++ b/drivers/net/wireless/rt2x00/Makefile 
    6 @@ -14,5 +14,7 @@ obj-$(CONFIG_RT2X00_LIB_USB)          += rt2x00u 
     19@@ -14,5 +14,7 @@ obj-$(CONFIG_RT2X00_LIB_USB)          += rt2x00usb.o 
    720 obj-$(CONFIG_RT2400PCI)                        += rt2400pci.o 
    821 obj-$(CONFIG_RT2500PCI)                        += rt2500pci.o 
     
    1225 obj-$(CONFIG_RT73USB)                  += rt73usb.o 
    1326+obj-$(CONFIG_RT2800USB)                        += rt2800usb.o 
    14 --- a/drivers/net/wireless/rt2x00/rt2500usb.c 
    15 +++ b/drivers/net/wireless/rt2x00/rt2500usb.c 
    16 @@ -36,6 +36,13 @@ 
    17  #include "rt2500usb.h" 
    18   
    19  /* 
    20 + * Allow hardware encryption to be disabled. 
    21 + */ 
    22 +static int modparam_nohwcrypt = 0; 
    23 +module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO); 
    24 +MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption."); 
    25 + 
    26 +/* 
    27   * Register access. 
    28   * All access to the CSR registers will go through the methods 
    29   * rt2500usb_register_read and rt2500usb_register_write. 
    30 @@ -343,6 +350,85 @@ static void rt2500usb_init_led(struct rt 
    31  /* 
    32   * Configuration handlers. 
    33   */ 
    34 + 
    35 +/* 
    36 + * rt2500usb does not differentiate between shared and pairwise 
    37 + * keys, so we should use the same function for both key types. 
    38 + */ 
    39 +static int rt2500usb_config_key(struct rt2x00_dev *rt2x00dev, 
    40 +                               struct rt2x00lib_crypto *crypto, 
    41 +                               struct ieee80211_key_conf *key) 
    42 +{ 
    43 +       int timeout; 
    44 +       u32 mask; 
    45 +       u16 reg; 
    46 + 
    47 +       /* Support up to 4 keys */ 
    48 +       if (key->hw_key_idx >= 4) 
    49 +               return -ENOSPC; 
    50 + 
    51 +       if (crypto->cmd == SET_KEY) { 
    52 +               /* 
    53 +                * Pairwise key will always be entry 0, but this 
    54 +                * could collide with a shared key on the same 
    55 +                * position... 
    56 +                */ 
    57 +               mask = TXRX_CSR0_KEY_ID.bit_mask; 
    58 + 
    59 +               rt2500usb_register_read(rt2x00dev, TXRX_CSR0, &reg); 
    60 + 
    61 +               if ((reg & mask) && (reg & mask) == mask) 
    62 +                       return -ENOSPC; 
    63 + 
    64 +               reg = rt2x00_get_field16(reg, TXRX_CSR0_KEY_ID); 
    65 + 
    66 +               key->hw_key_idx += reg ? ffz(reg) : 0; 
    67 + 
    68 +               /* 
    69 +                * The encryption key doesn't fit within the CSR cache, 
    70 +                * this means we should allocate it seperately and use 
    71 +                * rt2x00usb_vendor_request() to send the key to the hardware. 
    72 +                */ 
    73 +               reg = KEY_ENTRY(key->hw_key_idx); 
    74 +               timeout = REGISTER_TIMEOUT32(sizeof(crypto->key)); 
    75 +               rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, 
    76 +                                                   USB_VENDOR_REQUEST_OUT, reg, 
    77 +                                                   crypto->key, 
    78 +                                                   sizeof(crypto->key), 
    79 +                                                   timeout); 
    80 + 
    81 +               /* 
    82 +                * The driver does not support the IV/EIV generation 
    83 +                * in hardware. However it doesn't support the IV/EIV 
    84 +                * inside the ieee80211 frame either, but requires it 
    85 +                * to be provided seperately for the descriptor. 
    86 +                * rt2x00lib will cut the IV/EIV data out of all frames 
    87 +                * given to us by mac80211, but we must tell mac80211 
    88 +                * to generate the IV/EIV data. 
    89 +                */ 
    90 +               key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 
    91 +               key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; 
    92 +       } 
    93 + 
    94 +       /* 
    95 +        * TXRX_CSR0_KEY_ID contains only single-bit fields to indicate 
    96 +        * a particular key is valid. 
    97 +        */ 
    98 +       rt2500usb_register_read(rt2x00dev, TXRX_CSR0, &reg); 
    99 +       rt2x00_set_field16(&reg, TXRX_CSR0_ALGORITHM, crypto->cipher); 
    100 +       rt2x00_set_field16(&reg, TXRX_CSR0_IV_OFFSET, IEEE80211_HEADER); 
    101 + 
    102 +       mask = rt2x00_get_field16(reg, TXRX_CSR0_KEY_ID); 
    103 +       if (crypto->cmd == SET_KEY) 
    104 +               mask |= 1 << key->hw_key_idx; 
    105 +       else if (crypto->cmd == DISABLE_KEY) 
    106 +               mask &= ~(1 << key->hw_key_idx); 
    107 +       rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, mask); 
    108 +       rt2500usb_register_write(rt2x00dev, TXRX_CSR0, reg); 
    109 + 
    110 +       return 0; 
    111 +} 
    112 + 
    113  static void rt2500usb_config_filter(struct rt2x00_dev *rt2x00dev, 
    114                                     const unsigned int filter_flags) 
    115  { 
    116 @@ -864,7 +950,7 @@ static int rt2500usb_init_registers(stru 
    117   
    118         rt2500usb_register_read(rt2x00dev, TXRX_CSR0, &reg); 
    119         rt2x00_set_field16(&reg, TXRX_CSR0_IV_OFFSET, IEEE80211_HEADER); 
    120 -       rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, 0xff); 
    121 +       rt2x00_set_field16(&reg, TXRX_CSR0_KEY_ID, 0); 
    122         rt2500usb_register_write(rt2x00dev, TXRX_CSR0, reg); 
    123   
    124         rt2500usb_register_read(rt2x00dev, MAC_CSR18, &reg); 
    125 @@ -1086,7 +1172,7 @@ static void rt2500usb_write_tx_desc(stru 
    126          * Start writing the descriptor words. 
    127          */ 
    128         rt2x00_desc_read(txd, 1, &word); 
    129 -       rt2x00_set_field32(&word, TXD_W1_IV_OFFSET, IEEE80211_HEADER); 
    130 +       rt2x00_set_field32(&word, TXD_W1_IV_OFFSET, txdesc->iv_offset); 
    131         rt2x00_set_field32(&word, TXD_W1_AIFS, txdesc->aifs); 
    132         rt2x00_set_field32(&word, TXD_W1_CWMIN, txdesc->cw_min); 
    133         rt2x00_set_field32(&word, TXD_W1_CWMAX, txdesc->cw_max); 
    134 @@ -1099,6 +1185,11 @@ static void rt2500usb_write_tx_desc(stru 
    135         rt2x00_set_field32(&word, TXD_W2_PLCP_LENGTH_HIGH, txdesc->length_high); 
    136         rt2x00_desc_write(txd, 2, word); 
    137   
    138 +       if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags)) { 
    139 +               _rt2x00_desc_write(txd, 3, skbdesc->iv); 
    140 +               _rt2x00_desc_write(txd, 4, skbdesc->eiv); 
    141 +       } 
    142 + 
    143         rt2x00_desc_read(txd, 0, &word); 
    144         rt2x00_set_field32(&word, TXD_W0_RETRY_LIMIT, txdesc->retry_limit); 
    145         rt2x00_set_field32(&word, TXD_W0_MORE_FRAG, 
    146 @@ -1113,7 +1204,8 @@ static void rt2500usb_write_tx_desc(stru 
    147                            test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags)); 
    148         rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->ifs); 
    149         rt2x00_set_field32(&word, TXD_W0_DATABYTE_COUNT, skb->len); 
    150 -       rt2x00_set_field32(&word, TXD_W0_CIPHER, CIPHER_NONE); 
    151 +       rt2x00_set_field32(&word, TXD_W0_CIPHER, txdesc->cipher); 
    152 +       rt2x00_set_field32(&word, TXD_W0_KEY_ID, txdesc->key_idx); 
    153         rt2x00_desc_write(txd, 0, word); 
    154  } 
    155   
    156 @@ -1225,6 +1317,7 @@ static void rt2500usb_kick_tx_queue(stru 
    157  static void rt2500usb_fill_rxdone(struct queue_entry *entry, 
    158                                   struct rxdone_entry_desc *rxdesc) 
    159  { 
    160 +       struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 
    161         struct queue_entry_priv_usb *entry_priv = entry->priv_data; 
    162         struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); 
    163         __le32 *rxd = 
    164 @@ -1252,6 +1345,31 @@ static void rt2500usb_fill_rxdone(struct 
    165         if (rt2x00_get_field32(word0, RXD_W0_PHYSICAL_ERROR)) 
    166                 rxdesc->flags |= RX_FLAG_FAILED_PLCP_CRC; 
    167   
    168 +       if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags)) { 
    169 +               rxdesc->cipher = rt2x00_get_field32(word0, RXD_W0_CIPHER); 
    170 +               if (rt2x00_get_field32(word0, RXD_W0_CIPHER_ERROR)) 
    171 +                       rxdesc->cipher_status = RX_CRYPTO_FAIL_KEY; 
    172 +       } 
    173 + 
    174 +       if (rxdesc->cipher != CIPHER_NONE) { 
    175 +               _rt2x00_desc_read(rxd, 2, &rxdesc->iv); 
    176 +               _rt2x00_desc_read(rxd, 3, &rxdesc->eiv); 
    177 +               /* ICV is located at the end of frame */ 
    178 + 
    179 +               /* 
    180 +                * Hardware has stripped IV/EIV data from 802.11 frame during 
    181 +                * decryption. It has provided the data seperately but rt2x00lib 
    182 +                * should decide if it should be reinserted. 
    183 +                */ 
    184 +               rxdesc->flags |= RX_FLAG_IV_STRIPPED; 
    185 +               if (rxdesc->cipher != CIPHER_TKIP) 
    186 +                       rxdesc->flags |= RX_FLAG_MMIC_STRIPPED; 
    187 +               if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS) 
    188 +                       rxdesc->flags |= RX_FLAG_DECRYPTED; 
    189 +               else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC) 
    190 +                       rxdesc->flags |= RX_FLAG_MMIC_ERROR; 
    191 +       } 
    192 + 
    193         /* 
    194          * Obtain the status about this packet. 
    195          * When frame was received with an OFDM bitrate, 
    196 @@ -1259,8 +1377,8 @@ static void rt2500usb_fill_rxdone(struct 
    197          * a CCK bitrate the signal is the rate in 100kbit/s. 
    198          */ 
    199         rxdesc->signal = rt2x00_get_field32(word1, RXD_W1_SIGNAL); 
    200 -       rxdesc->rssi = rt2x00_get_field32(word1, RXD_W1_RSSI) - 
    201 -           entry->queue->rt2x00dev->rssi_offset; 
    202 +       rxdesc->rssi = 
    203 +           rt2x00_get_field32(word1, RXD_W1_RSSI) - rt2x00dev->rssi_offset; 
    204         rxdesc->size = rt2x00_get_field32(word0, RXD_W0_DATABYTE_COUNT); 
    205   
    206         if (rt2x00_get_field32(word0, RXD_W0_OFDM)) 
    207 @@ -1750,6 +1868,8 @@ static int rt2500usb_probe_hw(struct rt2 
    208         __set_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags); 
    209         __set_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags); 
    210         __set_bit(DRIVER_REQUIRE_SCHEDULED, &rt2x00dev->flags); 
    211 +       if (!modparam_nohwcrypt) 
    212 +               __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags); 
    213         __set_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags); 
    214   
    215         /* 
    216 @@ -1769,6 +1889,7 @@ static const struct ieee80211_ops rt2500 
    217         .config                 = rt2x00mac_config, 
    218         .config_interface       = rt2x00mac_config_interface, 
    219         .configure_filter       = rt2x00mac_configure_filter, 
    220 +       .set_key                = rt2x00mac_set_key, 
    221         .get_stats              = rt2x00mac_get_stats, 
    222         .bss_info_changed       = rt2x00mac_bss_info_changed, 
    223         .conf_tx                = rt2x00mac_conf_tx, 
    224 @@ -1791,6 +1912,8 @@ static const struct rt2x00lib_ops rt2500 
    225         .get_tx_data_len        = rt2500usb_get_tx_data_len, 
    226         .kick_tx_queue          = rt2500usb_kick_tx_queue, 
    227         .fill_rxdone            = rt2500usb_fill_rxdone, 
    228 +       .config_shared_key      = rt2500usb_config_key, 
    229 +       .config_pairwise_key    = rt2500usb_config_key, 
    230         .config_filter          = rt2500usb_config_filter, 
    231         .config_intf            = rt2500usb_config_intf, 
    232         .config_erp             = rt2500usb_config_erp, 
    233 --- a/drivers/net/wireless/rt2x00/rt2500usb.h 
    234 +++ b/drivers/net/wireless/rt2x00/rt2500usb.h 
    235 @@ -447,6 +447,9 @@ 
    236  #define SEC_CSR30                      0x04bc 
    237  #define SEC_CSR31                      0x04be 
    238   
    239 +#define KEY_ENTRY(__idx) \ 
    240 +       ( SEC_CSR0 + ((__idx) * 16) ) 
    241 + 
    242  /* 
    243   * PHY control registers. 
    244   */ 
     27diff --git a/drivers/net/wireless/rt2x00/rt2800pci.c b/drivers/net/wireless/rt2x00/rt2800pci.c 
     28new file mode 100644 
     29index 0000000..65e9915 
    24530--- /dev/null 
    24631+++ b/drivers/net/wireless/rt2x00/rt2800pci.c 
    247 @@ -0,0 +1,2556 @@ 
     32@@ -0,0 +1,2576 @@ 
    24833+/* 
    24934+       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     
    30388+ * and we will print an error. 
    30489+ */ 
    305 +static u32 rt2800pci_bbp_check(struct rt2x00_dev *rt2x00dev) 
    306 +{ 
    307 +       u32 reg; 
    308 +       unsigned int i; 
    309 + 
    310 +       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    311 +               rt2x00pci_register_read(rt2x00dev, BBP_CSR_CFG, &reg); 
    312 +               if (!rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) 
    313 +                       break; 
    314 +               udelay(REGISTER_BUSY_DELAY); 
    315 +       } 
    316 + 
    317 +       return reg; 
    318 +} 
     90+#define WAIT_FOR_BBP(__dev, __reg) \ 
     91+       rt2x00pci_regbusy_read((__dev), BBP_CSR_CFG, BBP_CSR_CFG_BUSY, (__reg)) 
     92+#define WAIT_FOR_RF(__dev, __reg) \ 
     93+       rt2x00pci_regbusy_read((__dev), RF_CSR_CFG0, RF_CSR_CFG0_BUSY, (__reg)) 
     94+#define WAIT_FOR_MCU(__dev, __reg) \ 
     95+       rt2x00pci_regbusy_read((__dev), H2M_MAILBOX_CSR, \ 
     96+                              H2M_MAILBOX_CSR_OWNER, (__reg)) 
    31997+ 
    32098+static void rt2800pci_bbp_write(struct rt2x00_dev *rt2x00dev, 
     
    323101+       u32 reg; 
    324102+ 
    325 +       /* 
    326 +        * Wait until the BBP becomes ready. 
    327 +        */ 
    328 +       reg = rt2800pci_bbp_check(rt2x00dev); 
    329 +       if (rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) { 
    330 +               ERROR(rt2x00dev, "PHY_CSR3 register busy. Write failed.\n"); 
    331 +               return; 
    332 +       } 
    333 + 
    334 +       /* 
    335 +        * Write the data into the BBP. 
    336 +        */ 
    337 +       reg = 0; 
    338 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_VALUE, value); 
    339 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
    340 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
    341 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 0); 
    342 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_BBP_RW_MODE, 1); 
    343 + 
    344 +       rt2x00pci_register_write(rt2x00dev, BBP_CSR_CFG, reg); 
     103+       mutex_lock(&rt2x00dev->csr_mutex); 
     104+ 
     105+       /* 
     106+        * Wait until the BBP becomes available, afterwards we 
     107+        * can safely write the new data into the register. 
     108+        */ 
     109+       if (WAIT_FOR_BBP(rt2x00dev, &reg)) { 
     110+               reg = 0; 
     111+               rt2x00_set_field32(&reg, BBP_CSR_CFG_VALUE, value); 
     112+               rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
     113+               rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
     114+               rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 0); 
     115+               rt2x00_set_field32(&reg, BBP_CSR_CFG_BBP_RW_MODE, 1); 
     116+ 
     117+               rt2x00pci_register_write(rt2x00dev, BBP_CSR_CFG, reg); 
     118+       } 
     119+ 
     120+       mutex_unlock(&rt2x00dev->csr_mutex); 
    345121+} 
    346122+ 
     
    350126+       u32 reg; 
    351127+ 
    352 +       /* 
    353 +        * Wait until the BBP becomes ready. 
    354 +        */ 
    355 +       reg = rt2800pci_bbp_check(rt2x00dev); 
    356 +       if (rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) { 
    357 +               ERROR(rt2x00dev, "PHY_CSR3 register busy. Read failed.\n"); 
    358 +               return; 
    359 +       } 
    360 + 
    361 +       /* 
    362 +        * Write the request into the BBP. 
    363 +        */ 
    364 +       reg = 0; 
    365 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
    366 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
    367 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 1); 
    368 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_BBP_RW_MODE, 1); 
    369 + 
    370 +       rt2x00pci_register_write(rt2x00dev, BBP_CSR_CFG, reg); 
    371 + 
    372 +       /* 
    373 +        * Wait until the BBP becomes ready. 
    374 +        */ 
    375 +       reg = rt2800pci_bbp_check(rt2x00dev); 
    376 +       if (rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) { 
    377 +               ERROR(rt2x00dev, "PHY_CSR3 register busy. Read failed.\n"); 
    378 +               *value = 0xff; 
    379 +               return; 
     128+       mutex_lock(&rt2x00dev->csr_mutex); 
     129+ 
     130+       /* 
     131+        * Wait until the BBP becomes available, afterwards we 
     132+        * can safely write the read request into the register. 
     133+        * After the data has been written, we wait until hardware 
     134+        * returns the correct value, if at any time the register 
     135+        * doesn't become available in time, reg will be 0xffffffff 
     136+        * which means we return 0xff to the caller. 
     137+        */ 
     138+       if (WAIT_FOR_BBP(rt2x00dev, &reg)) { 
     139+               reg = 0; 
     140+               rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
     141+               rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
     142+               rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 1); 
     143+               rt2x00_set_field32(&reg, BBP_CSR_CFG_BBP_RW_MODE, 1); 
     144+ 
     145+               rt2x00pci_register_write(rt2x00dev, BBP_CSR_CFG, reg); 
     146+ 
     147+               WAIT_FOR_BBP(rt2x00dev, &reg); 
    380148+       } 
    381149+ 
    382150+       *value = rt2x00_get_field32(reg, BBP_CSR_CFG_VALUE); 
     151+ 
     152+       mutex_unlock(&rt2x00dev->csr_mutex); 
    383153+} 
    384154+ 
     
    387157+{ 
    388158+       u32 reg; 
    389 +       unsigned int i; 
    390159+ 
    391160+       if (!word) 
    392161+               return; 
    393162+ 
    394 +       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    395 +               rt2x00pci_register_read(rt2x00dev, RF_CSR_CFG0, &reg); 
    396 +               if (!rt2x00_get_field32(reg, RF_CSR_CFG0_BUSY)) 
    397 +                       goto rf_write; 
    398 +               udelay(REGISTER_BUSY_DELAY); 
    399 +       } 
    400 + 
    401 +       ERROR(rt2x00dev, "RF_CSR_CFG0 register busy. Write failed.\n"); 
    402 +       return; 
    403 + 
    404 +rf_write: 
    405 +       reg = 0; 
    406 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_REG_VALUE_BW, value); 
    407 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_STANDBYMODE, 0); 
    408 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_SEL, 0); 
    409 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_BUSY, 1); 
    410 + 
    411 +       rt2x00pci_register_write(rt2x00dev, RF_CSR_CFG0, reg); 
    412 +       rt2x00_rf_write(rt2x00dev, word, value); 
     163+       mutex_lock(&rt2x00dev->csr_mutex); 
     164+ 
     165+       /* 
     166+        * Wait until the RF becomes available, afterwards we 
     167+        * can safely write the new data into the register. 
     168+        */ 
     169+       if (WAIT_FOR_RF(rt2x00dev, &reg)) { 
     170+               reg = 0; 
     171+               rt2x00_set_field32(&reg, RF_CSR_CFG0_REG_VALUE_BW, value); 
     172+               rt2x00_set_field32(&reg, RF_CSR_CFG0_STANDBYMODE, 0); 
     173+               rt2x00_set_field32(&reg, RF_CSR_CFG0_SEL, 0); 
     174+               rt2x00_set_field32(&reg, RF_CSR_CFG0_BUSY, 1); 
     175+ 
     176+               rt2x00pci_register_write(rt2x00dev, RF_CSR_CFG0, reg); 
     177+               rt2x00_rf_write(rt2x00dev, word, value); 
     178+       } 
     179+ 
     180+       mutex_unlock(&rt2x00dev->csr_mutex); 
     181+} 
     182+ 
     183+static void rt2800pci_mcu_request(struct rt2x00_dev *rt2x00dev, 
     184+                                 const u8 command, const u8 token, 
     185+                                 const u8 arg0, const u8 arg1) 
     186+{ 
     187+       u32 reg; 
     188+ 
     189+       mutex_lock(&rt2x00dev->csr_mutex); 
     190+ 
     191+       /* 
     192+        * Wait until the MCU becomes available, afterwards we 
     193+        * can safely write the new data into the register. 
     194+        */ 
     195+       if (WAIT_FOR_MCU(rt2x00dev, &reg)) { 
     196+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_OWNER, 1); 
     197+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_CMD_TOKEN, token); 
     198+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG0, arg0); 
     199+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG1, arg1); 
     200+               rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CSR, reg); 
     201+ 
     202+               reg = 0; 
     203+               rt2x00_set_field32(&reg, HOST_CMD_CSR_HOST_COMMAND, command); 
     204+               rt2x00pci_register_write(rt2x00dev, HOST_CMD_CSR, reg); 
     205+       } 
     206+ 
     207+       mutex_unlock(&rt2x00dev->csr_mutex); 
    413208+} 
    414209+ 
     
    441236+ 
    442237+       rt2x00pci_register_write(rt2x00dev, E2PROM_CSR, reg); 
    443 +} 
    444 + 
    445 +static void rt2800pci_mcu_request(struct rt2x00_dev *rt2x00dev, 
    446 +                                 const u8 command, const u8 token, 
    447 +                                 const u8 arg0, const u8 arg1) 
    448 +{ 
    449 +       unsigned int i; 
    450 +       u32 reg; 
    451 + 
    452 +       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    453 +               rt2x00pci_register_read(rt2x00dev, H2M_MAILBOX_CSR, &reg); 
    454 +               if (!rt2x00_get_field32(reg, H2M_MAILBOX_CSR_OWNER)) 
    455 +                       goto mcu_write; 
    456 +               udelay(REGISTER_BUSY_DELAY); 
    457 +       } 
    458 + 
    459 +       ERROR(rt2x00dev, "mcu request error. " 
    460 +             "Request 0x%02x failed for token 0x%02x.\n", 
    461 +             command, token); 
    462 +       return; 
    463 + 
    464 +mcu_write: 
    465 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_OWNER, 1); 
    466 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_CMD_TOKEN, token); 
    467 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG0, arg0); 
    468 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG1, arg1); 
    469 +       rt2x00pci_register_write(rt2x00dev, H2M_MAILBOX_CSR, reg); 
    470 + 
    471 +       reg = 0; 
    472 +       rt2x00_set_field32(&reg, HOST_CMD_CSR_HOST_COMMAND, command); 
    473 +       rt2x00pci_register_write(rt2x00dev, HOST_CMD_CSR, reg); 
    474238+} 
    475239+ 
     
    736500+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_TO_ME, 
    737501+                          !(filter_flags & FIF_PROMISC_IN_BSS)); 
    738 +       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 0); 
     502+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 
     503+                          !(filter_flags & FIF_OTHER_BSS)); 
    739504+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_VER_ERROR, 1); 
    740505+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_MULTICAST, 
     
    13451110+ * Initialization functions. 
    13461111+ */ 
    1347 +static void rt2800pci_init_rxentry(struct rt2x00_dev *rt2x00dev, 
    1348 +                                  struct queue_entry *entry) 
     1112+static bool rt2800pci_get_entry_state(struct queue_entry *entry) 
     1113+{ 
     1114+       struct queue_entry_priv_pci *entry_priv = entry->priv_data; 
     1115+       u32 word; 
     1116+ 
     1117+       if (entry->queue->qid == QID_RX) { 
     1118+               rt2x00_desc_read(entry_priv->desc, 1, &word); 
     1119+ 
     1120+               return (!rt2x00_get_field32(word, RXD_W1_DMA_DONE)); 
     1121+       } else { 
     1122+               rt2x00_desc_read(entry_priv->desc, 0, &word); 
     1123+ 
     1124+               return (!rt2x00_get_field32(word, TXD_W1_DMA_DONE)); 
     1125+       } 
     1126+} 
     1127+ 
     1128+static void rt2800pci_clear_entry(struct queue_entry *entry) 
    13491129+{ 
    13501130+       struct queue_entry_priv_pci *entry_priv = entry->priv_data; 
     
    13521132+       u32 word; 
    13531133+ 
    1354 +       rt2x00_desc_read(entry_priv->desc, 0, &word); 
    1355 +       rt2x00_set_field32(&word, RXD_W0_SDP0, skbdesc->skb_dma); 
    1356 +       rt2x00_desc_write(entry_priv->desc, 0, word); 
    1357 + 
    1358 +       rt2x00_desc_read(entry_priv->desc, 1, &word); 
    1359 +       rt2x00_set_field32(&word, RXD_W1_DMA_DONE, 0); 
    1360 +       rt2x00_desc_write(entry_priv->desc, 1, word); 
    1361 +} 
    1362 + 
    1363 +static void rt2800pci_init_txentry(struct rt2x00_dev *rt2x00dev, 
    1364 +                                  struct queue_entry *entry) 
    1365 +{ 
    1366 +       struct queue_entry_priv_pci *entry_priv = entry->priv_data; 
    1367 +       u32 word; 
    1368 + 
    1369 +       rt2x00_desc_read(entry_priv->desc, 1, &word); 
    1370 +       rt2x00_set_field32(&word, TXD_W1_DMA_DONE, 1); 
    1371 +       rt2x00_desc_write(entry_priv->desc, 1, word); 
     1134+       if (entry->queue->qid == QID_RX) { 
     1135+               rt2x00_desc_read(entry_priv->desc, 0, &word); 
     1136+               rt2x00_set_field32(&word, RXD_W0_SDP0, skbdesc->skb_dma); 
     1137+               rt2x00_desc_write(entry_priv->desc, 0, word); 
     1138+ 
     1139+               rt2x00_desc_read(entry_priv->desc, 1, &word); 
     1140+               rt2x00_set_field32(&word, RXD_W1_DMA_DONE, 0); 
     1141+               rt2x00_desc_write(entry_priv->desc, 1, word); 
     1142+       } else { 
     1143+               rt2x00_desc_read(entry_priv->desc, 1, &word); 
     1144+               rt2x00_set_field32(&word, TXD_W1_DMA_DONE, 1); 
     1145+               rt2x00_desc_write(entry_priv->desc, 1, word); 
     1146+       } 
    13721147+} 
    13731148+ 
     
    17731548+                                enum dev_state state) 
    17741549+{ 
    1775 +       int mask = (state == STATE_RADIO_IRQ_OFF); 
     1550+       int mask = (state == STATE_RADIO_IRQ_ON); 
    17761551+       u32 reg; 
    17771552+ 
     
    20831858+ 
    20841859+static void rt2800pci_kick_tx_queue(struct rt2x00_dev *rt2x00dev, 
    2085 +                                   const enum data_queue_qid queue) 
    2086 +{ 
     1860+                                   const enum data_queue_qid queue_idx) 
     1861+{ 
     1862+       struct data_queue *queue; 
     1863+       unsigned int idx, qidx = 0; 
    20871864+       u32 reg; 
    20881865+ 
    2089 +       if (queue == QID_BEACON) { 
     1866+       if (queue_idx == QID_BEACON) { 
    20901867+               rt2x00pci_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
    20911868+               if (!rt2x00_get_field32(reg, BCN_TIME_CFG_BEACON_GEN)) { 
     
    20981875+       } 
    20991876+ 
    2100 +       /* FIXME: How can be kick normal TX queues? */ 
     1877+       if (queue_idx > QID_HCCA && queue_idx != QID_MGMT) 
     1878+               return; 
     1879+ 
     1880+       queue = rt2x00queue_get_queue(rt2x00dev, queue_idx); 
     1881+       idx = queue->index[Q_INDEX]; 
     1882+ 
     1883+       if (queue_idx == QID_MGMT) 
     1884+               qidx = 5; 
     1885+       else 
     1886+               qidx = queue_idx; 
     1887+ 
     1888+       rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX(qidx), idx); 
    21011889+} 
    21021890+ 
     
    21921980+{ 
    21931981+       struct rt2x00_dev *rt2x00dev = dev_instance; 
    2194 + 
    2195 +       /* FIXME */ 
     1982+       u32 reg; 
     1983+ 
     1984+       /* Read status and ACK all interrupts */ 
     1985+       rt2x00pci_register_read(rt2x00dev, INT_SOURCE_CSR, &reg); 
     1986+       rt2x00pci_register_write(rt2x00dev, INT_SOURCE_CSR, reg); 
     1987+ 
     1988+       if (!reg) 
     1989+               return IRQ_NONE; 
     1990+ 
     1991+       if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 
     1992+               return IRQ_HANDLED; 
     1993+ 
     1994+       /* 
     1995+        * 1 - Rx ring done interrupt. 
     1996+        */ 
     1997+       if (rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE)) 
     1998+               rt2x00pci_rxdone(rt2x00dev); 
     1999+ 
     2000+       /* TODO: TX DONE */ 
    21962001+ 
    21972002+       return IRQ_HANDLED; 
     
    27022507+       .initialize             = rt2x00pci_initialize, 
    27032508+       .uninitialize           = rt2x00pci_uninitialize, 
    2704 +       .init_rxentry           = rt2800pci_init_rxentry, 
    2705 +       .init_txentry           = rt2800pci_init_txentry, 
     2509+       .get_entry_state        = rt2800pci_get_entry_state, 
     2510+       .clear_entry            = rt2800pci_clear_entry, 
    27062511+       .set_device_state       = rt2800pci_set_device_state, 
    27072512+       .rfkill_poll            = rt2800pci_rfkill_poll, 
     
    28022607+module_init(rt2800pci_init); 
    28032608+module_exit(rt2800pci_exit); 
     2609diff --git a/drivers/net/wireless/rt2x00/rt2800pci.h b/drivers/net/wireless/rt2x00/rt2800pci.h 
     2610new file mode 100644 
     2611index 0000000..66593ed 
    28042612--- /dev/null 
    28052613+++ b/drivers/net/wireless/rt2x00/rt2800pci.h 
    2806 @@ -0,0 +1,1862 @@ 
     2614@@ -0,0 +1,1871 @@ 
    28072615+/* 
    28082616+       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     
    31172925+#define TX_CTX_IDX5                    0x0288 
    31182926+#define TX_DTX_IDX5                    0x028c 
     2927+ 
     2928+/* 
     2929+ * Queue register offset macros 
     2930+ */ 
     2931+#define TX_QUEUE_REG_OFFSET            0x10 
     2932+#define TX_BASE_PTR(__x)               TX_BASE_PTR0 + ((__x) * TX_QUEUE_REG_OFFSET) 
     2933+#define TX_MAX_CNT(__x)                        TX_MAX_CNT0 + ((__x) * TX_QUEUE_REG_OFFSET) 
     2934+#define TX_CTX_IDX(__x)                        TX_CTX_IDX0 + ((__x) * TX_QUEUE_REG_OFFSET) 
     2935+#define TX_DTX_IDX(__x)                        TX_DTX_IDX0 + ((__x) * TX_QUEUE_REG_OFFSET) 
    31192936+ 
    31202937+/* 
     
    46674484+ 
    46684485+#endif /* RT2800PCI_H */ 
     4486diff --git a/drivers/net/wireless/rt2x00/rt2800usb.c b/drivers/net/wireless/rt2x00/rt2800usb.c 
     4487new file mode 100644 
     4488index 0000000..761a7ec 
    46694489--- /dev/null 
    46704490+++ b/drivers/net/wireless/rt2x00/rt2800usb.c 
    4671 @@ -0,0 +1,2594 @@ 
     4491@@ -0,0 +1,2498 @@ 
    46724492+/* 
    46734493+       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     
    47184538+ * Register access. 
    47194539+ * All access to the CSR registers will go through the methods 
    4720 + * rt2800usb_register_read and rt2800usb_register_write. 
     4540+ * rt2x00usb_register_read and rt2x00usb_register_write. 
    47214541+ * BBP and RF register require indirect register access, 
    47224542+ * and use the CSR registers BBPCSR and RFCSR to achieve this. 
     
    47274547+ * the access attempt is considered to have failed, 
    47284548+ * and we will print an error. 
    4729 + * The _lock versions must be used if you already hold the usb_cache_mutex 
    4730 + */ 
    4731 +static inline void rt2800usb_register_read(struct rt2x00_dev *rt2x00dev, 
    4732 +                                          const unsigned int offset, 
    4733 +                                          u32 *value) 
    4734 +{ 
    4735 +       __le32 reg; 
    4736 +       rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_READ, 
    4737 +                                     USB_VENDOR_REQUEST_IN, offset, 
    4738 +                                     &reg, sizeof(u32), REGISTER_TIMEOUT); 
    4739 +       *value = le32_to_cpu(reg); 
    4740 +} 
    4741 + 
    4742 +static inline void rt2800usb_register_read_lock(struct rt2x00_dev *rt2x00dev, 
    4743 +                                               const unsigned int offset, 
    4744 +                                               u32 *value) 
    4745 +{ 
    4746 +       __le32 reg; 
    4747 +       rt2x00usb_vendor_req_buff_lock(rt2x00dev, USB_MULTI_READ, 
    4748 +                                      USB_VENDOR_REQUEST_IN, offset, 
    4749 +                                      &reg, sizeof(u32), REGISTER_TIMEOUT); 
    4750 +       *value = le32_to_cpu(reg); 
    4751 +} 
    4752 + 
    4753 +static inline void rt2800usb_register_multiread(struct rt2x00_dev *rt2x00dev, 
    4754 +                                               const unsigned int offset, 
    4755 +                                               void *value, const u32 length) 
    4756 +{ 
    4757 +       int timeout = REGISTER_TIMEOUT * (length / sizeof(u32)); 
    4758 +       rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_READ, 
    4759 +                                     USB_VENDOR_REQUEST_IN, offset, 
    4760 +                                     value, length, timeout); 
    4761 +} 
    4762 + 
    4763 +static inline void rt2800usb_register_write(struct rt2x00_dev *rt2x00dev, 
    4764 +                                           const unsigned int offset, 
    4765 +                                           u32 value) 
    4766 +{ 
    4767 +       __le32 reg = cpu_to_le32(value); 
    4768 +       rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_WRITE, 
    4769 +                                     USB_VENDOR_REQUEST_OUT, offset, 
    4770 +                                     &reg, sizeof(u32), REGISTER_TIMEOUT); 
    4771 +} 
    4772 + 
    4773 +static inline void rt2800usb_register_write_lock(struct rt2x00_dev *rt2x00dev, 
    4774 +                                                const unsigned int offset, 
    4775 +                                                u32 value) 
    4776 +{ 
    4777 +       __le32 reg = cpu_to_le32(value); 
    4778 +       rt2x00usb_vendor_req_buff_lock(rt2x00dev, USB_MULTI_WRITE, 
    4779 +                                      USB_VENDOR_REQUEST_OUT, offset, 
    4780 +                                     &reg, sizeof(u32), REGISTER_TIMEOUT); 
    4781 +} 
    4782 + 
    4783 +static inline void rt2800usb_register_multiwrite(struct rt2x00_dev *rt2x00dev, 
    4784 +                                                const unsigned int offset, 
    4785 +                                                void *value, const u32 length) 
    4786 +{ 
    4787 +       int timeout = REGISTER_TIMEOUT * (length / sizeof(u32)); 
    4788 +       rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_WRITE, 
    4789 +                                     USB_VENDOR_REQUEST_OUT, offset, 
    4790 +                                     value, length, timeout); 
    4791 +} 
    4792 + 
    4793 +static u32 rt2800usb_bbp_check(struct rt2x00_dev *rt2x00dev) 
    4794 +{ 
    4795 +       u32 reg; 
    4796 +       unsigned int i; 
    4797 + 
    4798 +       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    4799 +               rt2800usb_register_read_lock(rt2x00dev, BBP_CSR_CFG, &reg); 
    4800 +               if (!rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) 
    4801 +                       break; 
    4802 +               udelay(REGISTER_BUSY_DELAY); 
    4803 +       } 
    4804 + 
    4805 +       return reg; 
    4806 +} 
     4549+ * The _lock versions must be used if you already hold the csr_mutex 
     4550+ */ 
     4551+#define WAIT_FOR_BBP(__dev, __reg) \ 
     4552+       rt2x00usb_regbusy_read((__dev), BBP_CSR_CFG, BBP_CSR_CFG_BUSY, (__reg)) 
     4553+#define WAIT_FOR_RF(__dev, __reg) \ 
     4554+       rt2x00usb_regbusy_read((__dev), RF_CSR_CFG0, RF_CSR_CFG0_BUSY, (__reg)) 
     4555+#define WAIT_FOR_MCU(__dev, __reg) \ 
     4556+       rt2x00usb_regbusy_read((__dev), H2M_MAILBOX_CSR, \ 
     4557+                              H2M_MAILBOX_CSR_OWNER, (__reg)) 
    48074558+ 
    48084559+static void rt2800usb_bbp_write(struct rt2x00_dev *rt2x00dev, 
     
    48114562+       u32 reg; 
    48124563+ 
    4813 +       mutex_lock(&rt2x00dev->usb_cache_mutex); 
    4814 + 
    4815 +       /* 
    4816 +        * Wait until the BBP becomes ready. 
    4817 +        */ 
    4818 +       reg = rt2800usb_bbp_check(rt2x00dev); 
    4819 +       if (rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) { 
    4820 +               ERROR(rt2x00dev, "BBP_CSR_CFG register busy. Write failed.\n"); 
    4821 +               mutex_unlock(&rt2x00dev->usb_cache_mutex); 
    4822 +               return; 
    4823 +       } 
    4824 + 
    4825 +       /* 
    4826 +        * Write the data into the BBP. 
    4827 +        */ 
    4828 +       reg = 0; 
    4829 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_VALUE, value); 
    4830 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
    4831 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
    4832 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 0); 
    4833 + 
    4834 +       rt2800usb_register_write_lock(rt2x00dev, BBP_CSR_CFG, reg); 
    4835 +       mutex_unlock(&rt2x00dev->usb_cache_mutex); 
     4564+       mutex_lock(&rt2x00dev->csr_mutex); 
     4565+ 
     4566+       /* 
     4567+        * Wait until the BBP becomes available, afterwards we 
     4568+        * can safely write the new data into the register. 
     4569+        */ 
     4570+       if (WAIT_FOR_BBP(rt2x00dev, &reg)) { 
     4571+               reg = 0; 
     4572+               rt2x00_set_field32(&reg, BBP_CSR_CFG_VALUE, value); 
     4573+               rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
     4574+               rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
     4575+               rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 0); 
     4576+ 
     4577+               rt2x00usb_register_write_lock(rt2x00dev, BBP_CSR_CFG, reg); 
     4578+       } 
     4579+ 
     4580+       mutex_unlock(&rt2x00dev->csr_mutex); 
    48364581+} 
    48374582+ 
     
    48414586+       u32 reg; 
    48424587+ 
    4843 +       mutex_lock(&rt2x00dev->usb_cache_mutex); 
    4844 + 
    4845 +       /* 
    4846 +        * Wait until the BBP becomes ready. 
    4847 +        */ 
    4848 +       reg = rt2800usb_bbp_check(rt2x00dev); 
    4849 +       if (rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) { 
    4850 +               ERROR(rt2x00dev, "BBP_CSR_CFG register busy. Read failed.\n"); 
    4851 +               mutex_unlock(&rt2x00dev->usb_cache_mutex); 
    4852 +               return; 
    4853 +       } 
    4854 + 
    4855 +       /* 
    4856 +        * Write the request into the BBP. 
    4857 +        */ 
    4858 +       reg = 0; 
    4859 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
    4860 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
    4861 +       rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 1); 
    4862 + 
    4863 +       rt2800usb_register_write_lock(rt2x00dev, BBP_CSR_CFG, reg); 
    4864 + 
    4865 +       /* 
    4866 +        * Wait until the BBP becomes ready. 
    4867 +        */ 
    4868 +       reg = rt2800usb_bbp_check(rt2x00dev); 
    4869 +       if (rt2x00_get_field32(reg, BBP_CSR_CFG_BUSY)) { 
    4870 +               ERROR(rt2x00dev, "BBP_CSR_CFG register busy. Read failed.\n"); 
    4871 +               *value = 0xff; 
    4872 +               return; 
     4588+       mutex_lock(&rt2x00dev->csr_mutex); 
     4589+ 
     4590+       /* 
     4591+        * Wait until the BBP becomes available, afterwards we 
     4592+        * can safely write the read request into the register. 
     4593+        * After the data has been written, we wait until hardware 
     4594+        * returns the correct value, if at any time the register 
     4595+        * doesn't become available in time, reg will be 0xffffffff 
     4596+        * which means we return 0xff to the caller. 
     4597+        */ 
     4598+       if (WAIT_FOR_BBP(rt2x00dev, &reg)) { 
     4599+               reg = 0; 
     4600+               rt2x00_set_field32(&reg, BBP_CSR_CFG_REGNUM, word); 
     4601+               rt2x00_set_field32(&reg, BBP_CSR_CFG_BUSY, 1); 
     4602+               rt2x00_set_field32(&reg, BBP_CSR_CFG_READ_CONTROL, 1); 
     4603+ 
     4604+               rt2x00usb_register_write_lock(rt2x00dev, BBP_CSR_CFG, reg); 
     4605+ 
     4606+               WAIT_FOR_BBP(rt2x00dev, &reg); 
    48734607+       } 
    48744608+ 
    48754609+       *value = rt2x00_get_field32(reg, BBP_CSR_CFG_VALUE); 
    4876 +       mutex_unlock(&rt2x00dev->usb_cache_mutex); 
     4610+ 
     4611+       mutex_unlock(&rt2x00dev->csr_mutex); 
    48774612+} 
    48784613+ 
     
    48814616+{ 
    48824617+       u32 reg; 
    4883 +       unsigned int i; 
    48844618+ 
    48854619+       if (!word) 
    48864620+               return; 
    48874621+ 
    4888 +       mutex_lock(&rt2x00dev->usb_cache_mutex); 
    4889 + 
    4890 +       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    4891 +               rt2800usb_register_read_lock(rt2x00dev, RF_CSR_CFG0, &reg); 
    4892 +               if (!rt2x00_get_field32(reg, RF_CSR_CFG0_BUSY)) 
    4893 +                       goto rf_write; 
    4894 +               udelay(REGISTER_BUSY_DELAY); 
    4895 +       } 
    4896 + 
    4897 +       mutex_unlock(&rt2x00dev->usb_cache_mutex); 
    4898 +       ERROR(rt2x00dev, "RF_CSR_CFG0 register busy. Write failed.\n"); 
    4899 +       return; 
    4900 + 
    4901 +rf_write: 
    4902 +       reg = 0; 
    4903 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_REG_VALUE_BW, value); 
    4904 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_STANDBYMODE, 0); 
    4905 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_SEL, 0); 
    4906 +       rt2x00_set_field32(&reg, RF_CSR_CFG0_BUSY, 1); 
    4907 + 
    4908 +       rt2800usb_register_write_lock(rt2x00dev, RF_CSR_CFG0, reg); 
    4909 +       rt2x00_rf_write(rt2x00dev, word, value); 
    4910 +       mutex_unlock(&rt2x00dev->usb_cache_mutex); 
     4622+       mutex_lock(&rt2x00dev->csr_mutex); 
     4623+ 
     4624+       /* 
     4625+        * Wait until the RF becomes available, afterwards we 
     4626+        * can safely write the new data into the register. 
     4627+        */ 
     4628+       if (WAIT_FOR_RF(rt2x00dev, &reg)) { 
     4629+               reg = 0; 
     4630+               rt2x00_set_field32(&reg, RF_CSR_CFG0_REG_VALUE_BW, value); 
     4631+               rt2x00_set_field32(&reg, RF_CSR_CFG0_STANDBYMODE, 0); 
     4632+               rt2x00_set_field32(&reg, RF_CSR_CFG0_SEL, 0); 
     4633+               rt2x00_set_field32(&reg, RF_CSR_CFG0_BUSY, 1); 
     4634+ 
     4635+               rt2x00usb_register_write_lock(rt2x00dev, RF_CSR_CFG0, reg); 
     4636+               rt2x00_rf_write(rt2x00dev, word, value); 
     4637+       } 
     4638+ 
     4639+       mutex_unlock(&rt2x00dev->csr_mutex); 
    49114640+} 
    49124641+ 
     
    49154644+                                 const u8 arg0, const u8 arg1) 
    49164645+{ 
    4917 +       unsigned int i; 
    49184646+       u32 reg; 
    49194647+ 
    4920 +       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    4921 +               rt2800usb_register_read(rt2x00dev, H2M_MAILBOX_CSR, &reg); 
    4922 +               if (!rt2x00_get_field32(reg, H2M_MAILBOX_CSR_OWNER)) 
    4923 +                       goto mcu_write; 
    4924 +               udelay(REGISTER_BUSY_DELAY); 
    4925 +       } 
    4926 + 
    4927 +       ERROR(rt2x00dev, "mcu request error. " 
    4928 +             "Request 0x%02x failed for token 0x%02x.\n", 
    4929 +             command, token); 
    4930 +       return; 
    4931 + 
    4932 +mcu_write: 
    4933 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_OWNER, 1); 
    4934 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_CMD_TOKEN, token); 
    4935 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG0, arg0); 
    4936 +       rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG1, arg1); 
    4937 +       rt2800usb_register_write(rt2x00dev, H2M_MAILBOX_CSR, reg); 
    4938 + 
    4939 +       reg = 0; 
    4940 +       rt2x00_set_field32(&reg, HOST_CMD_CSR_HOST_COMMAND, command); 
    4941 +       rt2800usb_register_write(rt2x00dev, HOST_CMD_CSR, reg); 
     4648+       mutex_lock(&rt2x00dev->csr_mutex); 
     4649+ 
     4650+       /* 
     4651+        * Wait until the MCU becomes available, afterwards we 
     4652+        * can safely write the new data into the register. 
     4653+        */ 
     4654+       if (WAIT_FOR_MCU(rt2x00dev, &reg)) { 
     4655+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_OWNER, 1); 
     4656+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_CMD_TOKEN, token); 
     4657+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG0, arg0); 
     4658+               rt2x00_set_field32(&reg, H2M_MAILBOX_CSR_ARG1, arg1); 
     4659+               rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_CSR, reg); 
     4660+ 
     4661+               reg = 0; 
     4662+               rt2x00_set_field32(&reg, HOST_CMD_CSR_HOST_COMMAND, command); 
     4663+               rt2x00usb_register_write(rt2x00dev, HOST_CMD_CSR, reg); 
     4664+       } 
     4665+ 
     4666+       mutex_unlock(&rt2x00dev->csr_mutex); 
    49424667+} 
    49434668+ 
     
    49464671+       .owner  = THIS_MODULE, 
    49474672+       .csr    = { 
    4948 +               .read           = rt2800usb_register_read, 
    4949 +               .write          = rt2800usb_register_write, 
     4673+               .read           = rt2x00usb_register_read, 
     4674+               .write          = rt2x00usb_register_write, 
    49504675+               .flags          = RT2X00DEBUGFS_OFFSET, 
    49514676+               .word_base      = CSR_REG_BASE, 
     
    50224747+       u32 reg; 
    50234748+ 
    5024 +       rt2800usb_register_read(led->rt2x00dev, LED_CFG, &reg); 
     4749+       rt2x00usb_register_read(led->rt2x00dev, LED_CFG, &reg); 
    50254750+       rt2x00_set_field32(&reg, LED_CFG_ON_PERIOD, *delay_on); 
    50264751+       rt2x00_set_field32(&reg, LED_CFG_OFF_PERIOD, *delay_off); 
     
    50304755+       rt2x00_set_field32(&reg, LED_CFG_Y_LED_MODE, 3); 
    50314756+       rt2x00_set_field32(&reg, LED_CFG_LED_POLAR, 1); 
    5032 +       rt2800usb_register_write(led->rt2x00dev, LED_CFG, reg); 
     4757+       rt2x00usb_register_write(led->rt2x00dev, LED_CFG, reg); 
    50334758+ 
    50344759+       return 0; 
     
    50674792+                          (crypto->cmd == SET_KEY) ? crypto->bssidx : 0); 
    50684793+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_RX_WIUDF, 0); 
    5069 +       rt2800usb_register_write(rt2x00dev, offset, reg); 
     4794+       rt2x00usb_register_write(rt2x00dev, offset, reg); 
    50704795+} 
    50714796+ 
     
    51214846+ 
    51224847+       offset = SHARED_KEY_MODE_ENTRY(key->hw_key_idx / 8); 
    5123 +       rt2800usb_register_read(rt2x00dev, offset, &reg); 
     4848+       rt2x00usb_register_read(rt2x00dev, offset, &reg); 
    51244849+       rt2x00_set_field32(&reg, field, 
    51254850+                          (crypto->cmd == SET_KEY) ? crypto->cipher : 0); 
    5126 +       rt2800usb_register_write(rt2x00dev, offset, reg); 
     4851+       rt2x00usb_register_write(rt2x00dev, offset, reg); 
    51274852+ 
    51284853+       /* 
     
    51954920+        * there is no filter for it at this time. 
    51964921+        */ 
    5197 +       rt2800usb_register_read(rt2x00dev, RX_FILTER_CFG, &reg); 
     4922+       rt2x00usb_register_read(rt2x00dev, RX_FILTER_CFG, &reg); 
    51984923+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CRC_ERROR, 
    51994924+                          !(filter_flags & FIF_FCSFAIL)); 
     
    52024927+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_TO_ME, 
    52034928+                          !(filter_flags & FIF_PROMISC_IN_BSS)); 
    5204 +       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 0); 
     4929+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 
     4930+                          !(filter_flags & FIF_OTHER_BSS)); 
    52054931+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_VER_ERROR, 1); 
    52064932+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_MULTICAST, 
     
    52244950+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CNTL, 
    52254951+                          !(filter_flags & FIF_CONTROL)); 
    5226 +       rt2800usb_register_write(rt2x00dev, RX_FILTER_CFG, reg); 
     4952+       rt2x00usb_register_write(rt2x00dev, RX_FILTER_CFG, reg); 
    52274953+} 
    52284954+ 
     
    52434969+                */ 
    52444970+               beacon_base = HW_BEACON_OFFSET(intf->beacon->entry_idx); 
    5245 +               rt2800usb_register_write(rt2x00dev, beacon_base, 0); 
     4971+               rt2x00usb_register_write(rt2x00dev, beacon_base, 0); 
    52464972+ 
    52474973+               /* 
    52484974+                * Enable synchronisation. 
    52494975+                */ 
    5250 +               rt2800usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     4976+               rt2x00usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
    52514977+               rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1); 
    52524978+               rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_SYNC, conf->sync); 
    52534979+               rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1); 
    5254 +               rt2800usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     4980+               rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
    52554981+       } 
    52564982+ 
     
    52604986+               conf->mac[1] = cpu_to_le32(reg); 
    52614987+ 
    5262 +               rt2800usb_register_multiwrite(rt2x00dev, MAC_ADDR_DW0, 
     4988+               rt2x00usb_register_multiwrite(rt2x00dev, MAC_ADDR_DW0, 
    52634989+                                             conf->mac, sizeof(conf->mac)); 
    52644990+       } 
     
    52704996+               conf->bssid[1] = cpu_to_le32(reg); 
    52714997+ 
    5272 +               rt2800usb_register_multiwrite(rt2x00dev, MAC_BSSID_DW0, 
     4998+               rt2x00usb_register_multiwrite(rt2x00dev, MAC_BSSID_DW0, 
    52734999+                                             conf->bssid, sizeof(conf->bssid)); 
    52745000+       } 
     
    52805006+       u32 reg; 
    52815007+ 
    5282 +       rt2800usb_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
     5008+       rt2x00usb_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
    52835009+       rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_RX_ACK_TIMEOUT, 
    52845010+                          erp->ack_timeout); 
    5285 +       rt2800usb_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
    5286 + 
    5287 +       rt2800usb_register_read(rt2x00dev, AUTO_RSP_CFG, &reg); 
     5011+       rt2x00usb_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
     5012+ 
     5013+       rt2x00usb_register_read(rt2x00dev, AUTO_RSP_CFG, &reg); 
    52885014+       rt2x00_set_field32(&reg, AUTO_RSP_CFG_BAC_ACK_POLICY, 
    52895015+                          !!erp->short_preamble); 
    52905016+       rt2x00_set_field32(&reg, AUTO_RSP_CFG_AR_PREAMBLE, 
    52915017+                          !!erp->short_preamble); 
    5292 +       rt2800usb_register_write(rt2x00dev, AUTO_RSP_CFG, reg); 
    5293 + 
    5294 +       rt2800usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
     5018+       rt2x00usb_register_write(rt2x00dev, AUTO_RSP_CFG, reg); 
     5019+ 
     5020+       rt2x00usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
    52955021+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_CTRL, 
    52965022+                          erp->cts_protection ? 2 : 0); 
    5297 +       rt2800usb_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
    5298 + 
    5299 +       rt2800usb_register_write(rt2x00dev, LEGACY_BASIC_RATE, 
     5023+       rt2x00usb_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
     5024+ 
     5025+       rt2x00usb_register_write(rt2x00dev, LEGACY_BASIC_RATE, 
    53005026+                                erp->basic_rates); 
    5301 +       rt2800usb_register_write(rt2x00dev, HT_BASIC_RATE, 
     5027+       rt2x00usb_register_write(rt2x00dev, HT_BASIC_RATE, 
    53025028+                                erp->basic_rates >> 32); 
    53035029+ 
    5304 +       rt2800usb_register_read(rt2x00dev, BKOFF_SLOT_CFG, &reg); 
     5030+       rt2x00usb_register_read(rt2x00dev, BKOFF_SLOT_CFG, &reg); 
    53055031+       rt2x00_set_field32(&reg, BKOFF_SLOT_CFG_SLOT_TIME, erp->slot_time); 
    53065032+       rt2x00_set_field32(&reg, BKOFF_SLOT_CFG_CC_DELAY_TIME, 2); 
    5307 +       rt2800usb_register_write(rt2x00dev, BKOFF_SLOT_CFG, reg); 
    5308 + 
    5309 +       rt2800usb_register_read(rt2x00dev, XIFS_TIME_CFG, &reg); 
     5033+       rt2x00usb_register_write(rt2x00dev, BKOFF_SLOT_CFG, reg); 
     5034+ 
     5035+       rt2x00usb_register_read(rt2x00dev, XIFS_TIME_CFG, &reg); 
    53105036+       rt2x00_set_field32(&reg, XIFS_TIME_CFG_CCKM_SIFS_TIME, erp->sifs); 
    53115037+       rt2x00_set_field32(&reg, XIFS_TIME_CFG_OFDM_SIFS_TIME, erp->sifs); 
     
    53135039+       rt2x00_set_field32(&reg, XIFS_TIME_CFG_EIFS, erp->eifs); 
    53145040+       rt2x00_set_field32(&reg, XIFS_TIME_CFG_BB_RXEND_ENABLE, 1); 
    5315 +       rt2800usb_register_write(rt2x00dev, XIFS_TIME_CFG, reg); 
     5041+       rt2x00usb_register_write(rt2x00dev, XIFS_TIME_CFG, reg); 
    53165042+} 
    53175043+ 
     
    55025228+               } 
    55035229+ 
    5504 +               rt2800usb_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
     5230+               rt2x00usb_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
    55055231+               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_A, 0); 
    55065232+               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_BG, 1); 
    5507 +               rt2800usb_register_write(rt2x00dev, TX_BAND_CFG, reg); 
     5233+               rt2x00usb_register_write(rt2x00dev, TX_BAND_CFG, reg); 
    55085234+       } else { 
    55095235+               rt2800usb_bbp_write(rt2x00dev, 82, 0xf2); 
     
    55145240+                       rt2800usb_bbp_write(rt2x00dev, 75, 0x50); 
    55155241+ 
    5516 +               rt2800usb_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
     5242+               rt2x00usb_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
    55175243+               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_A, 1); 
    55185244+               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_BG, 0); 
    5519 +               rt2800usb_register_write(rt2x00dev, TX_BAND_CFG, reg); 
    5520 +       } 
    5521 + 
    5522 +       rt2800usb_register_write(rt2x00dev, TX_PIN_CFG, tx_pin); 
     5245+               rt2x00usb_register_write(rt2x00dev, TX_BAND_CFG, reg); 
     5246+       } 
     5247+ 
     5248+       rt2x00usb_register_write(rt2x00dev, TX_PIN_CFG, tx_pin); 
    55235249+ 
    55245250+       msleep(1); 
     
    55365262+       rt2800usb_bbp_write(rt2x00dev, 1, r1); 
    55375263+ 
    5538 +       rt2800usb_register_read(rt2x00dev, TX_PWR_CFG_0, &reg); 
     5264+       rt2x00usb_register_read(rt2x00dev, TX_PWR_CFG_0, &reg); 
    55395265+       rt2x00_set_field32(&reg, TX_PWR_CFG_0_1MBS, value); 
    55405266+       rt2x00_set_field32(&reg, TX_PWR_CFG_0_2MBS, value); 
     
    55455271+       rt2x00_set_field32(&reg, TX_PWR_CFG_0_12MBS, value); 
    55465272+       rt2x00_set_field32(&reg, TX_PWR_CFG_0_18MBS, value); 
    5547 +       rt2800usb_register_write(rt2x00dev, TX_PWR_CFG_0, reg); 
    5548 + 
    5549 +       rt2800usb_register_read(rt2x00dev, TX_PWR_CFG_1, &reg); 
     5273+       rt2x00usb_register_write(rt2x00dev, TX_PWR_CFG_0, reg); 
     5274+ 
     5275+       rt2x00usb_register_read(rt2x00dev, TX_PWR_CFG_1, &reg); 
    55505276+       rt2x00_set_field32(&reg, TX_PWR_CFG_1_24MBS, value); 
    55515277+       rt2x00_set_field32(&reg, TX_PWR_CFG_1_36MBS, value); 
     
    55565282+       rt2x00_set_field32(&reg, TX_PWR_CFG_1_MCS2, value); 
    55575283+       rt2x00_set_field32(&reg, TX_PWR_CFG_1_MCS3, value); 
    5558 +       rt2800usb_register_write(rt2x00dev, TX_PWR_CFG_1, reg); 
    5559 + 
    5560 +       rt2800usb_register_read(rt2x00dev, TX_PWR_CFG_2, &reg); 
     5284+       rt2x00usb_register_write(rt2x00dev, TX_PWR_CFG_1, reg); 
     5285+ 
     5286+       rt2x00usb_register_read(rt2x00dev, TX_PWR_CFG_2, &reg); 
    55615287+       rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS4, value); 
    55625288+       rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS5, value); 
     
    55675293+       rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS10, value); 
    55685294+       rt2x00_set_field32(&reg, TX_PWR_CFG_2_MCS11, value); 
    5569 +       rt2800usb_register_write(rt2x00dev, TX_PWR_CFG_2, reg); 
    5570 + 
    5571 +       rt2800usb_register_read(rt2x00dev, TX_PWR_CFG_3, &reg); 
     5295+       rt2x00usb_register_write(rt2x00dev, TX_PWR_CFG_2, reg); 
     5296+ 
     5297+       rt2x00usb_register_read(rt2x00dev, TX_PWR_CFG_3, &reg); 
    55725298+       rt2x00_set_field32(&reg, TX_PWR_CFG_3_MCS12, value); 
    55735299+       rt2x00_set_field32(&reg, TX_PWR_CFG_3_MCS13, value); 
     
    55785304+       rt2x00_set_field32(&reg, TX_PWR_CFG_3_UKNOWN3, value); 
    55795305+       rt2x00_set_field32(&reg, TX_PWR_CFG_3_UKNOWN4, value); 
    5580 +       rt2800usb_register_write(rt2x00dev, TX_PWR_CFG_3, reg); 
    5581 + 
    5582 +       rt2800usb_register_read(rt2x00dev, TX_PWR_CFG_4, &reg); 
     5306+       rt2x00usb_register_write(rt2x00dev, TX_PWR_CFG_3, reg); 
     5307+ 
     5308+       rt2x00usb_register_read(rt2x00dev, TX_PWR_CFG_4, &reg); 
    55835309+       rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN5, value); 
    55845310+       rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN6, value); 
    55855311+       rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN7, value); 
    55865312+       rt2x00_set_field32(&reg, TX_PWR_CFG_4_UKNOWN8, value); 
    5587 +       rt2800usb_register_write(rt2x00dev, TX_PWR_CFG_4, reg); 
     5313+       rt2x00usb_register_write(rt2x00dev, TX_PWR_CFG_4, reg); 
    55885314+} 
    55895315+ 
     
    55935319+       u32 reg; 
    55945320+ 
    5595 +       rt2800usb_register_read(rt2x00dev, TX_RTY_CFG, &reg); 
     5321+       rt2x00usb_register_read(rt2x00dev, TX_RTY_CFG, &reg); 
    55965322+       rt2x00_set_field32(&reg, TX_RTY_CFG_SHORT_RTY_LIMIT, 
    55975323+                          libconf->conf->short_frame_max_tx_count); 
     
    56025328+       rt2x00_set_field32(&reg, TX_RTY_CFG_AGG_RTY_MODE, 0); 
    56035329+       rt2x00_set_field32(&reg, TX_RTY_CFG_TX_AUTO_FB_ENABLE, 1); 
    5604 +       rt2800usb_register_write(rt2x00dev, TX_RTY_CFG, reg); 
     5330+       rt2x00usb_register_write(rt2x00dev, TX_RTY_CFG, reg); 
    56055331+} 
    56065332+ 
     
    56105336+       u32 reg; 
    56115337+ 
    5612 +       rt2800usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     5338+       rt2x00usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
    56135339+       rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL, 
    56145340+                          libconf->conf->beacon_int * 16); 
    5615 +       rt2800usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     5341+       rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
    56165342+} 
    56175343+ 
     
    56455371+        * Update FCS error count from register. 
    56465372+        */ 
    5647 +       rt2800usb_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
     5373+       rt2x00usb_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
    56485374+       qual->rx_failed = rt2x00_get_field32(reg, RX_STA_CNT0_CRC_ERR); 
    56495375+ 
     
    56515377+        * Update False CCA count from register. 
    56525378+        */ 
    5653 +       rt2800usb_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
     5379+       rt2x00usb_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
    56545380+       qual->false_cca = rt2x00_get_field32(reg, RX_STA_CNT1_FALSE_CCA); 
    56555381+} 
     
    57435469+        */ 
    57445470+       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    5745 +               rt2800usb_register_read(rt2x00dev, MAC_CSR0, &reg); 
     5471+               rt2x00usb_register_read(rt2x00dev, MAC_CSR0, &reg); 
    57465472+               if (reg && reg != ~0) 
    57475473+                       break; 
     
    57635489+                                           REGISTER_TIMEOUT32(len)); 
    57645490+ 
    5765 +       rt2800usb_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); 
    5766 +       rt2800usb_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0); 
     5491+       rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); 
     5492+       rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0); 
    57675493+ 
    57685494+       /* 
     
    57825508+        */ 
    57835509+       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    5784 +               rt2800usb_register_read(rt2x00dev, PBF_SYS_CTRL, &reg); 
     5510+               rt2x00usb_register_read(rt2x00dev, PBF_SYS_CTRL, &reg); 
    57855511+               if (rt2x00_get_field32(reg, PBF_SYS_CTRL_READY)) 
    57865512+                       break; 
     
    57965522+        * Initialize firmware. 
    57975523+        */ 
    5798 +       rt2800usb_register_write(rt2x00dev, H2M_BBP_AGENT, 0); 
    5799 +       rt2800usb_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); 
     5524+       rt2x00usb_register_write(rt2x00dev, H2M_BBP_AGENT, 0); 
     5525+       rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); 
    58005526+       msleep(1); 
    58015527+ 
     
    58155541+        */ 
    58165542+       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    5817 +               rt2800usb_register_read(rt2x00dev, MAC_CSR0, &reg); 
     5543+               rt2x00usb_register_read(rt2x00dev, MAC_CSR0, &reg); 
    58185544+               if (reg && reg != ~0) 
    58195545+                       break; 
     
    58265552+       } 
    58275553+ 
    5828 +       rt2800usb_register_read(rt2x00dev, PBF_SYS_CTRL, &reg); 
    5829 +       rt2800usb_register_write(rt2x00dev, PBF_SYS_CTRL, reg & ~0x00002000); 
    5830 + 
    5831 +       rt2800usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     5554+       rt2x00usb_register_read(rt2x00dev, PBF_SYS_CTRL, &reg); 
     5555+       rt2x00usb_register_write(rt2x00dev, PBF_SYS_CTRL, reg & ~0x00002000); 
     5556+ 
     5557+       rt2x00usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
    58325558+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_CSR, 1); 
    58335559+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_RESET_BBP, 1); 
    5834 +       rt2800usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
    5835 + 
    5836 +       rt2800usb_register_write(rt2x00dev, USB_DMA_CFG, 0x00000000); 
     5560+       rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     5561+ 
     5562+       rt2x00usb_register_write(rt2x00dev, USB_DMA_CFG, 0x00000000); 
    58375563+ 
    58385564+       rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, 0, 
    58395565+                                   USB_MODE_RESET, REGISTER_TIMEOUT); 
    58405566+ 
    5841 +       rt2800usb_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); 
    5842 + 
    5843 +       rt2800usb_register_read(rt2x00dev, BCN_OFFSET0, &reg); 
     5567+       rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); 
     5568+ 
     5569+       rt2x00usb_register_read(rt2x00dev, BCN_OFFSET0, &reg); 
    58445570+       rt2x00_set_field32(&reg, BCN_OFFSET0_BCN0, 0xe0); /* 0x3800 */ 
    58455571+       rt2x00_set_field32(&reg, BCN_OFFSET0_BCN1, 0xe8); /* 0x3a00 */ 
    58465572+       rt2x00_set_field32(&reg, BCN_OFFSET0_BCN2, 0xf0); /* 0x3c00 */ 
    58475573+       rt2x00_set_field32(&reg, BCN_OFFSET0_BCN3, 0xf8); /* 0x3e00 */ 
    5848 +       rt2800usb_register_write(rt2x00dev, BCN_OFFSET0, reg); 
    5849 + 
    5850 +       rt2800usb_register_read(rt2x00dev, BCN_OFFSET1, &reg); 
     5574+       rt2x00usb_register_write(rt2x00dev, BCN_OFFSET0, reg); 
     5575+ 
     5576+       rt2x00usb_register_read(rt2x00dev, BCN_OFFSET1, &reg); 
    58515577+       rt2x00_set_field32(&reg, BCN_OFFSET1_BCN4, 0xc8); /* 0x3200 */ 
    58525578+       rt2x00_set_field32(&reg, BCN_OFFSET1_BCN5, 0xd0); /* 0x3400 */ 
    58535579+       rt2x00_set_field32(&reg, BCN_OFFSET1_BCN6, 0x77); /* 0x1dc0 */ 
    58545580+       rt2x00_set_field32(&reg, BCN_OFFSET1_BCN7, 0x6f); /* 0x1bc0 */ 
    5855 +       rt2800usb_register_write(rt2x00dev, BCN_OFFSET1, reg); 
    5856 + 
    5857 +       rt2800usb_register_write(rt2x00dev, LEGACY_BASIC_RATE, 0x0000013f); 
    5858 +       rt2800usb_register_write(rt2x00dev, HT_BASIC_RATE, 0x00008003); 
    5859 + 
    5860 +       rt2800usb_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); 
    5861 + 
    5862 +       rt2800usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     5581+       rt2x00usb_register_write(rt2x00dev, BCN_OFFSET1, reg); 
     5582+ 
     5583+       rt2x00usb_register_write(rt2x00dev, LEGACY_BASIC_RATE, 0x0000013f); 
     5584+       rt2x00usb_register_write(rt2x00dev, HT_BASIC_RATE, 0x00008003); 
     5585+ 
     5586+       rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); 
     5587+ 
     5588+       rt2x00usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
    58635589+       rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_INTERVAL, 0); 
    58645590+       rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0); 
     
    58675593+       rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0); 
    58685594+       rt2x00_set_field32(&reg, BCN_TIME_CFG_TX_TIME_COMPENSATE, 0); 
    5869 +       rt2800usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
    5870 + 
    5871 +       rt2800usb_register_write(rt2x00dev, TX_SW_CFG0, 0x00040a06); 
    5872 +       rt2800usb_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606); 
    5873 + 
    5874 +       rt2800usb_register_read(rt2x00dev, TX_LINK_CFG, &reg); 
     5595+       rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     5596+ 
     5597+       rt2x00usb_register_write(rt2x00dev, TX_SW_CFG0, 0x00040a06); 
     5598+       rt2x00usb_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606); 
     5599+ 
     5600+       rt2x00usb_register_read(rt2x00dev, TX_LINK_CFG, &reg); 
    58755601+       rt2x00_set_field32(&reg, TX_LINK_CFG_REMOTE_MFB_LIFETIME, 32); 
    58765602+       rt2x00_set_field32(&reg, TX_LINK_CFG_MFB_ENABLE, 0); 
     
    58815607+       rt2x00_set_field32(&reg, TX_LINK_CFG_REMOTE_MFB, 0); 
    58825608+       rt2x00_set_field32(&reg, TX_LINK_CFG_REMOTE_MFS, 0); 
    5883 +       rt2800usb_register_write(rt2x00dev, TX_LINK_CFG, reg); 
    5884 + 
    5885 +       rt2800usb_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
     5609+       rt2x00usb_register_write(rt2x00dev, TX_LINK_CFG, reg); 
     5610+ 
     5611+       rt2x00usb_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
    58865612+       rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_MPDU_LIFETIME, 9); 
    58875613+       rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_TX_OP_TIMEOUT, 10); 
    5888 +       rt2800usb_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
    5889 + 
    5890 +       rt2800usb_register_read(rt2x00dev, MAX_LEN_CFG, &reg); 
     5614+       rt2x00usb_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
     5615+ 
     5616+       rt2x00usb_register_read(rt2x00dev, MAX_LEN_CFG, &reg); 
    58915617+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_MPDU, AGGREGATION_SIZE); 
    58925618+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 1); 
    58935619+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_PSDU, 0); 
    58945620+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_MPDU, 0); 
    5895 +       rt2800usb_register_write(rt2x00dev, MAX_LEN_CFG, reg); 
    5896 + 
    5897 +       rt2800usb_register_write(rt2x00dev, PBF_MAX_PCNT, 0x1f3fbf9f); 
    5898 + 
    5899 +       rt2800usb_register_read(rt2x00dev, AUTO_RSP_CFG, &reg); 
     5621+       rt2x00usb_register_write(rt2x00dev, MAX_LEN_CFG, reg); 
     5622+ 
     5623+       rt2x00usb_register_write(rt2x00dev, PBF_MAX_PCNT, 0x1f3fbf9f); 
     5624+ 
     5625+       rt2x00usb_register_read(rt2x00dev, AUTO_RSP_CFG, &reg); 
    59005626+       rt2x00_set_field32(&reg, AUTO_RSP_CFG_AUTORESPONDER, 1); 
    59015627+       rt2x00_set_field32(&reg, AUTO_RSP_CFG_CTS_40_MMODE, 0); 
     
    59035629+       rt2x00_set_field32(&reg, AUTO_RSP_CFG_DUAL_CTS_EN, 0); 
    59045630+       rt2x00_set_field32(&reg, AUTO_RSP_CFG_ACK_CTS_PSM_BIT, 0); 
    5905 +       rt2800usb_register_write(rt2x00dev, AUTO_RSP_CFG, reg); 
    5906 + 
    5907 +       rt2800usb_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
     5631+       rt2x00usb_register_write(rt2x00dev, AUTO_RSP_CFG, reg); 
     5632+ 
     5633+       rt2x00usb_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
    59085634+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_RATE, 3); 
    59095635+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_CTRL, 0); 
     
    59155641+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    59165642+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
    5917 +       rt2800usb_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
    5918 + 
    5919 +       rt2800usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
     5643+       rt2x00usb_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
     5644+ 
     5645+       rt2x00usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
    59205646+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_RATE, 3); 
    59215647+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_CTRL, 0); 
     
    59275653+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    59285654+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
    5929 +       rt2800usb_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
    5930 + 
    5931 +       rt2800usb_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
     5655+       rt2x00usb_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
     5656+ 
     5657+       rt2x00usb_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
    59325658+       rt2x00_set_field32(&reg, MM20_PROT_CFG_PROTECT_RATE, 0x4004); 
    59335659+       rt2x00_set_field32(&reg, MM20_PROT_CFG_PROTECT_CTRL, 0); 
     
    59395665+       rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    59405666+       rt2x00_set_field32(&reg, MM20_PROT_CFG_TX_OP_ALLOW_GF40, 0); 
    5941 +       rt2800usb_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
    5942 + 
    5943 +       rt2800usb_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
     5667+       rt2x00usb_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
     5668+ 
     5669+       rt2x00usb_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
    59445670+       rt2x00_set_field32(&reg, MM40_PROT_CFG_PROTECT_RATE, 0x4084); 
    59455671+       rt2x00_set_field32(&reg, MM40_PROT_CFG_PROTECT_CTRL, 0); 
     
    59515677+       rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    59525678+       rt2x00_set_field32(&reg, MM40_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
    5953 +       rt2800usb_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
    5954 + 
    5955 +       rt2800usb_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
     5679+       rt2x00usb_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
     5680+ 
     5681+       rt2x00usb_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
    59565682+       rt2x00_set_field32(&reg, GF20_PROT_CFG_PROTECT_RATE, 0x4004); 
    59575683+       rt2x00_set_field32(&reg, GF20_PROT_CFG_PROTECT_CTRL, 0); 
     
    59635689+       rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    59645690+       rt2x00_set_field32(&reg, GF20_PROT_CFG_TX_OP_ALLOW_GF40, 0); 
    5965 +       rt2800usb_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
    5966 + 
    5967 +       rt2800usb_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
     5691+       rt2x00usb_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
     5692+ 
     5693+       rt2x00usb_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
    59685694+       rt2x00_set_field32(&reg, GF40_PROT_CFG_PROTECT_RATE, 0x4084); 
    59695695+       rt2x00_set_field32(&reg, GF40_PROT_CFG_PROTECT_CTRL, 0); 
     
    59755701+       rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    59765702+       rt2x00_set_field32(&reg, GF40_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
    5977 +       rt2800usb_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
    5978 + 
    5979 +       rt2800usb_register_write(rt2x00dev, PBF_CFG, 0xf40006); 
    5980 + 
    5981 +       rt2800usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     5703+       rt2x00usb_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
     5704+ 
     5705+       rt2x00usb_register_write(rt2x00dev, PBF_CFG, 0xf40006); 
     5706+ 
     5707+       rt2x00usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
    59825708+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0); 
    59835709+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_DMA_BUSY, 0); 
     
    59895715+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_RX_HDR_SCATTER, 0); 
    59905716+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_HDR_SEG_LEN, 0); 
    5991 +       rt2800usb_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
    5992 + 
    5993 +       rt2800usb_register_write(rt2x00dev, TXOP_CTRL_CFG, 0x0000583f); 
    5994 +       rt2800usb_register_write(rt2x00dev, TXOP_HLDR_ET, 0x00000002); 
    5995 + 
    5996 +       rt2800usb_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
     5717+       rt2x00usb_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
     5718+ 
     5719+       rt2x00usb_register_write(rt2x00dev, TXOP_CTRL_CFG, 0x0000583f); 
     5720+       rt2x00usb_register_write(rt2x00dev, TXOP_HLDR_ET, 0x00000002); 
     5721+ 
     5722+       rt2x00usb_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
    59975723+       rt2x00_set_field32(&reg, TX_RTS_CFG_AUTO_RTS_RETRY_LIMIT, 32); 
    59985724+       rt2x00_set_field32(&reg, TX_RTS_CFG_RTS_FBK_EN, 0); 
    5999 +       rt2800usb_register_write(rt2x00dev, TX_RTS_CFG, reg); 
    6000 + 
    6001 +       rt2800usb_register_write(rt2x00dev, EXP_ACK_TIME, 0x002400ca); 
    6002 +       rt2800usb_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000003); 
     5725+       rt2x00usb_register_write(rt2x00dev, TX_RTS_CFG, reg); 
     5726+ 
     5727+       rt2x00usb_register_write(rt2x00dev, EXP_ACK_TIME, 0x002400ca); 
     5728+       rt2x00usb_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000003); 
    60035729+ 
    60045730+       /* 
     
    60075733+       for (i = 0; i < 254; i++) { 
    60085734+               u32 wcid[2] = { 0xffffffff, 0x0000ffff }; 
    6009 +               rt2800usb_register_multiwrite(rt2x00dev, MAC_WCID_ENTRY(i), 
     5735+               rt2x00usb_register_multiwrite(rt2x00dev, MAC_WCID_ENTRY(i), 
    60105736+                                             wcid, sizeof(wcid)); 
    60115737+       } 
    60125738+ 
    60135739+       for (i = 0; i < 4; i++) 
    6014 +               rt2800usb_register_write(rt2x00dev, 
     5740+               rt2x00usb_register_write(rt2x00dev, 
    60155741+                                        SHARED_KEY_MODE_ENTRY(i), 0); 
    60165742+ 
    60175743+       for (i = 0; i < 256; i++) 
    6018 +               rt2800usb_register_write(rt2x00dev, MAC_WCID_ATTR_ENTRY(i), 1); 
     5744+               rt2x00usb_register_write(rt2x00dev, MAC_WCID_ATTR_ENTRY(i), 1); 
    60195745+ 
    60205746+       /* 
     
    60245750+        * bits which (when set to 0) will invalidate the entire beacon. 
    60255751+        */ 
    6026 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE0, 0); 
    6027 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE1, 0); 
    6028 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE2, 0); 
    6029 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE3, 0); 
    6030 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE4, 0); 
    6031 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE5, 0); 
    6032 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE6, 0); 
    6033 +       rt2800usb_register_write(rt2x00dev, HW_BEACON_BASE7, 0); 
    6034 + 
    6035 +       rt2800usb_register_read(rt2x00dev, USB_CYC_CFG, &reg); 
     5752+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE0, 0); 
     5753+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE1, 0); 
     5754+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE2, 0); 
     5755+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE3, 0); 
     5756+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE4, 0); 
     5757+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE5, 0); 
     5758+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE6, 0); 
     5759+       rt2x00usb_register_write(rt2x00dev, HW_BEACON_BASE7, 0); 
     5760+ 
     5761+       rt2x00usb_register_read(rt2x00dev, USB_CYC_CFG, &reg); 
    60365762+       rt2x00_set_field32(&reg, USB_CYC_CFG_CLOCK_CYCLE, 30); 
    6037 +       rt2800usb_register_write(rt2x00dev, USB_CYC_CFG, reg); 
    6038 + 
    6039 +       rt2800usb_register_read(rt2x00dev, HT_FBK_CFG0, &reg); 
     5763+       rt2x00usb_register_write(rt2x00dev, USB_CYC_CFG, reg); 
     5764+ 
     5765+       rt2x00usb_register_read(rt2x00dev, HT_FBK_CFG0, &reg); 
    60405766+       rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS0FBK, 0); 
    60415767+       rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS1FBK, 0); 
     
    60465772+       rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS6FBK, 5); 
    60475773+       rt2x00_set_field32(&reg, HT_FBK_CFG0_HTMCS7FBK, 6); 
    6048 +       rt2800usb_register_write(rt2x00dev, HT_FBK_CFG0, reg); 
    6049 + 
    6050 +       rt2800usb_register_read(rt2x00dev, HT_FBK_CFG1, &reg); 
     5774+       rt2x00usb_register_write(rt2x00dev, HT_FBK_CFG0, reg); 
     5775+ 
     5776+       rt2x00usb_register_read(rt2x00dev, HT_FBK_CFG1, &reg); 
    60515777+       rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS8FBK, 8); 
    60525778+       rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS9FBK, 8); 
     
    60575783+       rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS14FBK, 13); 
    60585784+       rt2x00_set_field32(&reg, HT_FBK_CFG1_HTMCS15FBK, 14); 
    6059 +       rt2800usb_register_write(rt2x00dev, HT_FBK_CFG1, reg); 
    6060 + 
    6061 +       rt2800usb_register_read(rt2x00dev, LG_FBK_CFG0, &reg); 
     5785+       rt2x00usb_register_write(rt2x00dev, HT_FBK_CFG1, reg); 
     5786+ 
     5787+       rt2x00usb_register_read(rt2x00dev, LG_FBK_CFG0, &reg); 
    60625788+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS0FBK, 8); 
    60635789+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS1FBK, 8); 
     
    60685794+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS6FBK, 14); 
    60695795+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS7FBK, 15); 
    6070 +       rt2800usb_register_write(rt2x00dev, LG_FBK_CFG0, reg); 
    6071 + 
    6072 +       rt2800usb_register_read(rt2x00dev, LG_FBK_CFG1, &reg); 
     5796+       rt2x00usb_register_write(rt2x00dev, LG_FBK_CFG0, reg); 
     5797+ 
     5798+       rt2x00usb_register_read(rt2x00dev, LG_FBK_CFG1, &reg); 
    60735799+       rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS0FBK, 0); 
    60745800+       rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS1FBK, 0); 
    60755801+       rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS2FBK, 1); 
    60765802+       rt2x00_set_field32(&reg, LG_FBK_CFG0_CCKMCS3FBK, 2); 
    6077 +       rt2800usb_register_write(rt2x00dev, LG_FBK_CFG1, reg); 
     5803+       rt2x00usb_register_write(rt2x00dev, LG_FBK_CFG1, reg); 
    60785804+ 
    60795805+       /* 
     
    60825808+        * so we may pass a useless variable to store the value. 
    60835809+        */ 
    6084 +       rt2800usb_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
    6085 +       rt2800usb_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
    6086 +       rt2800usb_register_read(rt2x00dev, RX_STA_CNT2, &reg); 
    6087 +       rt2800usb_register_read(rt2x00dev, TX_STA_CNT0, &reg); 
    6088 +       rt2800usb_register_read(rt2x00dev, TX_STA_CNT1, &reg); 
    6089 +       rt2800usb_register_read(rt2x00dev, TX_STA_CNT2, &reg); 
     5810+       rt2x00usb_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
     5811+       rt2x00usb_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
     5812+       rt2x00usb_register_read(rt2x00dev, RX_STA_CNT2, &reg); 
     5813+       rt2x00usb_register_read(rt2x00dev, TX_STA_CNT0, &reg); 
     5814+       rt2x00usb_register_read(rt2x00dev, TX_STA_CNT1, &reg); 
     5815+       rt2x00usb_register_read(rt2x00dev, TX_STA_CNT2, &reg); 
    60905816+ 
    60915817+       return 0; 
     
    60985824+ 
    60995825+       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    6100 +               rt2800usb_register_read(rt2x00dev, MAC_STATUS_CFG, &reg); 
     5826+               rt2x00usb_register_read(rt2x00dev, MAC_STATUS_CFG, &reg); 
    61015827+               if (!rt2x00_get_field32(reg, MAC_STATUS_CFG_BBP_RF_BUSY)) 
    61025828+                       return 0; 
     
    61795905+       u32 reg; 
    61805906+ 
    6181 +       rt2800usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     5907+       rt2x00usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
    61825908+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 
    61835909+                          (state == STATE_RADIO_RX_ON) || 
    61845910+                          (state == STATE_RADIO_RX_ON_LINK)); 
    6185 +       rt2800usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     5911+       rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
    61865912+} 
    61875913+ 
     
    61925918+ 
    61935919+       for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 
    6194 +               rt2800usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     5920+               rt2x00usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
    61955921+               if (!rt2x00_get_field32(reg, WPDMA_GLO_CFG_TX_DMA_BUSY) && 
    61965922+                   !rt2x00_get_field32(reg, WPDMA_GLO_CFG_RX_DMA_BUSY)) 
     
    62175943+               return -EIO; 
    62185944+ 
    6219 +       rt2800usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     5945+       rt2x00usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
    62205946+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_TX, 1); 
    6221 +       rt2800usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     5947+       rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
    62225948+ 
    62235949+       udelay(50); 
    62245950+ 
    6225 +       rt2800usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     5951+       rt2x00usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
    62265952+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1); 
    62275953+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 1); 
    62285954+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 1); 
    6229 +       rt2800usb_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
    6230 + 
    6231 + 
    6232 +       rt2800usb_register_read(rt2x00dev, USB_DMA_CFG, &reg); 
     5955+       rt2x00usb_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
     5956+ 
     5957+ 
     5958+       rt2x00usb_register_read(rt2x00dev, USB_DMA_CFG, &reg); 
    62335959+       rt2x00_set_field32(&reg, USB_DMA_CFG_PHY_CLEAR, 0); 
    62345960+       /* Don't use bulk in aggregation when working with USB 1.1 */ 
    62355961+       rt2x00_set_field32(&reg, USB_DMA_CFG_RX_BULK_AGG_EN, 
    6236 +                          (rt2x00dev->usb_maxpacket == 512)); 
     5962+                          (rt2x00dev->rx->usb_maxpacket == 512)); 
    62375963+       rt2x00_set_field32(&reg, USB_DMA_CFG_RX_BULK_AGG_TIMEOUT, 128); 
    62385964+       /* FIXME: Calculate this value based on Aggregation defines */ 
     
    62405966+       rt2x00_set_field32(&reg, USB_DMA_CFG_RX_BULK_EN, 1); 
    62415967+       rt2x00_set_field32(&reg, USB_DMA_CFG_TX_BULK_EN, 1); 
    6242 +       rt2800usb_register_write(rt2x00dev, USB_DMA_CFG, reg); 
    6243 + 
    6244 +       rt2800usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     5968+       rt2x00usb_register_write(rt2x00dev, USB_DMA_CFG, reg); 
     5969+ 
     5970+       rt2x00usb_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
    62455971+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_TX, 1); 
    62465972+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 1); 
    6247 +       rt2800usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     5973+       rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
    62485974+ 
    62495975+       /* 
     
    62746000+       u32 reg; 
    62756001+ 
    6276 +       rt2800usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
     6002+       rt2x00usb_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
    62776003+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0); 
    62786004+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0); 
    6279 +       rt2800usb_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
    6280 + 
    6281 +       rt2800usb_register_write(rt2x00dev, MAC_SYS_CTRL, 0); 
    6282 +       rt2800usb_register_write(rt2x00dev, PWR_PIN_CFG, 0); 
    6283 +       rt2800usb_register_write(rt2x00dev, TX_PIN_CFG, 0); 
     6005+       rt2x00usb_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 
     6006+ 
     6007+       rt2x00usb_register_write(rt2x00dev, MAC_SYS_CTRL, 0); 
     6008+       rt2x00usb_register_write(rt2x00dev, PWR_PIN_CFG, 0); 
     6009+       rt2x00usb_register_write(rt2x00dev, TX_PIN_CFG, 0); 
    62846010+ 
    62856011+       /* Wait for DMA, ignore error */ 
     
    62926018+                              enum dev_state state) 
    62936019+{ 
    6294 +       rt2800usb_register_write(rt2x00dev, AUTOWAKEUP_CFG, 0); 
     6020+       rt2x00usb_register_write(rt2x00dev, AUTOWAKEUP_CFG, 0); 
    62956021+ 
    62966022+       if (state == STATE_AWAKE) 
     
    64586184+        * otherwise we might be sending out invalid data. 
    64596185+        */ 
    6460 +       rt2800usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     6186+       rt2x00usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
    64616187+       rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0); 
    64626188+       rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0); 
    64636189+       rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0); 
    6464 +       rt2800usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     6190+       rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
    64656191+ 
    64666192+       /* 
     
    64806206+} 
    64816207+ 
    6482 +static int rt2800usb_get_tx_data_len(struct rt2x00_dev *rt2x00dev, 
    6483 +                                    struct sk_buff *skb) 
     6208+static int rt2800usb_get_tx_data_len(struct queue_entry *entry) 
    64846209+{ 
    64856210+       int length; 
     
    64896214+        * but it must _not_ be a multiple of the USB packet size. 
    64906215+        */ 
    6491 +       length = roundup(skb->len, 4); 
    6492 +       length += (4 * !(length % rt2x00dev->usb_maxpacket)); 
     6216+       length = roundup(entry->skb->len, 4); 
     6217+       length += (4 * !(length % entry->queue->usb_maxpacket)); 
    64936218+ 
    64946219+       return length; 
     
    65056230+       } 
    65066231+ 
    6507 +       rt2800usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
     6232+       rt2x00usb_register_read(rt2x00dev, BCN_TIME_CFG, &reg); 
    65086233+       if (!rt2x00_get_field32(reg, BCN_TIME_CFG_BEACON_GEN)) { 
    65096234+               rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1); 
    65106235+               rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1); 
    65116236+               rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 1); 
    6512 +               rt2800usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
     6237+               rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
    65136238+       } 
    65146239+} 
     
    67206445+        */ 
    67216446+       value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RF_TYPE); 
    6722 +       rt2800usb_register_read(rt2x00dev, MAC_CSR0, &reg); 
     6447+       rt2x00usb_register_read(rt2x00dev, MAC_CSR0, &reg); 
    67236448+       rev = rt2x00_get_field32(reg, MAC_CSR0_ASIC_REV); 
    67246449+       rt2x00_set_chip(rt2x00dev, RT2870, value, rev); 
     
    69586683+       u32 reg; 
    69596684+ 
    6960 +       rt2800usb_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
     6685+       rt2x00usb_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
    69616686+       rt2x00_set_field32(&reg, TX_RTS_CFG_RTS_THRES, value); 
    6962 +       rt2800usb_register_write(rt2x00dev, TX_RTS_CFG, reg); 
    6963 + 
    6964 +       rt2800usb_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
     6687+       rt2x00usb_register_write(rt2x00dev, TX_RTS_CFG, reg); 
     6688+ 
     6689+       rt2x00usb_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
    69656690+       rt2x00_set_field32(&reg, CCK_PROT_CFG_RTS_TH_EN, 1); 
    6966 +       rt2800usb_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
    6967 + 
    6968 +       rt2800usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
     6691+       rt2x00usb_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
     6692+ 
     6693+       rt2x00usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
    69696694+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_RTS_TH_EN, 1); 
    6970 +       rt2800usb_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
    6971 + 
    6972 +       rt2800usb_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
     6695+       rt2x00usb_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
     6696+ 
     6697+       rt2x00usb_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
    69736698+       rt2x00_set_field32(&reg, MM20_PROT_CFG_RTS_TH_EN, 1); 
    6974 +       rt2800usb_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
    6975 + 
    6976 +       rt2800usb_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
     6699+       rt2x00usb_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
     6700+ 
     6701+       rt2x00usb_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
    69776702+       rt2x00_set_field32(&reg, MM40_PROT_CFG_RTS_TH_EN, 1); 
    6978 +       rt2800usb_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
    6979 + 
    6980 +       rt2800usb_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
     6703+       rt2x00usb_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
     6704+ 
     6705+       rt2x00usb_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
    69816706+       rt2x00_set_field32(&reg, GF20_PROT_CFG_RTS_TH_EN, 1); 
    6982 +       rt2800usb_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
    6983 + 
    6984 +       rt2800usb_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
     6707+       rt2x00usb_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
     6708+ 
     6709+       rt2x00usb_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
    69856710+       rt2x00_set_field32(&reg, GF40_PROT_CFG_RTS_TH_EN, 1); 
    6986 +       rt2800usb_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
     6711+       rt2x00usb_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
    69876712+ 
    69886713+       return 0; 
     
    70166741+               field.bit_mask = 0xffff << field.bit_offset; 
    70176742+ 
    7018 +               rt2800usb_register_read(rt2x00dev, WMM_TXOP0_CFG, &reg); 
     6743+               rt2x00usb_register_read(rt2x00dev, WMM_TXOP0_CFG, &reg); 
    70196744+               rt2x00_set_field32(&reg, field, queue->txop); 
    7020 +               rt2800usb_register_write(rt2x00dev, WMM_TXOP0_CFG, reg); 
     6745+               rt2x00usb_register_write(rt2x00dev, WMM_TXOP0_CFG, reg); 
    70216746+       } else if (queue_idx < 4) { 
    70226747+               field.bit_offset = (queue_idx - 2) * 16; 
    70236748+               field.bit_mask = 0xffff << field.bit_offset; 
    70246749+ 
    7025 +               rt2800usb_register_read(rt2x00dev, WMM_TXOP1_CFG, &reg); 
     6750+               rt2x00usb_register_read(rt2x00dev, WMM_TXOP1_CFG, &reg); 
    70266751+               rt2x00_set_field32(&reg, field, queue->txop); 
    7027 +               rt2800usb_register_write(rt2x00dev, WMM_TXOP1_CFG, reg); 
     6752+               rt2x00usb_register_write(rt2x00dev, WMM_TXOP1_CFG, reg); 
    70286753+       } 
    70296754+ 
     
    70326757+       field.bit_mask = 0xf << field.bit_offset; 
    70336758+ 
    7034 +       rt2800usb_register_read(rt2x00dev, WMM_AIFSN_CFG, &reg); 
     6759+       rt2x00usb_register_read(rt2x00dev, WMM_AIFSN_CFG, &reg); 
    70356760+       rt2x00_set_field32(&reg, field, queue->aifs); 
    7036 +       rt2800usb_register_write(rt2x00dev, WMM_AIFSN_CFG, reg); 
    7037 + 
    7038 +       rt2800usb_register_read(rt2x00dev, WMM_CWMIN_CFG, &reg); 
     6761+       rt2x00usb_register_write(rt2x00dev, WMM_AIFSN_CFG, reg); 
     6762+ 
     6763+       rt2x00usb_register_read(rt2x00dev, WMM_CWMIN_CFG, &reg); 
    70396764+       rt2x00_set_field32(&reg, field, queue->cw_min); 
    7040 +       rt2800usb_register_write(rt2x00dev, WMM_CWMIN_CFG, reg); 
    7041 + 
    7042 +       rt2800usb_register_read(rt2x00dev, WMM_CWMAX_CFG, &reg); 
     6765+       rt2x00usb_register_write(rt2x00dev, WMM_CWMIN_CFG, reg); 
     6766+ 
     6767+       rt2x00usb_register_read(rt2x00dev, WMM_CWMAX_CFG, &reg); 
    70436768+       rt2x00_set_field32(&reg, field, queue->cw_max); 
    7044 +       rt2800usb_register_write(rt2x00dev, WMM_CWMAX_CFG, reg); 
     6769+       rt2x00usb_register_write(rt2x00dev, WMM_CWMAX_CFG, reg); 
    70456770+ 
    70466771+       /* Update EDCA registers */ 
     
    70486773+               offset = EDCA_AC0_CFG + (sizeof(u32) * queue_idx); 
    70496774+ 
    7050 +               rt2800usb_register_read(rt2x00dev, offset, &reg); 
     6775+               rt2x00usb_register_read(rt2x00dev, offset, &reg); 
    70516776+               rt2x00_set_field32(&reg, EDCA_AC0_CFG_AIFSN, queue->aifs); 
    70526777+               rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMIN, queue->cw_min); 
    70536778+               rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMAX, queue->cw_max); 
    7054 +               rt2800usb_register_write(rt2x00dev, offset, reg); 
     6779+               rt2x00usb_register_write(rt2x00dev, offset, reg); 
    70556780+       } 
    70566781+ 
     
    70716796+       u32 reg; 
    70726797+ 
    7073 +       rt2800usb_register_read(rt2x00dev, TSF_TIMER_DW1, &reg); 
     6798+       rt2x00usb_register_read(rt2x00dev, TSF_TIMER_DW1, &reg); 
    70746799+       tsf = (u64) rt2x00_get_field32(reg, TSF_TIMER_DW1_HIGH_WORD) << 32; 
    7075 +       rt2800usb_register_read(rt2x00dev, TSF_TIMER_DW0, &reg); 
     6800+       rt2x00usb_register_read(rt2x00dev, TSF_TIMER_DW0, &reg); 
    70766801+       tsf |= rt2x00_get_field32(reg, TSF_TIMER_DW0_LOW_WORD); 
    70776802+ 
     
    71076832+       .initialize             = rt2x00usb_initialize, 
    71086833+       .uninitialize           = rt2x00usb_uninitialize, 
    7109 +       .init_rxentry           = rt2x00usb_init_rxentry, 
    7110 +       .init_txentry           = rt2x00usb_init_txentry, 
     6834+       .clear_entry            = rt2x00usb_clear_entry, 
    71116835+       .set_device_state       = rt2800usb_set_device_state, 
    71126836+       .link_stats             = rt2800usb_link_stats, 
     
    72646988+module_init(rt2800usb_init); 
    72656989+module_exit(rt2800usb_exit); 
     6990diff --git a/drivers/net/wireless/rt2x00/rt2800usb.h b/drivers/net/wireless/rt2x00/rt2800usb.h 
     6991new file mode 100644 
     6992index 0000000..1843217 
    72666993--- /dev/null 
    72676994+++ b/drivers/net/wireless/rt2x00/rt2800usb.h 
     
    91518878+ 
    91528879+#endif /* RT2800USB_H */ 
     8880diff --git a/drivers/net/wireless/rt2x00/rt2x00.h b/drivers/net/wireless/rt2x00/rt2x00.h 
     8881index 780ba73..f462424 100644 
    91538882--- a/drivers/net/wireless/rt2x00/rt2x00.h 
    91548883+++ b/drivers/net/wireless/rt2x00/rt2x00.h 
    9155 @@ -97,6 +97,7 @@ 
     8884@@ -107,6 +107,7 @@ 
    91568885  */ 
    91578886 #define ACK_SIZE               14 
     
    91618890 #define BEACON                 100 
    91628891 #define PREAMBLE               144 
    9163 @@ -127,6 +128,11 @@ struct rt2x00_chip { 
     8892@@ -137,6 +138,11 @@ struct rt2x00_chip { 
    91648893 #define RT2561         0x0302 
    91658894 #define RT2661         0x0401 
     
    91738902        u16 rf; 
    91748903        u32 rev; 
     8904diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c 
     8905index 7fc1d76..853cc51 100644 
    91758906--- a/drivers/net/wireless/rt2x00/rt2x00dev.c 
    91768907+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c 
    9177 @@ -658,7 +658,9 @@ void rt2x00lib_rxdone(struct rt2x00_dev  
     8908@@ -659,7 +659,9 @@ void rt2x00lib_rxdone(struct rt2x00_dev *rt2x00dev, 
    91788909                if (((rxdesc.dev_flags & RXDONE_SIGNAL_PLCP) && 
    91798910                     (rate->plcp == rxdesc.signal)) || 
     
    91868917                        break; 
    91878918                } 
    9188 @@ -690,6 +692,7 @@ void rt2x00lib_rxdone(struct rt2x00_dev  
     8919@@ -691,6 +693,7 @@ void rt2x00lib_rxdone(struct rt2x00_dev *rt2x00dev, 
    91898920        rx_status->qual = 
    91908921            rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc.rssi); 
     
    91948925        rx_status->antenna = rt2x00dev->link.ant.active.rx; 
    91958926  
    9196 @@ -721,72 +724,84 @@ const struct rt2x00_rate rt2x00_supporte 
     8927@@ -722,72 +725,84 @@ const struct rt2x00_rate rt2x00_supported_rates[12] = { 
    91978928                .bitrate = 10, 
    91988929                .ratemask = BIT(0), 
     
    92018932        }, 
    92028933        { 
    9203                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC, 
     8934                .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE, 
    92048935                .bitrate = 20, 
    92058936                .ratemask = BIT(1), 
     
    92088939        }, 
    92098940        { 
    9210                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC, 
     8941                .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE, 
    92118942                .bitrate = 55, 
    92128943                .ratemask = BIT(2), 
     
    92158946        }, 
    92168947        { 
    9217                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC, 
     8948                .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE, 
    92188949                .bitrate = 110, 
    92198950                .ratemask = BIT(3), 
     
    92228953        }, 
    92238954        { 
    9224                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC, 
     8955                .flags = DEV_RATE_OFDM, 
    92258956                .bitrate = 60, 
    92268957                .ratemask = BIT(4), 
     
    92368967        }, 
    92378968        { 
    9238                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC, 
     8969                .flags = DEV_RATE_OFDM, 
    92398970                .bitrate = 120, 
    92408971                .ratemask = BIT(6), 
     
    92508981        }, 
    92518982        { 
    9252                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC, 
     8983                .flags = DEV_RATE_OFDM, 
    92538984                .bitrate = 240, 
    92548985                .ratemask = BIT(8), 
     
    92799010 }; 
    92809011  
     9012diff --git a/drivers/net/wireless/rt2x00/rt2x00lib.h b/drivers/net/wireless/rt2x00/rt2x00lib.h 
     9013index 9399733..b6aa417 100644 
    92819014--- a/drivers/net/wireless/rt2x00/rt2x00lib.h 
    92829015+++ b/drivers/net/wireless/rt2x00/rt2x00lib.h 
    9283 @@ -49,6 +49,7 @@ struct rt2x00_rate { 
     9016@@ -48,6 +48,7 @@ struct rt2x00_rate { 
    92849017        unsigned short ratemask; 
    92859018  
     
    92899022  
    92909023 extern const struct rt2x00_rate rt2x00_supported_rates[12]; 
    9291 @@ -69,6 +70,9 @@ static inline int rt2x00_get_rate_preamb 
     9024@@ -68,6 +69,9 @@ static inline int rt2x00_get_rate_preamble(const u16 hw_value) 
    92929025        return (hw_value & 0xff00); 
    92939026 } 
     
    92999032  * Radio control handlers. 
    93009033  */ 
     9034diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.c b/drivers/net/wireless/rt2x00/rt2x00queue.c 
     9035index b8de9d2..effe93e 100644 
    93019036--- a/drivers/net/wireless/rt2x00/rt2x00queue.c 
    93029037+++ b/drivers/net/wireless/rt2x00/rt2x00queue.c 
    9303 @@ -303,6 +303,19 @@ static void rt2x00queue_create_tx_descri 
     9038@@ -303,6 +303,19 @@ static void rt2x00queue_create_tx_descriptor(struct queue_entry *entry, 
    93049039        } 
    93059040  
     
    93219056         * Length calculation depends on OFDM/CCK rate. 
    93229057         */ 
    9323 @@ -342,6 +355,20 @@ static void rt2x00queue_create_tx_descri 
     9058@@ -342,6 +355,20 @@ static void rt2x00queue_create_tx_descriptor(struct queue_entry *entry, 
    93249059                if (rt2x00_get_rate_preamble(rate->hw_value)) 
    93259060                        txdesc->signal |= 0x08; 
     
    93429077  
    93439078 static void rt2x00queue_write_tx_descriptor(struct queue_entry *entry, 
     9079diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.h b/drivers/net/wireless/rt2x00/rt2x00queue.h 
     9080index 2e99ab5..1772cdd 100644 
    93449081--- a/drivers/net/wireless/rt2x00/rt2x00queue.h 
    93459082+++ b/drivers/net/wireless/rt2x00/rt2x00queue.h 
    9346 @@ -147,12 +147,14 @@ static inline struct skb_frame_desc* get 
     9083@@ -147,12 +147,14 @@ static inline struct skb_frame_desc* get_skb_frame_desc(struct sk_buff *skb) 
    93479084  * 
    93489085  * @RXDONE_SIGNAL_PLCP: Signal field contains the plcp value. 
     
    94219158        short aifs; 
    94229159        short ifs; 
     9160diff --git a/drivers/net/wireless/rt2x00/rt2x00reg.h b/drivers/net/wireless/rt2x00/rt2x00reg.h 
     9161index c2fba7c..52cc166 100644 
    94239162--- a/drivers/net/wireless/rt2x00/rt2x00reg.h 
    94249163+++ b/drivers/net/wireless/rt2x00/rt2x00reg.h 
  • trunk/package/mac80211/patches/320-enable_rt2800.patch

    r13114 r13431  
     1diff --git a/config.mk b/config.mk 
     2index d94a976..a624bdf 100644 
    13--- a/config.mk 
    24+++ b/config.mk 
    3 @@ -146,6 +146,7 @@ CONFIG_ADM8211=m 
     5@@ -156,6 +156,7 @@ CONFIG_ADM8211=m 
    46 CONFIG_RT2X00_LIB_PCI=m 
    57 CONFIG_RT2400PCI=m 
     
    911  
    1012 # Two rt2x00 drivers require firmware: rt61pci and rt73usb. They depend on 
     13@@ -197,6 +198,7 @@ CONFIG_RTL8187=m 
     14 # RT2500USB does not require firmware 
     15 CONFIG_RT2500USB=m 
     16 CONFIG_RT2X00_LIB_USB=m 
     17+CONFIG_RT2X00_LIB_CRYPTO=y 
     18 NEED_RT2X00=y 
     19 # RT73USB requires firmware 
     20 ifneq ($(CONFIG_CRC_ITU_T),) 
Note: See TracChangeset for help on using the changeset viewer.