Changeset 14434


Ignore:
Timestamp:
2009-02-08T10:41:49+01:00 (9 years ago)
Author:
juhosg
Message:

[package] mac80211: update compat-wireless to 2009-02-07

Location:
trunk/package/mac80211
Files:
1 deleted
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/mac80211/Makefile

    r14385 r14434  
    1313 
    1414ifneq ($(CONFIG_LINUX_2_6_27)$(CONFIG_LINUX_2_6_28),) 
    15   PKG_VERSION:=2009-02-02 
     15  PKG_VERSION:=2009-02-07 
    1616  PKG_SOURCE_URL:= \ 
    1717        http://www.orbit-lab.org/kernel/compat-wireless-2.6/2009/02 \ 
    1818        http://wireless.kernel.org/download/compat-wireless-2.6 
    19   PKG_MD5SUM:=310b08184b16ead8cab3714bf5a57728 
     19  PKG_MD5SUM:=fed21ffa78c91e0f8067b8ca63a442b7 
    2020else 
    2121  PKG_VERSION:=2008-08-06 
  • trunk/package/mac80211/patches/210-remove_unused_stuff.patch

    r14329 r14434  
    11--- a/config.mk 
    22+++ b/config.mk 
    3 @@ -75,10 +75,10 @@ CONFIG_MAC80211_MESH=y 
     3@@ -78,10 +78,10 @@ CONFIG_MAC80211_MESH=y 
    44 CONFIG_CFG80211=m 
    55 # CONFIG_CFG80211_REG_DEBUG is not set 
     
    1616 CONFIG_NL80211=y 
    1717  
    18 @@ -118,16 +118,16 @@ CONFIG_IWL3945_LEDS=y 
     18@@ -121,16 +121,16 @@ CONFIG_IWL3945_LEDS=y 
    1919 CONFIG_B43=m 
    2020 CONFIG_B43_PCI_AUTOSELECT=y 
     
    3636 # CONFIG_B43LEGACY_DEBUG=y 
    3737 CONFIG_B43LEGACY_DMA=y 
    38 @@ -137,17 +137,17 @@ CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y 
     38@@ -140,17 +140,17 @@ CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y 
    3939 # CONFIG_B43LEGACY_PIO_MODE is not set 
    4040  
     
    6262 # The above enables use a second interface prefixed 'rtap'. 
    6363 #           Example usage: 
    64 @@ -269,15 +269,15 @@ CONFIG_SSB_SPROM=y 
     64@@ -272,15 +272,15 @@ CONFIG_SSB_SPROM=y 
    6565 ifneq ($(CONFIG_USB),) 
    6666 ifneq ($(CONFIG_LIBERTAS_THINFIRM_USB),m) 
  • trunk/package/mac80211/patches/301-rt2x00-Implement-support-for-802.11n.patch

    r14172 r14434  
    1 From adf33d3a207846709e2a5fb006f17dbc9225f7a9 Mon Sep 17 00:00:00 2001 
     1From 2c0af6ef6263ad5b581429953ad1b98e6d522e69 Mon Sep 17 00:00:00 2001 
    22From: Ivo van Doorn <IvDoorn@gmail.com> 
    3 Date: Fri, 23 Jan 2009 17:10:06 +0100 
     3Date: Wed, 4 Feb 2009 20:10:23 +0100 
    44Subject: [PATCH] rt2x00: Implement support for 802.11n 
    55 
     
    1212 drivers/net/wireless/rt2x00/Kconfig        |    3 + 
    1313 drivers/net/wireless/rt2x00/Makefile       |    1 + 
    14  drivers/net/wireless/rt2x00/rt2x00.h       |    5 ++ 
     14 drivers/net/wireless/rt2x00/rt2x00.h       |    4 + 
    1515 drivers/net/wireless/rt2x00/rt2x00config.c |    5 ++ 
    1616 drivers/net/wireless/rt2x00/rt2x00dev.c    |   91 ++++++++++++++++++++------- 
     
    1818 drivers/net/wireless/rt2x00/rt2x00lib.h    |   24 +++++++ 
    1919 drivers/net/wireless/rt2x00/rt2x00queue.c  |    1 + 
    20  drivers/net/wireless/rt2x00/rt2x00queue.h  |   26 +++++++- 
    21  9 files changed, 197 insertions(+), 28 deletions(-) 
     20 drivers/net/wireless/rt2x00/rt2x00queue.h  |   33 ++++++++-- 
     21 9 files changed, 201 insertions(+), 30 deletions(-) 
    2222 create mode 100644 drivers/net/wireless/rt2x00/rt2x00ht.c 
    2323 
     
    3434--- a/drivers/net/wireless/rt2x00/rt2x00.h 
    3535+++ b/drivers/net/wireless/rt2x00/rt2x00.h 
    36 @@ -108,6 +108,7 @@ 
    37   */ 
    38  #define ACK_SIZE               14 
    39  #define IEEE80211_HEADER       24 
    40 +#define AGGREGATION_SIZE       3840 
    41  #define PLCP                   48 
    42  #define BEACON                 100 
    43  #define PREAMBLE               144 
    44 @@ -357,6 +358,7 @@ static inline struct rt2x00_intf* vif_to 
     36@@ -357,6 +357,7 @@ static inline struct rt2x00_intf* vif_to 
    4537  *     for @tx_power_a, @tx_power_bg and @channels. 
    4638  * @channels: Device/chipset specific channel values (See &struct rf_channel). 
     
    5042 struct hw_mode_spec { 
    5143        unsigned int supported_bands; 
    52 @@ -370,6 +372,8 @@ struct hw_mode_spec { 
     44@@ -370,6 +371,8 @@ struct hw_mode_spec { 
    5345        unsigned int num_channels; 
    5446        const struct rf_channel *channels; 
     
    5951  
    6052 /* 
    61 @@ -603,6 +607,7 @@ enum rt2x00_flags { 
     53@@ -606,6 +609,7 @@ enum rt2x00_flags { 
    6254        CONFIG_EXTERNAL_LNA_BG, 
    6355        CONFIG_DOUBLE_ANTENNA, 
     
    8375--- a/drivers/net/wireless/rt2x00/rt2x00dev.c 
    8476+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c 
    85 @@ -315,18 +315,54 @@ void rt2x00lib_txdone(struct queue_entry 
     77@@ -316,18 +316,54 @@ void rt2x00lib_txdone(struct queue_entry 
    8678 } 
    8779 EXPORT_SYMBOL_GPL(rt2x00lib_txdone); 
     
    142134        /* 
    143135         * Allocate a new sk_buffer. If no new buffer available, drop the 
    144 @@ -375,26 +411,17 @@ void rt2x00lib_rxdone(struct rt2x00_dev  
     136@@ -376,26 +412,17 @@ void rt2x00lib_rxdone(struct rt2x00_dev  
    145137        skb_trim(entry->skb, rxdesc.size); 
    146138  
     
    180172  
    181173        /* 
    182 @@ -404,7 +431,7 @@ void rt2x00lib_rxdone(struct rt2x00_dev  
     174@@ -405,7 +432,7 @@ void rt2x00lib_rxdone(struct rt2x00_dev  
    183175        rt2x00debug_update_crypto(rt2x00dev, &rxdesc); 
    184176  
     
    189181        rx_status->signal = rxdesc.rssi; 
    190182        rx_status->noise = rxdesc.noise; 
    191 @@ -439,72 +466,84 @@ const struct rt2x00_rate rt2x00_supporte 
     183@@ -440,72 +467,84 @@ const struct rt2x00_rate rt2x00_supporte 
    192184                .bitrate = 10, 
    193185                .ratemask = BIT(0), 
     
    274266 }; 
    275267  
    276 @@ -580,6 +619,8 @@ static int rt2x00lib_probe_hw_modes(stru 
     268@@ -581,6 +620,8 @@ static int rt2x00lib_probe_hw_modes(stru 
    277269                rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates; 
    278270                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 
     
    283275  
    284276        /* 
    285 @@ -596,6 +637,8 @@ static int rt2x00lib_probe_hw_modes(stru 
     277@@ -597,6 +638,8 @@ static int rt2x00lib_probe_hw_modes(stru 
    286278                rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4]; 
    287279                hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 
     
    339331+               txdesc->mpdu_density = 0; 
    340332+ 
    341 +       txdesc->ba_size = 0;    /* FIXME: What value is needed? */ 
     333+       txdesc->ba_size = 7;    /* FIXME: What value is needed? */ 
    342334+       txdesc->stbc = 0;       /* FIXME: What value is needed? */ 
    343335+ 
     
    389381  * Radio control handlers. 
    390382  */ 
    391 @@ -330,6 +339,21 @@ static inline void rt2x00crypto_rx_inser 
     383@@ -341,6 +350,21 @@ static inline void rt2x00crypto_rx_inser 
    392384 #endif /* CONFIG_RT2X00_LIB_CRYPTO */ 
    393385  
     
    423415--- a/drivers/net/wireless/rt2x00/rt2x00queue.h 
    424416+++ b/drivers/net/wireless/rt2x00/rt2x00queue.h 
    425 @@ -145,6 +145,7 @@ static inline struct skb_frame_desc* get 
     417@@ -35,9 +35,12 @@ 
     418  * for USB devices this restriction does not apply, but the value of 
     419  * 2432 makes sense since it is big enough to contain the maximum fragment 
     420  * size according to the ieee802.11 specs. 
     421+ * The aggregation size depends on support from the driver, but should 
     422+ * be something around 3840 bytes. 
     423  */ 
     424-#define DATA_FRAME_SIZE        2432 
     425-#define MGMT_FRAME_SIZE        256 
     426+#define DATA_FRAME_SIZE                2432 
     427+#define MGMT_FRAME_SIZE                256 
     428+#define AGGREGATION_SIZE       3840 
     429  
     430 /** 
     431  * DOC: Number of entries per queue 
     432@@ -145,6 +148,7 @@ static inline struct skb_frame_desc* get 
    426433  * 
    427434  * @RXDONE_SIGNAL_PLCP: Signal field contains the plcp value. 
     
    431438  * @RXDONE_CRYPTO_IV: Driver provided IV/EIV data. 
    432439  * @RXDONE_CRYPTO_ICV: Driver provided ICV data. 
    433 @@ -152,9 +153,10 @@ static inline struct skb_frame_desc* get 
     440@@ -152,9 +156,10 @@ static inline struct skb_frame_desc* get 
    434441 enum rxdone_entry_desc_flags { 
    435442        RXDONE_SIGNAL_PLCP = 1 << 0, 
     
    445452  
    446453 /** 
    447 @@ -163,7 +165,7 @@ enum rxdone_entry_desc_flags { 
     454@@ -163,7 +168,7 @@ enum rxdone_entry_desc_flags { 
    448455  * from &rxdone_entry_desc to a signal value type. 
    449456  */ 
     
    454461 /** 
    455462  * struct rxdone_entry_desc: RX Entry descriptor 
    456 @@ -177,6 +179,7 @@ enum rxdone_entry_desc_flags { 
     463@@ -177,6 +182,7 @@ enum rxdone_entry_desc_flags { 
    457464  * @size: Data size of the received frame. 
    458465  * @flags: MAC80211 receive flags (See &enum mac80211_rx_flags). 
     
    462469  * @cipher_status: Decryption status. 
    463470  * @iv: IV/EIV data used during decryption. 
    464 @@ -190,6 +193,7 @@ struct rxdone_entry_desc { 
     471@@ -190,6 +196,7 @@ struct rxdone_entry_desc { 
    465472        int size; 
    466473        int flags; 
     
    470477        u8 cipher_status; 
    471478  
    472 @@ -243,6 +247,9 @@ struct txdone_entry_desc { 
     479@@ -243,6 +250,9 @@ struct txdone_entry_desc { 
    473480  * @ENTRY_TXD_ENCRYPT_PAIRWISE: Use pairwise key table (instead of shared). 
    474481  * @ENTRY_TXD_ENCRYPT_IV: Generate IV/EIV in hardware. 
     
    480487 enum txentry_desc_flags { 
    481488        ENTRY_TXD_RTS_FRAME, 
    482 @@ -258,6 +265,9 @@ enum txentry_desc_flags { 
     489@@ -258,6 +268,9 @@ enum txentry_desc_flags { 
    483490        ENTRY_TXD_ENCRYPT_PAIRWISE, 
    484491        ENTRY_TXD_ENCRYPT_IV, 
     
    490497  
    491498 /** 
    492 @@ -271,7 +281,11 @@ enum txentry_desc_flags { 
     499@@ -271,7 +284,11 @@ enum txentry_desc_flags { 
    493500  * @length_low: PLCP length low word. 
    494501  * @signal: PLCP signal. 
     
    502509  * @aifs: AIFS value. 
    503510  * @ifs: IFS value. 
    504 @@ -291,7 +305,11 @@ struct txentry_desc { 
     511@@ -291,7 +308,11 @@ struct txentry_desc { 
    505512        u16 signal; 
    506513        u16 service; 
  • trunk/package/mac80211/patches/302-rt2x00-Implement-support-for-rt2800pci.patch

    r14172 r14434  
    1 From 659988a6bb83536c5d0a01b0b58378cc1856c975 Mon Sep 17 00:00:00 2001 
     1From f2219a0f2f2f61656d2c3a524836f6f1e646ea33 Mon Sep 17 00:00:00 2001 
    22From: Ivo van Doorn <IvDoorn@gmail.com> 
    3 Date: Fri, 23 Jan 2009 17:13:03 +0100 
     3Date: Wed, 4 Feb 2009 20:43:00 +0100 
    44Subject: [PATCH] rt2x00: Implement support for rt2800pci 
    55 
     
    1515 drivers/net/wireless/rt2x00/Kconfig     |   15 + 
    1616 drivers/net/wireless/rt2x00/Makefile    |    1 + 
    17  drivers/net/wireless/rt2x00/rt2800pci.c | 2763 +++++++++++++++++++++++++++++++ 
    18  drivers/net/wireless/rt2x00/rt2800pci.h | 1881 +++++++++++++++++++++ 
     17 drivers/net/wireless/rt2x00/rt2800pci.c | 2785 +++++++++++++++++++++++++++++++ 
     18 drivers/net/wireless/rt2x00/rt2800pci.h | 1877 +++++++++++++++++++++ 
    1919 drivers/net/wireless/rt2x00/rt2x00.h    |    4 + 
    20  5 files changed, 4664 insertions(+), 0 deletions(-) 
     20 5 files changed, 4682 insertions(+), 0 deletions(-) 
    2121 create mode 100644 drivers/net/wireless/rt2x00/rt2800pci.c 
    2222 create mode 100644 drivers/net/wireless/rt2x00/rt2800pci.h 
     
    3333--- /dev/null 
    3434+++ b/drivers/net/wireless/rt2x00/rt2800pci.c 
    35 @@ -0,0 +1,2763 @@ 
     35@@ -0,0 +1,2785 @@ 
    3636+/* 
    3737+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
     
    365365+                                      struct ieee80211_key_conf *key) 
    366366+{ 
     367+       struct mac_wcid_entry wcid_entry; 
     368+       struct mac_iveiv_entry iveiv_entry; 
    367369+       u32 offset; 
    368370+       u32 reg; 
     
    370372+       offset = MAC_WCID_ATTR_ENTRY(crypto->aid); 
    371373+ 
    372 +       reg = 0; 
     374+       rt2x00pci_register_read(rt2x00dev, offset, &reg); 
    373375+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_KEYTAB, 
    374376+                          !!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)); 
    375 +       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_PAIRKEY_MODE, 
    376 +                          crypto->cipher); 
     377+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_CIPHER, crypto->cipher); 
    377378+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_BSS_IDX, 
    378 +                          (crypto->cmd == SET_KEY) ? crypto->bssidx : 0); 
     379+                          (crypto->cmd == SET_KEY) * crypto->bssidx); 
    379380+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_RX_WIUDF, 0); 
    380381+       rt2x00pci_register_write(rt2x00dev, offset, reg); 
     382+ 
     383+       offset = MAC_IVEIV_ENTRY(crypto->aid); 
     384+ 
     385+       memset(&iveiv_entry, 0, sizeof(iveiv_entry)); 
     386+       if ((crypto->cipher == CIPHER_TKIP) || 
     387+           (crypto->cipher == CIPHER_TKIP_NO_MIC) || 
     388+           (crypto->cipher == CIPHER_AES)) 
     389+               iveiv_entry.iv[3] |= 0x20; 
     390+       iveiv_entry.iv[3] |= key->keyidx << 6; 
     391+       rt2x00pci_register_multiwrite(rt2x00dev, offset, 
     392+                                     &iveiv_entry, sizeof(iveiv_entry)); 
     393+ 
     394+       offset = MAC_WCID_ENTRY(crypto->aid); 
     395+ 
     396+       memset(&wcid_entry, 0, sizeof(wcid_entry)); 
     397+       if (crypto->cmd == SET_KEY) 
     398+               memcpy(&wcid_entry, crypto->address, ETH_ALEN); 
     399+       rt2x00pci_register_multiwrite(rt2x00dev, offset, 
     400+                                     &wcid_entry, sizeof(wcid_entry)); 
    381401+} 
    382402+ 
     
    388408+       struct rt2x00_field32 field; 
    389409+       u32 offset; 
    390 +       u32 mask; 
    391410+       u32 reg; 
    392411+ 
    393412+       if (crypto->cmd == SET_KEY) { 
     413+               key->hw_key_idx = (4 * crypto->bssidx) + key->keyidx; 
     414+ 
    394415+               memcpy(key_entry.key, crypto->key, 
    395416+                      sizeof(key_entry.key)); 
     
    402423+               rt2x00pci_register_multiwrite(rt2x00dev, offset, 
    403424+                                             &key_entry, sizeof(key_entry)); 
    404 + 
    405 +               /* 
    406 +                * The driver does not support the IV/EIV generation 
    407 +                * in hardware. However it doesn't support the IV/EIV 
    408 +                * inside the ieee80211 frame either, but requires it 
    409 +                * to be provided seperately for the descriptor. 
    410 +                * rt2x00lib will cut the IV/EIV data out of all frames 
    411 +                * given to us by mac80211, but we must tell mac80211 
    412 +                * to generate the IV/EIV data. 
    413 +                */ 
    414 +               key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 
    415425+       } 
    416426+ 
     
    418428+        * The cipher types are stored over multiple registers 
    419429+        * starting with SHARED_KEY_MODE_BASE each word will have 
    420 +        * 32 bits and contains the cipher types for 2 modes each. 
     430+        * 32 bits and contains the cipher types for 2 bssidx each. 
    421431+        * Using the correct defines correctly will cause overhead, 
    422432+        * so just calculate the correct offset. 
    423433+        */ 
    424 +       mask = key->hw_key_idx % 8; 
    425 +       field.bit_offset = (3 * mask); 
     434+       field.bit_offset = (4 * key->keyidx); 
    426435+       field.bit_mask = 0x7 << field.bit_offset; 
    427436+ 
     
    429438+       rt2x00pci_register_read(rt2x00dev, offset, &reg); 
    430439+       rt2x00_set_field32(&reg, field, 
    431 +                          (crypto->cmd == SET_KEY) ? crypto->cipher : 0); 
     440+                          (crypto->cmd == SET_KEY) * crypto->cipher); 
    432441+       rt2x00pci_register_write(rt2x00dev, offset, reg); 
    433442+ 
     
    447456+       u32 offset; 
    448457+ 
    449 +       /* 
    450 +        * 1 pairwise key is possible per AID, this means that the AID 
    451 +        * equals our hw_key_idx. 
    452 +        */ 
    453 +       key->hw_key_idx = crypto->aid; 
    454 + 
    455458+       if (crypto->cmd == SET_KEY) { 
     459+               /* 
     460+                * 1 pairwise key is possible per AID, this means that the AID 
     461+                * equals our hw_key_idx. 
     462+                */ 
     463+               key->hw_key_idx = crypto->aid; 
     464+ 
    456465+               memcpy(key_entry.key, crypto->key, 
    457466+                      sizeof(key_entry.key)); 
     
    464473+               rt2x00pci_register_multiwrite(rt2x00dev, offset, 
    465474+                                             &key_entry, sizeof(key_entry)); 
    466 + 
    467 +               /* 
    468 +                * The driver does not support the IV/EIV generation 
    469 +                * in hardware. However it doesn't support the IV/EIV 
    470 +                * inside the ieee80211 frame either, but requires it 
    471 +                * to be provided seperately for the descriptor. 
    472 +                * rt2x00lib will cut the IV/EIV data out of all frames 
    473 +                * given to us by mac80211, but we must tell mac80211 
    474 +                * to generate the IV/EIV data. 
    475 +                */ 
    476 +               key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 
    477475+       } 
    478476+ 
     
    522520+                          !(filter_flags & FIF_CONTROL)); 
    523521+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BA, 1); 
    524 +       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BAR, 1); 
     522+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BAR, 0); 
    525523+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CNTL, 
    526524+                          !(filter_flags & FIF_CONTROL)); 
     
    583581+       rt2x00pci_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
    584582+       rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_RX_ACK_TIMEOUT, 
    585 +                          erp->ack_timeout); 
     583+                          DIV_ROUND_UP(erp->ack_timeout, erp->slot_time)); 
    586584+       rt2x00pci_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
    587585+ 
     
    600598+       rt2x00pci_register_write(rt2x00dev, LEGACY_BASIC_RATE, 
    601599+                                erp->basic_rates); 
    602 +       rt2x00pci_register_write(rt2x00dev, HT_BASIC_RATE, 
    603 +                                erp->basic_rates >> 32); 
     600+       rt2x00pci_register_write(rt2x00dev, HT_BASIC_RATE, 0x00008003); 
    604601+ 
    605602+       rt2x00pci_register_read(rt2x00dev, BKOFF_SLOT_CFG, &reg); 
     
    981978+       rt2x00pci_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
    982979+       qual->rx_failed = rt2x00_get_field32(reg, RX_STA_CNT0_CRC_ERR); 
    983 + 
    984 +       /* 
    985 +        * Update False CCA count from register. 
    986 +        */ 
    987 +       rt2x00pci_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
    988 +       qual->false_cca = rt2x00_get_field32(reg, RX_STA_CNT1_FALSE_CCA); 
    989980+} 
    990981+ 
     
    10391030+} 
    10401031+ 
    1041 +static u16 rt2800pci_get_firmware_crc(const void *data, const size_t len) 
    1042 +{ 
     1032+static int rt2800pci_check_firmware(struct rt2x00_dev *rt2x00dev, 
     1033+                                   const u8 *data, const size_t len) 
     1034+{ 
     1035+       u16 fw_crc; 
    10431036+       u16 crc; 
     1037+ 
     1038+       /* 
     1039+        * Only support 8kb firmware files. 
     1040+        */ 
     1041+       if (len != 8192) 
     1042+               return FW_BAD_LENGTH; 
     1043+ 
     1044+       /* 
     1045+        * The last 2 bytes in the firmware array are the crc checksum itself, 
     1046+        * this means that we should never pass those 2 bytes to the crc 
     1047+        * algorithm. 
     1048+        */ 
     1049+       fw_crc = (data[len - 2] << 8 | data[len - 1]); 
    10441050+ 
    10451051+       /* 
     
    10491055+        * before input input as well as on the final output. 
    10501056+        * Obviously using crc ccitt directly is much more efficient. 
    1051 +        * The last 2 bytes in the firmware array are the crc checksum itself, 
    1052 +        * this means that we should never pass those 2 bytes to the crc 
    1053 +        * algorithm. 
    10541057+        */ 
    10551058+       crc = crc_ccitt(~0, data, len - 2); 
     
    10611064+        * value. 
    10621065+        */ 
    1063 +       return swab16(crc); 
     1066+       crc = swab16(crc); 
     1067+ 
     1068+       return (fw_crc == crc) ? FW_OK : FW_BAD_CRC; 
    10641069+} 
    10651070+ 
    10661071+static int rt2800pci_load_firmware(struct rt2x00_dev *rt2x00dev, 
    1067 +                                  const void *data, const size_t len) 
     1072+                                  const u8 *data, const size_t len) 
    10681073+{ 
    10691074+       unsigned int i; 
    10701075+       u32 reg; 
    1071 + 
    1072 +       if (len != 8192) { 
    1073 +               ERROR(rt2x00dev, "Invalid firmware file length (len=%zu)\n", len); 
    1074 +               return -ENOENT; 
    1075 +       } 
    10761076+ 
    10771077+       /* 
     
    12021202+       rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT0, rt2x00dev->tx[0].limit); 
    12031203+       rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX0, 0); 
     1204+       rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX0, 0); 
    12041205+ 
    12051206+       entry_priv = rt2x00dev->tx[1].entries[0].priv_data; 
     
    12071208+       rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT1, rt2x00dev->tx[1].limit); 
    12081209+       rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX1, 0); 
     1210+       rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX1, 0); 
    12091211+ 
    12101212+       entry_priv = rt2x00dev->tx[2].entries[0].priv_data; 
     
    12121214+       rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT2, rt2x00dev->tx[2].limit); 
    12131215+       rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX2, 0); 
     1216+       rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX2, 0); 
    12141217+ 
    12151218+       entry_priv = rt2x00dev->tx[3].entries[0].priv_data; 
     
    12171220+       rt2x00pci_register_write(rt2x00dev, TX_MAX_CNT3, rt2x00dev->tx[3].limit); 
    12181221+       rt2x00pci_register_write(rt2x00dev, TX_CTX_IDX3, 0); 
     1222+       rt2x00pci_register_write(rt2x00dev, TX_DTX_IDX3, 0); 
    12191223+ 
    12201224+       entry_priv = rt2x00dev->rx->entries[0].priv_data; 
     
    12221226+       rt2x00pci_register_write(rt2x00dev, RX_MAX_CNT, rt2x00dev->rx[0].limit); 
    12231227+       rt2x00pci_register_write(rt2x00dev, RX_CRX_IDX, 0); 
     1228+       rt2x00pci_register_write(rt2x00dev, RX_DRX_IDX, 0); 
    12241229+ 
    12251230+       /* 
     
    12921297+       rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
    12931298+ 
    1294 +       rt2x00pci_register_write(rt2x00dev, TX_SW_CFG0, 0x00040a06); 
     1299+       rt2x00pci_register_write(rt2x00dev, TX_SW_CFG0, 0x00000000); 
    12951300+       rt2x00pci_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606); 
    12961301+ 
     
    13331338+ 
    13341339+       rt2x00pci_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
    1335 +       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_RATE, 3); 
     1340+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_RATE, 8); 
    13361341+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_CTRL, 0); 
    13371342+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_NAV, 1); 
     
    13391344+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
    13401345+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
    1341 +       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1346+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM40, 1); 
    13421347+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    13431348+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     
    13451350+ 
    13461351+       rt2x00pci_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
    1347 +       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_RATE, 3); 
     1352+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_RATE, 8); 
    13481353+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_CTRL, 0); 
    13491354+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_NAV, 1); 
     
    13511356+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
    13521357+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
    1353 +       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1358+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM40, 1); 
    13541359+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    13551360+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     
    14711476+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS0FBK, 8); 
    14721477+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS1FBK, 8); 
    1473 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS2FBK, 10); 
    1474 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS3FBK, 11); 
    1475 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS4FBK, 12); 
    1476 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS5FBK, 13); 
    1477 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS6FBK, 14); 
    1478 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS7FBK, 15); 
     1478+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS2FBK, 3); 
     1479+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS3FBK, 10); 
     1480+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS4FBK, 11); 
     1481+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS5FBK, 12); 
     1482+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS6FBK, 13); 
     1483+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS7FBK, 14); 
    14791484+       rt2x00pci_register_write(rt2x00dev, LG_FBK_CFG0, reg); 
    14801485+ 
     
    18211826+       rt2x00_desc_read(txwi, 0, &word); 
    18221827+       rt2x00_set_field32(&word, TXWI_W0_FRAG, 
    1823 +                          test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags) || 
    18241828+                          test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags)); 
    18251829+       rt2x00_set_field32(&word, TXWI_W0_MIMO_PS, 0); 
     
    19581962+} 
    19591963+ 
     1964+static void rt2800pci_kill_tx_queue(struct rt2x00_dev *rt2x00dev, 
     1965+                                   const enum data_queue_qid qid) 
     1966+{ 
     1967+       u32 reg; 
     1968+ 
     1969+       if (qid == QID_BEACON) { 
     1970+               rt2x00pci_register_write(rt2x00dev, BCN_TIME_CFG, 0); 
     1971+               return; 
     1972+       } 
     1973+ 
     1974+       rt2x00pci_register_read(rt2x00dev, WPDMA_RST_IDX, &reg); 
     1975+       rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX0, (qid == QID_AC_BE)); 
     1976+       rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX1, (qid == QID_AC_BK)); 
     1977+       rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX2, (qid == QID_AC_VI)); 
     1978+       rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX3, (qid == QID_AC_VO)); 
     1979+       rt2x00pci_register_write(rt2x00dev, WPDMA_RST_IDX, reg); 
     1980+} 
     1981+ 
    19601982+/* 
    19611983+ * RX control handlers 
     
    20332055+       rxdesc->rssi = 
    20342056+           (rt2x00_get_field32(rxwi2, RXWI_W2_RSSI0) + 
    2035 +            rt2x00_get_field32(rxwi2, RXWI_W2_RSSI1) + 
    2036 +            rt2x00_get_field32(rxwi2, RXWI_W2_RSSI2)) / 3; 
     2057+            rt2x00_get_field32(rxwi2, RXWI_W2_RSSI1)) / 2; 
    20372058+ 
    20382059+       rxdesc->noise = 
     
    21802201+       eeprom.register_read = rt2800pci_eepromregister_read; 
    21812202+       eeprom.register_write = rt2800pci_eepromregister_write; 
    2182 +       eeprom.width = rt2x00_get_field32(reg, E2PROM_CSR_TYPE_93C46) ? 
     2203+       eeprom.width = !rt2x00_get_field32(reg, E2PROM_CSR_TYPE) ? 
    21832204+           PCI_EEPROM_WIDTH_93C46 : PCI_EEPROM_WIDTH_93C66; 
    21842205+       eeprom.reg_data_in = 0; 
     
    26932714+       .probe_hw               = rt2800pci_probe_hw, 
    26942715+       .get_firmware_name      = rt2800pci_get_firmware_name, 
    2695 +       .get_firmware_crc       = rt2800pci_get_firmware_crc, 
     2716+       .check_firmware         = rt2800pci_check_firmware, 
    26962717+       .load_firmware          = rt2800pci_load_firmware, 
    26972718+       .initialize             = rt2x00pci_initialize, 
     
    27082729+       .write_beacon           = rt2800pci_write_beacon, 
    27092730+       .kick_tx_queue          = rt2800pci_kick_tx_queue, 
     2731+       .kill_tx_queue          = rt2800pci_kill_tx_queue, 
    27102732+       .fill_rxdone            = rt2800pci_fill_rxdone, 
    27112733+       .config_shared_key      = rt2800pci_config_shared_key, 
     
    27992821--- /dev/null 
    28002822+++ b/drivers/net/wireless/rt2x00/rt2800pci.h 
    2801 @@ -0,0 +1,1881 @@ 
     2823@@ -0,0 +1,1877 @@ 
    28022824+/* 
    28032825+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
     
    28912913+ * E2PROM_CSR: EEPROM control register. 
    28922914+ * RELOAD: Write 1 to reload eeprom content. 
    2893 + * TYPE_93C46: 1: 93c46, 0:93c66. 
     2915+ * TYPE: 0: 93c46, 1:93c66. 
    28942916+ * LOAD_STATUS: 1:loading, 0:done. 
    28952917+ */ 
     
    28992921+#define E2PROM_CSR_DATA_IN             FIELD32(0x00000004) 
    29002922+#define E2PROM_CSR_DATA_OUT            FIELD32(0x00000008) 
    2901 +#define E2PROM_CSR_TYPE_93C46          FIELD32(0x00000020) 
     2923+#define E2PROM_CSR_TYPE                        FIELD32(0x00000030) 
    29022924+#define E2PROM_CSR_LOAD_STATUS         FIELD32(0x00000040) 
    29032925+#define E2PROM_CSR_RELOAD              FIELD32(0x00000080) 
     
    40894111+ 
    40904112+/* 
    4091 + * Security key table memory, base address = 0x1800 
    4092 + */ 
    4093 +struct hw_pairwise_ta_entry { 
    4094 +       u8 address[6]; 
     4113+ * Security key table memory. 
     4114+ * MAC_WCID_BASE: 8-bytes (use only 6 bytes) * 256 entry 
     4115+ * PAIRWISE_KEY_TABLE_BASE: 32-byte * 256 entry 
     4116+ * MAC_IVEIV_TABLE_BASE: 8-byte * 256-entry 
     4117+ * MAC_WCID_ATTRIBUTE_BASE: 4-byte * 256-entry 
     4118+ * SHARED_KEY_TABLE_BASE: 32-byte * 16-entry 
     4119+ * SHARED_KEY_MODE_BASE: 4-byte * 16-entry 
     4120+ */ 
     4121+#define MAC_WCID_BASE                  0x1800 
     4122+#define PAIRWISE_KEY_TABLE_BASE                0x4000 
     4123+#define MAC_IVEIV_TABLE_BASE           0x6000 
     4124+#define MAC_WCID_ATTRIBUTE_BASE                0x6800 
     4125+#define SHARED_KEY_TABLE_BASE          0x6c00 
     4126+#define SHARED_KEY_MODE_BASE           0x7000 
     4127+ 
     4128+#define MAC_WCID_ENTRY(__idx) \ 
     4129+       ( MAC_WCID_BASE + ((__idx) * sizeof(struct mac_wcid_entry)) ) 
     4130+#define PAIRWISE_KEY_ENTRY(__idx) \ 
     4131+       ( PAIRWISE_KEY_TABLE_BASE + ((__idx) * sizeof(struct hw_key_entry)) ) 
     4132+#define MAC_IVEIV_ENTRY(__idx) \ 
     4133+       ( MAC_IVEIV_TABLE_BASE + ((__idx) & sizeof(struct mac_iveiv_entry)) ) 
     4134+#define MAC_WCID_ATTR_ENTRY(__idx) \ 
     4135+       ( MAC_WCID_ATTRIBUTE_BASE + ((__idx) * sizeof(u32)) ) 
     4136+#define SHARED_KEY_ENTRY(__idx) \ 
     4137+       ( SHARED_KEY_TABLE_BASE + ((__idx) * sizeof(struct hw_key_entry)) ) 
     4138+#define SHARED_KEY_MODE_ENTRY(__idx) \ 
     4139+       ( SHARED_KEY_MODE_BASE + ((__idx) * sizeof(u32)) ) 
     4140+ 
     4141+struct mac_wcid_entry { 
     4142+       u8 mac[6]; 
    40954143+       u8 reserved[2]; 
    4096 +} __attribute__ ((packed)); 
    4097 + 
    4098 +struct wcid_entry { 
    4099 +       u8 rx_ba_bitmat7; 
    4100 +       u8 rx_ba_bitmat0; 
    4101 +       u8 mac[6]; 
    41024144+} __attribute__ ((packed)); 
    41034145+ 
     
    41084150+} __attribute__ ((packed)); 
    41094151+ 
    4110 +/* 
    4111 + * Security key table memory. 
    4112 + * MAC_WCID_BASE: 8-bytes (use only 6 bytes) * 256 entry 
    4113 + * PAIRWISE_KEY_TABLE_BASE: 32-byte * 256 entry 
    4114 + * PAIRWISE_IVEIV_TABLE_BASE: 8-byte * 256-entry 
    4115 + * MAC_IVEIV_TABLE_BASE: 8-byte * 256-entry 
    4116 + * MAC_WCID_ATTRIBUTE_BASE: 4-byte * 256-entry 
    4117 + * SHARED_KEY_TABLE_BASE: 32-byte * 16-entry 
    4118 + * SHARED_KEY_MODE_BASE: 32-byte * 16-entry 
    4119 + */ 
    4120 +#define MAC_WCID_BASE                  0x1800 
    4121 +#define PAIRWISE_KEY_TABLE_BASE                0x4000 
    4122 +#define PAIRWISE_IVEIV_TABLE_BASE      0x6000 
    4123 +#define MAC_IVEIV_TABLE_BASE           0x6000 
    4124 +#define MAC_WCID_ATTRIBUTE_BASE                0x6800 
    4125 +#define SHARED_KEY_TABLE_BASE          0x6c00 
    4126 +#define SHARED_KEY_MODE_BASE           0x7000 
    4127 + 
    4128 +#define SHARED_KEY_ENTRY(__idx) \ 
    4129 +       ( SHARED_KEY_TABLE_BASE + \ 
    4130 +               ((__idx) * sizeof(struct hw_key_entry)) ) 
    4131 +#define SHARED_KEY_MODE_ENTRY(__idx) \ 
    4132 +       ( SHARED_KEY_MODE_BASE + ((__idx) * sizeof(u32)) ) 
    4133 +#define PAIRWISE_KEY_ENTRY(__idx) \ 
    4134 +       ( PAIRWISE_KEY_TABLE_BASE + \ 
    4135 +               ((__idx) * sizeof(struct hw_key_entry)) ) 
    4136 + 
    4137 +#define MAC_WCID_ENTRY(__idx) \ 
    4138 +       ( MAC_WCID_BASE + (2 * sizeof(u32) * (__idx)) ) 
    4139 +#define MAC_WCID_ATTR_ENTRY(__idx) \ 
    4140 +       ( MAC_WCID_ATTRIBUTE_BASE + ((__idx) * sizeof(u32)) ) 
     4152+struct mac_iveiv_entry { 
     4153+       u8 iv[8]; 
     4154+} __attribute__ ((packed)); 
     4155+ 
     4156+/* 
     4157+ * MAC_IVEIV: 
     4158+ */ 
     4159+#define MAC_IVEIV_EIV                  FIELD32(0x20000000) 
     4160+#define MAC_IVEIV_KEYIDX               FIELD32(0xc0000000) 
    41414161+ 
    41424162+/* 
    41434163+ * MAC_WCID_ATTRIBUTE: 
    4144 + * KEYTAB: 0: shared key table, 1: pairwise key table 
    4145 + * BSS_IDX: multipleBSS index for the WCID 
    41464164+ */ 
    41474165+#define MAC_WCID_ATTRIBUTE_KEYTAB      FIELD32(0x00000001) 
    4148 +#define MAC_WCID_ATTRIBUTE_PAIRKEY_MODE        FIELD32(0x0000000e) 
     4166+#define MAC_WCID_ATTRIBUTE_CIPHER      FIELD32(0x0000000e) 
    41494167+#define MAC_WCID_ATTRIBUTE_BSS_IDX     FIELD32(0x00000070) 
    41504168+#define MAC_WCID_ATTRIBUTE_RX_WIUDF    FIELD32(0x00000380) 
     
    46834701--- a/drivers/net/wireless/rt2x00/rt2x00.h 
    46844702+++ b/drivers/net/wireless/rt2x00/rt2x00.h 
    4685 @@ -139,6 +139,10 @@ struct rt2x00_chip { 
     4703@@ -138,6 +138,10 @@ struct rt2x00_chip { 
    46864704 #define RT2561         0x0302 
    46874705 #define RT2661         0x0401 
  • trunk/package/mac80211/patches/303-rt2x00-Implement-support-for-rt2800usb.patch

    r14172 r14434  
    1 From e380f1fa260d81cba1ebb1b6c333ef8c31f2a8c5 Mon Sep 17 00:00:00 2001 
     1From ec4f9f97afa3f792cf64035b8458bf2f8648a76f Mon Sep 17 00:00:00 2001 
    22From: Ivo van Doorn <IvDoorn@gmail.com> 
    3 Date: Fri, 23 Jan 2009 17:16:11 +0100 
     3Date: Wed, 4 Feb 2009 20:45:56 +0100 
    44Subject: [PATCH] rt2x00: Implement support for rt2800usb 
    55 
     
    1414 drivers/net/wireless/rt2x00/Kconfig     |   14 + 
    1515 drivers/net/wireless/rt2x00/Makefile    |    1 + 
    16  drivers/net/wireless/rt2x00/rt2800usb.c | 2905 +++++++++++++++++++++++++++++++ 
    17  drivers/net/wireless/rt2x00/rt2800usb.h | 1944 +++++++++++++++++++++ 
     16 drivers/net/wireless/rt2x00/rt2800usb.c | 2928 +++++++++++++++++++++++++++++++ 
     17 drivers/net/wireless/rt2x00/rt2800usb.h | 1940 ++++++++++++++++++++ 
    1818 drivers/net/wireless/rt2x00/rt2x00.h    |    7 + 
    19  5 files changed, 4871 insertions(+), 0 deletions(-) 
     19 5 files changed, 4890 insertions(+), 0 deletions(-) 
    2020 create mode 100644 drivers/net/wireless/rt2x00/rt2800usb.c 
    2121 create mode 100644 drivers/net/wireless/rt2x00/rt2800usb.h 
     
    3030--- /dev/null 
    3131+++ b/drivers/net/wireless/rt2x00/rt2800usb.c 
    32 @@ -0,0 +1,2905 @@ 
     32@@ -0,0 +1,2928 @@ 
    3333+/* 
    3434+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
     
    389389+                                      struct ieee80211_key_conf *key) 
    390390+{ 
     391+       struct mac_wcid_entry wcid_entry; 
     392+       struct mac_iveiv_entry iveiv_entry; 
    391393+       u32 offset; 
    392394+       u32 reg; 
     
    394396+       offset = MAC_WCID_ATTR_ENTRY(crypto->aid); 
    395397+ 
    396 +       reg = 0; 
     398+       rt2x00usb_register_read(rt2x00dev, offset, &reg); 
    397399+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_KEYTAB, 
    398400+                          !!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)); 
    399 +       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_PAIRKEY_MODE, 
    400 +                          crypto->cipher); 
     401+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_CIPHER, crypto->cipher); 
    401402+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_BSS_IDX, 
    402 +                          (crypto->cmd == SET_KEY) ? crypto->bssidx : 0); 
     403+                          (crypto->cmd == SET_KEY) * crypto->bssidx); 
    403404+       rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_RX_WIUDF, 0); 
    404405+       rt2x00usb_register_write(rt2x00dev, offset, reg); 
     406+ 
     407+       offset = MAC_IVEIV_ENTRY(crypto->aid); 
     408+ 
     409+       memset(&iveiv_entry, 0, sizeof(iveiv_entry)); 
     410+       if ((crypto->cipher == CIPHER_TKIP) || 
     411+           (crypto->cipher == CIPHER_TKIP_NO_MIC) || 
     412+           (crypto->cipher == CIPHER_AES)) 
     413+               iveiv_entry.iv[3] |= 0x20; 
     414+       iveiv_entry.iv[3] |= key->keyidx << 6; 
     415+       rt2x00usb_register_multiwrite(rt2x00dev, offset, 
     416+                                     &iveiv_entry, sizeof(iveiv_entry)); 
     417+ 
     418+       offset = MAC_WCID_ENTRY(crypto->aid); 
     419+ 
     420+       memset(&wcid_entry, 0, sizeof(wcid_entry)); 
     421+       if (crypto->cmd == SET_KEY) 
     422+               memcpy(&wcid_entry, crypto->address, ETH_ALEN); 
     423+       rt2x00usb_register_multiwrite(rt2x00dev, offset, 
     424+                                     &wcid_entry, sizeof(wcid_entry)); 
    405425+} 
    406426+ 
     
    413433+       int timeout; 
    414434+       u32 offset; 
    415 +       u32 mask; 
    416435+       u32 reg; 
    417436+ 
    418437+       if (crypto->cmd == SET_KEY) { 
     438+               key->hw_key_idx = (4 * crypto->bssidx) + key->keyidx; 
     439+ 
    419440+               memcpy(key_entry.key, crypto->key, 
    420441+                      sizeof(key_entry.key)); 
     
    431452+                                                   sizeof(key_entry), 
    432453+                                                   timeout); 
    433 + 
    434 +               /* 
    435 +                * The driver does not support the IV/EIV generation 
    436 +                * in hardware. However it doesn't support the IV/EIV 
    437 +                * inside the ieee80211 frame either, but requires it 
    438 +                * to be provided seperately for the descriptor. 
    439 +                * rt2x00lib will cut the IV/EIV data out of all frames 
    440 +                * given to us by mac80211, but we must tell mac80211 
    441 +                * to generate the IV/EIV data. 
    442 +                */ 
    443 +               key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 
    444454+       } 
    445455+ 
     
    447457+        * The cipher types are stored over multiple registers 
    448458+        * starting with SHARED_KEY_MODE_BASE each word will have 
    449 +        * 32 bits and contains the cipher types for 2 modes each. 
     459+        * 32 bits and contains the cipher types for 2 bssidx each. 
    450460+        * Using the correct defines correctly will cause overhead, 
    451461+        * so just calculate the correct offset. 
    452462+        */ 
    453 +       mask = key->hw_key_idx % 8; 
    454 +       field.bit_offset = (3 * mask); 
     463+       field.bit_offset = (4 * key->keyidx); 
    455464+       field.bit_mask = 0x7 << field.bit_offset; 
    456465+ 
    457466+       offset = SHARED_KEY_MODE_ENTRY(key->hw_key_idx / 8); 
     467+ 
    458468+       rt2x00usb_register_read(rt2x00dev, offset, &reg); 
    459469+       rt2x00_set_field32(&reg, field, 
    460 +                          (crypto->cmd == SET_KEY) ? crypto->cipher : 0); 
     470+                          (crypto->cmd == SET_KEY) * crypto->cipher); 
    461471+       rt2x00usb_register_write(rt2x00dev, offset, reg); 
    462472+ 
     
    477487+       u32 offset; 
    478488+ 
    479 +       /* 
    480 +        * 1 pairwise key is possible per AID, this means that the AID 
    481 +        * equals our hw_key_idx. 
    482 +        */ 
    483 +       key->hw_key_idx = crypto->aid; 
    484 + 
    485489+       if (crypto->cmd == SET_KEY) { 
     490+               /* 
     491+                * 1 pairwise key is possible per AID, this means that the AID 
     492+                * equals our hw_key_idx. 
     493+                */ 
     494+               key->hw_key_idx = crypto->aid; 
     495+ 
    486496+               memcpy(key_entry.key, crypto->key, 
    487497+                      sizeof(key_entry.key)); 
     
    498508+                                                   sizeof(key_entry), 
    499509+                                                   timeout); 
    500 + 
    501 +               /* 
    502 +                * The driver does not support the IV/EIV generation 
    503 +                * in hardware. However it doesn't support the IV/EIV 
    504 +                * inside the ieee80211 frame either, but requires it 
    505 +                * to be provided seperately for the descriptor. 
    506 +                * rt2x00lib will cut the IV/EIV data out of all frames 
    507 +                * given to us by mac80211, but we must tell mac80211 
    508 +                * to generate the IV/EIV data. 
    509 +                */ 
    510 +               key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 
    511510+       } 
    512511+ 
     
    556555+                          !(filter_flags & FIF_CONTROL)); 
    557556+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BA, 1); 
    558 +       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BAR, 1); 
     557+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_BAR, 0); 
    559558+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_CNTL, 
    560559+                          !(filter_flags & FIF_CONTROL)); 
     
    617616+       rt2x00usb_register_read(rt2x00dev, TX_TIMEOUT_CFG, &reg); 
    618617+       rt2x00_set_field32(&reg, TX_TIMEOUT_CFG_RX_ACK_TIMEOUT, 
    619 +                          erp->ack_timeout); 
     618+                          DIV_ROUND_UP(erp->ack_timeout, erp->slot_time)); 
    620619+       rt2x00usb_register_write(rt2x00dev, TX_TIMEOUT_CFG, reg); 
    621620+ 
     
    634633+       rt2x00usb_register_write(rt2x00dev, LEGACY_BASIC_RATE, 
    635634+                                erp->basic_rates); 
    636 +       rt2x00usb_register_write(rt2x00dev, HT_BASIC_RATE, 
    637 +                                erp->basic_rates >> 32); 
     635+       rt2x00usb_register_write(rt2x00dev, HT_BASIC_RATE, 0x00008003); 
    638636+ 
    639637+       rt2x00usb_register_read(rt2x00dev, BKOFF_SLOT_CFG, &reg); 
     
    10681066+       rt2x00usb_register_read(rt2x00dev, RX_STA_CNT0, &reg); 
    10691067+       qual->rx_failed = rt2x00_get_field32(reg, RX_STA_CNT0_CRC_ERR); 
    1070 + 
    1071 +       /* 
    1072 +        * Update False CCA count from register. 
    1073 +        */ 
    1074 +       rt2x00usb_register_read(rt2x00dev, RX_STA_CNT1, &reg); 
    1075 +       qual->false_cca = rt2x00_get_field32(reg, RX_STA_CNT1_FALSE_CCA); 
    10761068+} 
    10771069+ 
     
    11301122+} 
    11311123+ 
    1132 +static u16 rt2800usb_get_firmware_crc(const void *data, const size_t len) 
    1133 +{ 
     1124+static bool rt2800usb_check_crc(const u8 *data, const size_t len) 
     1125+{ 
     1126+       u16 fw_crc; 
    11341127+       u16 crc; 
     1128+ 
     1129+       /* 
     1130+        * The last 2 bytes in the firmware array are the crc checksum itself, 
     1131+        * this means that we should never pass those 2 bytes to the crc 
     1132+        * algorithm. 
     1133+        */ 
     1134+       fw_crc = (data[len - 2] << 8 | data[len - 1]); 
    11351135+ 
    11361136+       /* 
     
    11401140+        * before input input as well as on the final output. 
    11411141+        * Obviously using crc ccitt directly is much more efficient. 
    1142 +        * The last 2 bytes in the firmware array are the crc checksum itself, 
    1143 +        * this means that we should never pass those 2 bytes to the crc 
    1144 +        * algorithm. 
    11451142+        */ 
    11461143+       crc = crc_ccitt(~0, data, len - 2); 
     
    11521149+        * value. 
    11531150+        */ 
    1154 +       return swab16(crc); 
    1155 +} 
    1156 + 
    1157 +static int rt2800usb_load_firmware(struct rt2x00_dev *rt2x00dev, 
    1158 +                                  const void *data, const size_t len) 
    1159 +{ 
    1160 +       unsigned int i; 
    1161 +       int status; 
    1162 +       u32 reg; 
    1163 +       u32 offset; 
    1164 +       u32 length; 
     1151+       crc = swab16(crc); 
     1152+ 
     1153+       return fw_crc == crc; 
     1154+} 
     1155+ 
     1156+static int rt2800usb_check_firmware(struct rt2x00_dev *rt2x00dev, 
     1157+                                   const u8 *data, const size_t len) 
     1158+{ 
    11651159+       u16 chipset = (rt2x00_rev(&rt2x00dev->chip) >> 16) & 0xffff; 
     1160+       size_t offset = 0; 
    11661161+ 
    11671162+       /* 
     
    11741169+        * but the second blob is for the additional chipsets. 
    11751170+        */ 
    1176 +       if (len != 4096 && len != 8192) { 
    1177 +               ERROR(rt2x00dev, "Invalid firmware file length (len=%zu)\n", len); 
    1178 +               return -ENOENT; 
    1179 +       } 
    1180 + 
     1171+       if (len != 4096 && len != 8192) 
     1172+               return FW_BAD_LENGTH; 
     1173+ 
     1174+       /* 
     1175+        * Check if we need the upper 4kb firmware data or not. 
     1176+        */ 
     1177+       if ((len == 4096) && 
     1178+           (chipset != 0x2860) && 
     1179+           (chipset != 0x2872) && 
     1180+           (chipset != 0x3070)) 
     1181+               return FW_BAD_VERSION; 
     1182+ 
     1183+       /* 
     1184+        * 8kb firmware files must be checked as if it were 
     1185+        * 2 seperate firmware files. 
     1186+        */ 
     1187+       while (offset < len) { 
     1188+               if (!rt2800usb_check_crc(data + offset, 4096)) 
     1189+                       return FW_BAD_CRC; 
     1190+ 
     1191+               offset += 4096; 
     1192+       } 
     1193+ 
     1194+       return FW_OK; 
     1195+} 
     1196+ 
     1197+static int rt2800usb_load_firmware(struct rt2x00_dev *rt2x00dev, 
     1198+                                  const u8 *data, const size_t len) 
     1199+{ 
     1200+       unsigned int i; 
     1201+       int status; 
     1202+       u32 reg; 
     1203+       u32 offset; 
     1204+       u32 length; 
     1205+       u16 chipset = (rt2x00_rev(&rt2x00dev->chip) >> 16) & 0xffff; 
     1206+ 
     1207+       /* 
     1208+        * Check which section of the firmware we need. 
     1209+        */ 
    11811210+       if ((chipset == 0x2860) || (chipset == 0x2872) || (chipset == 0x3070)) { 
    11821211+               offset = 0; 
    11831212+               length = 4096; 
    1184 +       } else if (len == 8192) { 
     1213+       } else { 
    11851214+               offset = 4096; 
    11861215+               length = 4096; 
    1187 +       } else { 
    1188 +               ERROR(rt2x00dev, 
    1189 +                     "Current firmware does not support detected chipset %04x.\n", 
    1190 +                     chipset); 
    1191 +               ERROR(rt2x00dev, 
    1192 +                     "Please upgrade to a more recent firmware version.\n"); 
    1193 +               return -ENOENT; 
    11941216+       } 
    11951217+ 
     
    13291351+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG2, 0x00000000); 
    13301352+       } else { 
    1331 +               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG0, 0x00040a06); 
     1353+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG0, 0x00000000); 
    13321354+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606); 
    13331355+       } 
     
    13711393+ 
    13721394+       rt2x00usb_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
    1373 +       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_RATE, 3); 
     1395+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_RATE, 8); 
    13741396+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_CTRL, 0); 
    13751397+       rt2x00_set_field32(&reg, CCK_PROT_CFG_PROTECT_NAV, 1); 
     
    13771399+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
    13781400+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
    1379 +       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1401+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_MM40, 1); 
    13801402+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    13811403+       rt2x00_set_field32(&reg, CCK_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     
    13831405+ 
    13841406+       rt2x00usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
    1385 +       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_RATE, 3); 
     1407+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_RATE, 8); 
    13861408+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_CTRL, 0); 
    13871409+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_PROTECT_NAV, 1); 
     
    13891411+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_OFDM, 1); 
    13901412+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM20, 1); 
    1391 +       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM40, 0); 
     1413+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_MM40, 1); 
    13921414+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF20, 1); 
    13931415+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_TX_OP_ALLOW_GF40, 1); 
     
    15271549+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS0FBK, 8); 
    15281550+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS1FBK, 8); 
    1529 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS2FBK, 10); 
    1530 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS3FBK, 11); 
    1531 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS4FBK, 12); 
    1532 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS5FBK, 13); 
    1533 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS6FBK, 14); 
    1534 +       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS7FBK, 15); 
     1551+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS2FBK, 3); 
     1552+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS3FBK, 10); 
     1553+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS4FBK, 11); 
     1554+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS5FBK, 12); 
     1555+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS6FBK, 13); 
     1556+       rt2x00_set_field32(&reg, LG_FBK_CFG0_OFDMMCS7FBK, 14); 
    15351557+       rt2x00usb_register_write(rt2x00dev, LG_FBK_CFG0, reg); 
    15361558+ 
     
    19611983+       struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb); 
    19621984+       __le32 *txi = skbdesc->desc; 
    1963 +       __le32 *txwi = txi + TXINFO_DESC_SIZE; 
     1985+       __le32 *txwi = &txi[TXINFO_DESC_SIZE / sizeof(__le32)]; 
    19641986+       u32 word; 
    19651987+ 
     
    19691991+       rt2x00_desc_read(txwi, 0, &word); 
    19701992+       rt2x00_set_field32(&word, TXWI_W0_FRAG, 
    1971 +                          test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags) || 
    19721993+                          test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags)); 
    19731994+       rt2x00_set_field32(&word, TXWI_W0_MIMO_PS, 0); 
     
    20102031+       rt2x00_desc_read(txi, 0, &word); 
    20112032+       rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN, 
    2012 +                          roundup(skb->len + TXWI_DESC_SIZE, 4)); 
     2033+                          skb->len + TXWI_DESC_SIZE); 
    20132034+       rt2x00_set_field32(&word, TXINFO_W0_WIV, 1); 
    20142035+       rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2); 
     
    20682089+ 
    20692090+       /* 
    2070 +        * The length _must_ be a multiple of 4, 
     2091+        * The length _must_ include 4 bytes padding, 
     2092+        * it should always be multiple of 4, 
    20712093+        * but it must _not_ be a multiple of the USB packet size. 
    20722094+        */ 
    2073 +       length = roundup(entry->skb->len, 4); 
     2095+       length = roundup(entry->skb->len + 4, 4); 
    20742096+       length += (4 * !(length % entry->queue->usb_maxpacket)); 
    20752097+ 
     
    21052127+       struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); 
    21062128+       __le32 *rxd = (__le32 *)entry->skb->data; 
    2107 +       __le32 *rxwi = (__le32 *)(entry->skb->data + skbdesc->desc_len); 
     2129+       __le32 *rxwi; 
    21082130+       u32 rxd0; 
    21092131+       u32 rxwi0; 
     
    21182140+       memcpy(skbdesc->desc, rxd, skbdesc->desc_len); 
    21192141+       rxd = (__le32 *)skbdesc->desc; 
     2142+       rxwi = &rxd[RXD_DESC_SIZE / sizeof(__le32)]; 
    21202143+ 
    21212144+       /* 
     
    21812204+       rxdesc->rssi = 
    21822205+           (rt2x00_get_field32(rxwi2, RXWI_W2_RSSI0) + 
    2183 +            rt2x00_get_field32(rxwi2, RXWI_W2_RSSI1) + 
    2184 +            rt2x00_get_field32(rxwi2, RXWI_W2_RSSI2)) / 3; 
     2206+            rt2x00_get_field32(rxwi2, RXWI_W2_RSSI1)) / 2; 
    21852207+ 
    21862208+       rxdesc->noise = 
     
    21932215+        * Remove RXWI descriptor from start of buffer. 
    21942216+        */ 
    2195 +       skb_pull(entry->skb, RXWI_DESC_SIZE + skbdesc->desc_len); 
     2217+       skb_pull(entry->skb, skbdesc->desc_len); 
    21962218+       skb_trim(entry->skb, rxdesc->size); 
    21972219+} 
     
    27522774+       .probe_hw               = rt2800usb_probe_hw, 
    27532775+       .get_firmware_name      = rt2800usb_get_firmware_name, 
    2754 +       .get_firmware_crc       = rt2800usb_get_firmware_crc, 
     2776+       .check_firmware         = rt2800usb_check_firmware, 
    27552777+       .load_firmware          = rt2800usb_load_firmware, 
    27562778+       .initialize             = rt2x00usb_initialize, 
     
    27672789+       .get_tx_data_len        = rt2800usb_get_tx_data_len, 
    27682790+       .kick_tx_queue          = rt2800usb_kick_tx_queue, 
     2791+       .kill_tx_queue          = rt2x00usb_kill_tx_queue, 
    27692792+       .fill_rxdone            = rt2800usb_fill_rxdone, 
    27702793+       .config_shared_key      = rt2800usb_config_shared_key, 
     
    27802803+       .entry_num              = RX_ENTRIES, 
    27812804+       .data_size              = DATA_FRAME_SIZE, 
    2782 +       .desc_size              = RXD_DESC_SIZE, 
     2805+       .desc_size              = RXD_DESC_SIZE + RXWI_DESC_SIZE, 
    27832806+       .priv_size              = sizeof(struct queue_entry_priv_usb), 
    27842807+}; 
     
    29382961--- /dev/null 
    29392962+++ b/drivers/net/wireless/rt2x00/rt2800usb.h 
    2940 @@ -0,0 +1,1944 @@ 
     2963@@ -0,0 +1,1940 @@ 
    29412964+/* 
    29422965+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
     
    42404263+ 
    42414264+/* 
    4242 + * Security key table memory, base address = 0x1800 
    4243 + */ 
    4244 +struct hw_pairwise_ta_entry { 
    4245 +       u8 address[6]; 
     4265+ * Security key table memory. 
     4266+ * MAC_WCID_BASE: 8-bytes (use only 6 bytes) * 256 entry 
     4267+ * PAIRWISE_KEY_TABLE_BASE: 32-byte * 256 entry 
     4268+ * MAC_IVEIV_TABLE_BASE: 8-byte * 256-entry 
     4269+ * MAC_WCID_ATTRIBUTE_BASE: 4-byte * 256-entry 
     4270+ * SHARED_KEY_TABLE_BASE: 32-byte * 16-entry 
     4271+ * SHARED_KEY_MODE_BASE: 4-byte * 16-entry 
     4272+ */ 
     4273+#define MAC_WCID_BASE                  0x1800 
     4274+#define PAIRWISE_KEY_TABLE_BASE                0x4000 
     4275+#define MAC_IVEIV_TABLE_BASE           0x6000 
     4276+#define MAC_WCID_ATTRIBUTE_BASE                0x6800 
     4277+#define SHARED_KEY_TABLE_BASE          0x6c00 
     4278+#define SHARED_KEY_MODE_BASE           0x7000 
     4279+ 
     4280+#define MAC_WCID_ENTRY(__idx) \ 
     4281+       ( MAC_WCID_BASE + ((__idx) * sizeof(struct mac_wcid_entry)) ) 
     4282+#define PAIRWISE_KEY_ENTRY(__idx) \ 
     4283+       ( PAIRWISE_KEY_TABLE_BASE + ((__idx) * sizeof(struct hw_key_entry)) ) 
     4284+#define MAC_IVEIV_ENTRY(__idx) \ 
     4285+       ( MAC_IVEIV_TABLE_BASE + ((__idx) & sizeof(struct mac_iveiv_entry)) ) 
     4286+#define MAC_WCID_ATTR_ENTRY(__idx) \ 
     4287+       ( MAC_WCID_ATTRIBUTE_BASE + ((__idx) * sizeof(u32)) ) 
     4288+#define SHARED_KEY_ENTRY(__idx) \ 
     4289+       ( SHARED_KEY_TABLE_BASE + ((__idx) * sizeof(struct hw_key_entry)) ) 
     4290+#define SHARED_KEY_MODE_ENTRY(__idx) \ 
     4291+       ( SHARED_KEY_MODE_BASE + ((__idx) * sizeof(u32)) ) 
     4292+ 
     4293+struct mac_wcid_entry { 
     4294+       u8 mac[6]; 
    42464295+       u8 reserved[2]; 
    4247 +} __attribute__ ((packed)); 
    4248 + 
    4249 +struct wcid_entry { 
    4250 +       u8 rx_ba_bitmat7; 
    4251 +       u8 rx_ba_bitmat0; 
    4252 +       u8 mac[6]; 
    42534296+} __attribute__ ((packed)); 
    42544297+ 
     
    42594302+} __attribute__ ((packed)); 
    42604303+ 
    4261 +/* 
    4262 + * Security key table memory. 
    4263 + * MAC_WCID_BASE: 8-bytes (use only 6 bytes) * 256 entry 
    4264 + * PAIRWISE_KEY_TABLE_BASE: 32-byte * 256 entry 
    4265 + * PAIRWISE_IVEIV_TABLE_BASE: 8-byte * 256-entry 
    4266 + * MAC_IVEIV_TABLE_BASE: 8-byte * 256-entry 
    4267 + * MAC_WCID_ATTRIBUTE_BASE: 4-byte * 256-entry 
    4268 + * SHARED_KEY_TABLE_BASE: 32-byte * 16-entry 
    4269 + * SHARED_KEY_MODE_BASE: 32-byte * 16-entry 
    4270 + */ 
    4271 +#define MAC_WCID_BASE                  0x1800 
    4272 +#define PAIRWISE_KEY_TABLE_BASE                0x4000 
    4273 +#define PAIRWISE_IVEIV_TABLE_BASE      0x6000 
    4274 +#define MAC_IVEIV_TABLE_BASE           0x6000 
    4275 +#define MAC_WCID_ATTRIBUTE_BASE                0x6800 
    4276 +#define SHARED_KEY_TABLE_BASE          0x6c00 
    4277 +#define SHARED_KEY_MODE_BASE           0x7000 
    4278 + 
    4279 +#define SHARED_KEY_ENTRY(__idx) \ 
    4280 +       ( SHARED_KEY_TABLE_BASE + \ 
    4281 +               ((__idx) * sizeof(struct hw_key_entry)) ) 
    4282 +#define SHARED_KEY_MODE_ENTRY(__idx) \ 
    4283 +       ( SHARED_KEY_MODE_BASE + ((__idx) * sizeof(u32)) ) 
    4284 +#define PAIRWISE_KEY_ENTRY(__idx) \ 
    4285 +       ( PAIRWISE_KEY_TABLE_BASE + \ 
    4286 +               ((__idx) * sizeof(struct hw_key_entry)) ) 
    4287 + 
    4288 +#define MAC_WCID_ENTRY(__idx) \ 
    4289 +       ( MAC_WCID_BASE + (2 * sizeof(u32) * (__idx)) ) 
    4290 +#define MAC_WCID_ATTR_ENTRY(__idx) \ 
    4291 +       ( MAC_WCID_ATTRIBUTE_BASE + ((__idx) * sizeof(u32)) ) 
     4304+struct mac_iveiv_entry { 
     4305+       u8 iv[8]; 
     4306+} __attribute__ ((packed)); 
     4307+ 
     4308+/* 
     4309+ * MAC_IVEIV: 
     4310+ */ 
     4311+#define MAC_IVEIV_EIV                  FIELD32(0x20000000) 
     4312+#define MAC_IVEIV_KEYIDX               FIELD32(0xc0000000) 
    42924313+ 
    42934314+/* 
    42944315+ * MAC_WCID_ATTRIBUTE: 
    4295 + * KEYTAB: 0: shared key table, 1: pairwise key table 
    4296 + * BSS_IDX: multipleBSS index for the WCID 
    42974316+ */ 
    42984317+#define MAC_WCID_ATTRIBUTE_KEYTAB      FIELD32(0x00000001) 
    4299 +#define MAC_WCID_ATTRIBUTE_PAIRKEY_MODE        FIELD32(0x0000000e) 
     4318+#define MAC_WCID_ATTRIBUTE_CIPHER      FIELD32(0x0000000e) 
    43004319+#define MAC_WCID_ATTRIBUTE_BSS_IDX     FIELD32(0x00000070) 
    43014320+#define MAC_WCID_ATTRIBUTE_RX_WIUDF    FIELD32(0x00000380) 
     
    48854904--- a/drivers/net/wireless/rt2x00/rt2x00.h 
    48864905+++ b/drivers/net/wireless/rt2x00/rt2x00.h 
    4887 @@ -143,6 +143,7 @@ struct rt2x00_chip { 
     4906@@ -142,6 +142,7 @@ struct rt2x00_chip { 
    48884907 #define RT2860D                0x0681  /* 2.4GHz, 5GHz PCI/CB */ 
    48894908 #define RT2890         0x0701  /* 2.4GHz PCIe */ 
     
    48934912        u16 rf; 
    48944913        u32 rev; 
    4895 @@ -778,6 +779,12 @@ struct rt2x00_dev { 
     4914@@ -780,6 +781,12 @@ struct rt2x00_dev { 
    48964915        u8 freq_offset; 
    48974916  
  • trunk/package/mac80211/patches/401-ath9k-dont-register-leds-on-ar9100.patch

    r14331 r14434  
    11--- a/drivers/net/wireless/ath9k/main.c 
    22+++ b/drivers/net/wireless/ath9k/main.c 
    3 @@ -989,6 +989,9 @@ static void ath_unregister_led(struct at 
     3@@ -1026,6 +1026,9 @@ static void ath_unregister_led(struct at 
    44  
    55 static void ath_deinit_leds(struct ath_softc *sc) 
     
    88+               return; 
    99+ 
     10        cancel_delayed_work_sync(&sc->ath_led_blink_work); 
    1011        ath_unregister_led(&sc->assoc_led); 
    1112        sc->sc_flags &= ~SC_OP_LED_ASSOCIATED; 
    12         ath_unregister_led(&sc->tx_led); 
    13 @@ -1002,6 +1005,9 @@ static void ath_init_leds(struct ath_sof 
     13@@ -1040,6 +1043,9 @@ static void ath_init_leds(struct ath_sof 
    1414        char *trigger; 
    1515        int ret; 
  • trunk/package/mac80211/patches/402-ath9k-enable-debug.patch

    r14334 r14434  
    11--- a/config.mk 
    22+++ b/config.mk 
    3 @@ -95,7 +95,7 @@ ifneq ($(CONFIG_PCI),) 
     3@@ -98,7 +98,7 @@ ifneq ($(CONFIG_PCI),) 
    44 CONFIG_ATH5K=m 
    55 # CONFIG_ATH5K_DEBUG is not set 
Note: See TracChangeset for help on using the changeset viewer.