Ignore:
Timestamp:
2009-03-05T13:49:25+01:00 (7 years ago)
Author:
juhosg
Message:

[package] mac80211: update compat-wireless to 2009-03-04, and refresh patches

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/mac80211/patches/303-rt2x00-Implement-support-for-rt2800usb.patch

    r14605 r14749  
    1 From 1d21decc7ccd8b7c2a280a4d15bda08883a03b2c Mon Sep 17 00:00:00 2001 
     1From b249bc450f982cd2491448c91faf797ed37b69b8 Mon Sep 17 00:00:00 2001 
    22From: Ivo van Doorn <IvDoorn@gmail.com> 
    3 Date: Wed, 4 Feb 2009 20:45:56 +0100 
     3Date: Tue, 3 Mar 2009 19:25:49 +0100 
    44Subject: [PATCH] rt2x00: Implement support for rt2800usb 
    55 
    66Add support for the rt2800usb chipset. 
    77 
    8 Includes various patches from Mattias and Felix. 
     8Includes various patches from Mattias, Felix, Xose and Axel. 
    99 
    1010Signed-off-by: Mattias Nissler <mattias.nissler@gmx.de> 
    1111Signed-off-by: Felix Fietkau <nbd@openwrt.org> 
     12Signed-off-by: Xose Vazquez Perez <xose.vazquez@gmail.com> 
     13Signed-off-by: Axel Kollhofer <rain_maker@root-forum.org> 
    1214Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com> 
    1315--- 
    1416 drivers/net/wireless/rt2x00/Kconfig     |   14 + 
    1517 drivers/net/wireless/rt2x00/Makefile    |    1 + 
    16  drivers/net/wireless/rt2x00/rt2800usb.c | 2928 +++++++++++++++++++++++++++++++ 
    17  drivers/net/wireless/rt2x00/rt2800usb.h | 1940 ++++++++++++++++++++ 
     18 drivers/net/wireless/rt2x00/rt2800usb.c | 3032 +++++++++++++++++++++++++++++++ 
     19 drivers/net/wireless/rt2x00/rt2800usb.h | 1932 ++++++++++++++++++++ 
    1820 drivers/net/wireless/rt2x00/rt2x00.h    |    7 + 
    19  5 files changed, 4890 insertions(+), 0 deletions(-) 
     21 5 files changed, 4986 insertions(+), 0 deletions(-) 
    2022 create mode 100644 drivers/net/wireless/rt2x00/rt2800usb.c 
    2123 create mode 100644 drivers/net/wireless/rt2x00/rt2800usb.h 
    2224 
     25 config RT2X00_LIB_PCI 
     26        tristate 
     27        select RT2X00_LIB 
    2328--- a/drivers/net/wireless/rt2x00/Makefile 
    2429+++ b/drivers/net/wireless/rt2x00/Makefile 
     
    3035--- /dev/null 
    3136+++ b/drivers/net/wireless/rt2x00/rt2800usb.c 
    32 @@ -0,0 +1,2928 @@ 
     37@@ -0,0 +1,3032 @@ 
    3338+/* 
    3439+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
     
    214219+{ 
    215220+       u32 reg; 
    216 + 
    217 +       if (!word) 
    218 +               return; 
    219221+ 
    220222+       mutex_lock(&rt2x00dev->csr_mutex); 
     
    394396+       u32 reg; 
    395397+ 
    396 +       offset = MAC_WCID_ATTR_ENTRY(crypto->aid); 
     398+       offset = MAC_WCID_ATTR_ENTRY(key->hw_key_idx); 
    397399+ 
    398400+       rt2x00usb_register_read(rt2x00dev, offset, &reg); 
     
    405407+       rt2x00usb_register_write(rt2x00dev, offset, reg); 
    406408+ 
    407 +       offset = MAC_IVEIV_ENTRY(crypto->aid); 
     409+       offset = MAC_IVEIV_ENTRY(key->hw_key_idx); 
    408410+ 
    409411+       memset(&iveiv_entry, 0, sizeof(iveiv_entry)); 
     
    416418+                                     &iveiv_entry, sizeof(iveiv_entry)); 
    417419+ 
    418 +       offset = MAC_WCID_ENTRY(crypto->aid); 
     420+       offset = MAC_WCID_ENTRY(key->hw_key_idx); 
    419421+ 
    420422+       memset(&wcid_entry, 0, sizeof(wcid_entry)); 
     
    461463+        * so just calculate the correct offset. 
    462464+        */ 
    463 +       field.bit_offset = (4 * key->keyidx); 
     465+       field.bit_offset = (4 * key->keyidx) + (16 * (crypto->bssidx & 1)); 
    464466+       field.bit_mask = 0x7 << field.bit_offset; 
    465467+ 
    466 +       offset = SHARED_KEY_MODE_ENTRY(key->hw_key_idx / 8); 
     468+       offset = SHARED_KEY_MODE_ENTRY(key->hw_key_idx / 2); 
    467469+ 
    468470+       rt2x00usb_register_read(rt2x00dev, offset, &reg); 
     
    671673+       case 1: 
    672674+               rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 0); 
    673 +               rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 0); 
    674675+               break; 
    675676+       case 2: 
    676 +               rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 16); 
     677+               rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 2); 
    677678+               break; 
    678679+       case 3: 
     
    724725+ 
    725726+static void rt2800usb_config_channel_rt2x(struct rt2x00_dev *rt2x00dev, 
     727+                                         struct ieee80211_conf *conf, 
    726728+                                         struct rf_channel *rf, 
    727729+                                         struct channel_info *info) 
     
    735737+        */ 
    736738+       rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
     739+ 
    737740+       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) == 1) 
    738741+               rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_TX1, 1); 
     
    775778+       } 
    776779+ 
    777 +       rt2x00_set_field32(&rf->rf4, RF4_BW40, 
    778 +                          test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags)); 
     780+       rt2x00_set_field32(&rf->rf4, RF4_HT40, conf_is_ht40(conf)); 
    779781+ 
    780782+       rt2800usb_rf_write(rt2x00dev, 1, rf->rf1); 
     
    799801+ 
    800802+static void rt2800usb_config_channel_rt3x(struct rt2x00_dev *rt2x00dev, 
     803+                                         struct ieee80211_conf *conf, 
    801804+                                         struct rf_channel *rf, 
    802805+                                         struct channel_info *info) 
     
    820823+       rt2800usb_rfcsr_write(rt2x00dev, 23, rfcsr); 
    821824+ 
    822 +       if (test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags)) 
    823 +               rt2800usb_rfcsr_write(rt2x00dev, 24, rt2x00dev->calibration_bw40); 
     825+       if (conf_is_ht40(conf)) 
     826+               rt2800usb_rfcsr_write(rt2x00dev, 24, 
     827+                                     rt2x00dev->calibration_bw40); 
    824828+       else 
    825 +               rt2800usb_rfcsr_write(rt2x00dev, 24, rt2x00dev->calibration_bw20); 
     829+               rt2800usb_rfcsr_write(rt2x00dev, 24, 
     830+                                     rt2x00dev->calibration_bw20); 
    826831+ 
    827832+       rt2800usb_rfcsr_read(rt2x00dev, 23, &rfcsr); 
     
    831836+ 
    832837+static void rt2800usb_config_channel(struct rt2x00_dev *rt2x00dev, 
     838+                                    struct ieee80211_conf *conf, 
    833839+                                    struct rf_channel *rf, 
    834840+                                    struct channel_info *info) 
     
    837843+       unsigned int tx_pin; 
    838844+       u16 eeprom; 
     845+       u8 bbp; 
     846+ 
     847+       /* 
     848+        * Determine antenna settings from EEPROM 
     849+        */ 
     850+       rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
    839851+ 
    840852+       if (rt2x00_rev(&rt2x00dev->chip) != RT3070_VERSION) 
    841 +               rt2800usb_config_channel_rt2x(rt2x00dev, rf, info); 
     853+               rt2800usb_config_channel_rt2x(rt2x00dev, conf, rf, info); 
    842854+       else 
    843 +               rt2800usb_config_channel_rt3x(rt2x00dev, rf, info); 
    844 + 
    845 +       tx_pin = 0; 
    846 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 1); 
    847 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A0_EN, 1); 
    848 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G0_EN, 1); 
    849 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 1); 
    850 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 1); 
    851 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_RFTR_EN, 1); 
    852 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_TRSW_EN, 1); 
    853 + 
    854 +       rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
    855 + 
    856 +       /* Turn off unused PA or LNA when only 1T or 1R */ 
    857 +       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) == 1) { 
    858 +                
    859 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A1_EN, 0); 
    860 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 0); 
    861 +       } 
    862 + 
    863 +       /* Turn off unused PA or LNA when only 1T or 1R */ 
    864 +       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH) == 1) { 
    865 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 0); 
    866 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 0); 
    867 +       } 
    868 + 
    869 +       if (rf->channel > 14) 
    870 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A0_EN, 1); 
    871 +       else 
    872 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN, 1); 
     855+               rt2800usb_config_channel_rt3x(rt2x00dev, conf, rf, info); 
    873856+ 
    874857+       /* 
     
    888871+                       rt2800usb_bbp_write(rt2x00dev, 75, 0x50); 
    889872+               } 
    890 + 
    891 +               rt2x00usb_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
    892 +               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_A, 0); 
    893 +               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_BG, 1); 
    894 +               rt2x00usb_register_write(rt2x00dev, TX_BAND_CFG, reg); 
    895873+       } else { 
    896874+               rt2800usb_bbp_write(rt2x00dev, 82, 0xf2); 
     
    900878+               else 
    901879+                       rt2800usb_bbp_write(rt2x00dev, 75, 0x50); 
    902 + 
    903 +               rt2x00usb_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
    904 +               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_A, 1); 
    905 +               rt2x00_set_field32(&rf->rf3, TX_BAND_CFG_BG, 0); 
    906 +               rt2x00usb_register_write(rt2x00dev, TX_BAND_CFG, reg); 
    907 +       } 
     880+       } 
     881+ 
     882+       rt2x00usb_register_read(rt2x00dev, TX_BAND_CFG, &reg); 
     883+       rt2x00_set_field32(&reg, TX_BAND_CFG_HT40_PLUS, conf_is_ht40_plus(conf)); 
     884+       rt2x00_set_field32(&reg, TX_BAND_CFG_A, rf->channel > 14); 
     885+       rt2x00_set_field32(&reg, TX_BAND_CFG_BG, rf->channel <= 14); 
     886+       rt2x00usb_register_write(rt2x00dev, TX_BAND_CFG, reg); 
     887+ 
     888+       tx_pin = 0; 
     889+ 
     890+       /* Turn on unused PA or LNA when not using 1T or 1R */ 
     891+       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) != 1) { 
     892+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A1_EN, 1); 
     893+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 1); 
     894+       } 
     895+ 
     896+       /* Turn on unused PA or LNA when not using 1T or 1R */ 
     897+       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH) != 1) { 
     898+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 1); 
     899+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 1); 
     900+       } 
     901+ 
     902+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A0_EN, 1); 
     903+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G0_EN, 1); 
     904+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_RFTR_EN, 1); 
     905+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_TRSW_EN, 1); 
     906+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN, rf->channel <= 14); 
     907+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A0_EN, rf->channel > 14); 
    908908+ 
    909909+       rt2x00usb_register_write(rt2x00dev, TX_PIN_CFG, tx_pin); 
     910+ 
     911+       rt2800usb_bbp_read(rt2x00dev, 4, &bbp); 
     912+       rt2x00_set_field8(&bbp, BBP4_BANDWIDTH, 2 * conf_is_ht40(conf)); 
     913+       rt2800usb_bbp_write(rt2x00dev, 4, bbp); 
     914+ 
     915+       rt2800usb_bbp_read(rt2x00dev, 3, &bbp); 
     916+       rt2x00_set_field8(&bbp, BBP3_HT40_PLUS, conf_is_ht40_plus(conf)); 
     917+       rt2800usb_bbp_write(rt2x00dev, 3, bbp); 
     918+ 
     919+       if (rt2x00_rev(&rt2x00dev->chip) == RT2860C_VERSION) { 
     920+               if (conf_is_ht40(conf)) { 
     921+                       rt2800usb_bbp_write(rt2x00dev, 69, 0x1a); 
     922+                       rt2800usb_bbp_write(rt2x00dev, 70, 0x0a); 
     923+                       rt2800usb_bbp_write(rt2x00dev, 73, 0x16); 
     924+               } else { 
     925+                       rt2800usb_bbp_write(rt2x00dev, 69, 0x16); 
     926+                       rt2800usb_bbp_write(rt2x00dev, 70, 0x08); 
     927+                       rt2800usb_bbp_write(rt2x00dev, 73, 0x11); 
     928+               } 
     929+       } 
    910930+ 
    911931+       msleep(1); 
     
    10411061+ 
    10421062+       if (flags & IEEE80211_CONF_CHANGE_CHANNEL) 
    1043 +               rt2800usb_config_channel(rt2x00dev, &libconf->rf, 
    1044 +                                        &libconf->channel); 
     1063+               rt2800usb_config_channel(rt2x00dev, libconf->conf, 
     1064+                                        &libconf->rf, &libconf->channel); 
    10451065+       if (flags & IEEE80211_CONF_CHANGE_POWER) 
    10461066+               rt2800usb_config_txpower(rt2x00dev, libconf->conf->power_level); 
     
    14831503+       rt2x00usb_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
    14841504+       rt2x00_set_field32(&reg, TX_RTS_CFG_AUTO_RTS_RETRY_LIMIT, 32); 
     1505+       rt2x00_set_field32(&reg, TX_RTS_CFG_RTS_THRES, 
     1506+                          IEEE80211_MAX_RTS_THRESHOLD); 
    14851507+       rt2x00_set_field32(&reg, TX_RTS_CFG_RTS_FBK_EN, 0); 
    14861508+       rt2x00usb_register_write(rt2x00dev, TX_RTS_CFG, reg); 
     
    14921514+        * ASIC will keep garbage value after boot, clear encryption keys. 
    14931515+        */ 
    1494 +       for (i = 0; i < 254; i++) { 
     1516+       for (i = 0; i < 256; i++) { 
    14951517+               u32 wcid[2] = { 0xffffffff, 0x00ffffff }; 
    14961518+               rt2x00usb_register_multiwrite(rt2x00dev, MAC_WCID_ENTRY(i), 
    14971519+                                             wcid, sizeof(wcid)); 
    1498 +       } 
    1499 + 
    1500 +       for (i = 0; i < 4; i++) 
     1520+ 
     1521+               rt2x00usb_register_write(rt2x00dev, MAC_WCID_ATTR_ENTRY(i), 1); 
     1522+               rt2x00usb_register_write(rt2x00dev, MAC_IVEIV_ENTRY(i), 0); 
     1523+       } 
     1524+ 
     1525+       for (i = 0; i < 16; i++) 
    15011526+               rt2x00usb_register_write(rt2x00dev, 
    15021527+                                        SHARED_KEY_MODE_ENTRY(i), 0); 
    1503 + 
    1504 +       for (i = 0; i < 256; i++) 
    1505 +               rt2x00usb_register_write(rt2x00dev, MAC_WCID_ATTR_ENTRY(i), 1); 
    15061528+ 
    15071529+       /* 
     
    16431665+       } 
    16441666+ 
     1667+       if (rt2x00_rev(&rt2x00dev->chip) > RT2860D_VERSION) { 
     1668+               rt2800usb_bbp_write(rt2x00dev, 84, 0x19); 
     1669+       } 
     1670+ 
    16451671+       if (rt2x00_rev(&rt2x00dev->chip) == RT3070_VERSION) { 
    16461672+               rt2800usb_bbp_write(rt2x00dev, 70, 0x0a); 
     
    16741700+       rt2800usb_rfcsr_write(rt2x00dev, 24, rfcsr24); 
    16751701+ 
    1676 +       if (bw40) { 
    1677 +               rt2800usb_bbp_read(rt2x00dev, 4, &bbp); 
    1678 +               rt2x00_set_field8(&bbp, BBP4_BANDWIDTH, 0x10); 
    1679 +               rt2800usb_bbp_write(rt2x00dev, 4, bbp); 
    1680 +       } 
     1702+       rt2800usb_bbp_read(rt2x00dev, 4, &bbp); 
     1703+       rt2x00_set_field8(&bbp, BBP4_BANDWIDTH, 2 * bw40); 
     1704+       rt2800usb_bbp_write(rt2x00dev, 4, bbp); 
    16811705+ 
    16821706+       rt2800usb_rfcsr_read(rt2x00dev, 22, &rfcsr); 
     
    20152039+                          test_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags)); 
    20162040+       rt2x00_set_field32(&word, TXWI_W1_BW_WIN_SIZE, txdesc->ba_size); 
    2017 +       rt2x00_set_field32(&word, TXWI_W1_WIRELESS_CLI_ID, 0xff); 
     2041+       rt2x00_set_field32(&word, TXWI_W1_WIRELESS_CLI_ID, 
     2042+                          test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags) ? 
     2043+                              txdesc->key_idx : 0xff); 
    20182044+       rt2x00_set_field32(&word, TXWI_W1_MPDU_TOTAL_BYTE_COUNT, skb->len); 
    20192045+       rt2x00_set_field32(&word, TXWI_W1_PACKETID, 
     
    20212047+       rt2x00_desc_write(txwi, 1, word); 
    20222048+ 
    2023 +       if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags)) { 
    2024 +               _rt2x00_desc_write(txwi, 2, skbdesc->iv[0]); 
    2025 +               _rt2x00_desc_write(txwi, 3, skbdesc->iv[1]); 
    2026 +       } 
     2049+       /* 
     2050+        * Always write 0 to IV/EIV fields, hardware will insert the IV 
     2051+        * from the IVEIV register when TXINFO_W0_WIV is set to 0. 
     2052+        * When TXINFO_W0_WIV is set to 1 it will use the IV data 
     2053+        * from the descriptor. The TXWI_W1_WIRELESS_CLI_ID indicates which 
     2054+        * crypto entry in the registers should be used to encrypt the frame. 
     2055+        */ 
     2056+       _rt2x00_desc_write(txwi, 2, 0 /* skbdesc->iv[0] */); 
     2057+       _rt2x00_desc_write(txwi, 3, 0 /* skbdesc->iv[1] */); 
    20272058+ 
    20282059+       /* 
     
    20322063+       rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN, 
    20332064+                          skb->len + TXWI_DESC_SIZE); 
    2034 +       rt2x00_set_field32(&word, TXINFO_W0_WIV, 1); 
     2065+       rt2x00_set_field32(&word, TXINFO_W0_WIV, 
     2066+                          !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc->flags)); 
    20352067+       rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2); 
    20362068+       rt2x00_set_field32(&word, TXINFO_W0_SW_USE_LAST_ROUND, 0); 
     
    22482280+               rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word); 
    22492281+               EEPROM(rt2x00dev, "Antenna: 0x%04x\n", word); 
     2282+       } else if (rt2x00_rev(&rt2x00dev->chip) < RT2883_VERSION) { 
     2283+               /* 
     2284+                * There is a max of 2 RX streams for RT2860 series 
     2285+                */ 
     2286+               if (rt2x00_get_field16(word, EEPROM_ANTENNA_RXPATH) > 2) 
     2287+                       rt2x00_set_field16(&word, EEPROM_ANTENNA_RXPATH, 2); 
     2288+               rt2x00_eeprom_write(rt2x00dev, EEPROM_ANTENNA, word); 
    22502289+       } 
    22512290+ 
     
    23452384+        */ 
    23462385+       if ((rt2x00_get_field32(reg, MAC_CSR0_ASIC_VER) != 0x2860) && 
    2347 +           (rt2x00_get_field32(reg, MAC_CSR0_ASIC_VER) != 0x2870)) { 
     2386+           (rt2x00_get_field32(reg, MAC_CSR0_ASIC_VER) != 0x2870) && 
     2387+           (rt2x00_get_field32(reg, MAC_CSR0_ASIC_VER) != 0x3070)) { 
    23482388+               ERROR(rt2x00dev, "Invalid RT chipset detected.\n"); 
    23492389+               return -ENODEV; 
     
    24982538+       char *tx_power2; 
    24992539+       unsigned int i; 
     2540+       u16 eeprom; 
    25002541+ 
    25012542+       /* 
     
    25132554+                               rt2x00_eeprom_addr(rt2x00dev, 
    25142555+                                                  EEPROM_MAC_ADDR_0)); 
     2556+ 
     2557+       rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
    25152558+ 
    25162559+       /* 
     
    25282571+       spec->ht.ampdu_factor = 3; 
    25292572+       spec->ht.ampdu_density = 4; 
    2530 +       spec->ht.mcs.rx_mask[0] = 0xff; 
    2531 +       spec->ht.mcs.rx_mask[1] = 0xff; 
    25322573+       spec->ht.mcs.tx_params = 
    2533 +           IEEE80211_HT_MCS_TX_DEFINED; 
     2574+           IEEE80211_HT_MCS_TX_DEFINED | 
     2575+           IEEE80211_HT_MCS_TX_RX_DIFF | 
     2576+           ((rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) - 1) << 
     2577+               IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT); 
     2578+ 
     2579+       switch (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH)) { 
     2580+       case 3: 
     2581+               spec->ht.mcs.rx_mask[2] = 0xff; 
     2582+       case 2: 
     2583+               spec->ht.mcs.rx_mask[1] = 0xff; 
     2584+       case 1: 
     2585+               spec->ht.mcs.rx_mask[0] = 0xff; 
     2586+               spec->ht.mcs.rx_mask[4] = 0x1; /* MCS32 */ 
     2587+               break; 
     2588+       } 
    25342589+ 
    25352590+       /* 
     
    26252680+ * IEEE80211 stack callback functions. 
    26262681+ */ 
     2682+static void rt2800usb_get_tkip_seq(struct ieee80211_hw *hw, u8 hw_key_idx, 
     2683+                                  u32 *iv32, u16 *iv16) 
     2684+{ 
     2685+       struct rt2x00_dev *rt2x00dev = hw->priv; 
     2686+       struct mac_iveiv_entry iveiv_entry; 
     2687+       u32 offset; 
     2688+ 
     2689+       offset = MAC_IVEIV_ENTRY(hw_key_idx); 
     2690+       rt2x00usb_register_multiread(rt2x00dev, offset, 
     2691+                                     &iveiv_entry, sizeof(iveiv_entry)); 
     2692+ 
     2693+       memcpy(&iveiv_entry.iv[0], iv16, sizeof(iv16)); 
     2694+       memcpy(&iveiv_entry.iv[4], iv32, sizeof(iv32)); 
     2695+} 
     2696+ 
    26272697+static int rt2800usb_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 
    26282698+{ 
     
    27292799+} 
    27302800+ 
    2731 +#if 0 
    2732 +/* 
    2733 + * Mac80211 demands get_tsf must be atomic. 
    2734 + * This is not possible for rt2800usb since all register access 
    2735 + * functions require sleeping. Untill mac80211 no longer needs 
    2736 + * get_tsf to be atomic, this function should be disabled. 
    2737 + */ 
    27382801+static u64 rt2800usb_get_tsf(struct ieee80211_hw *hw) 
    27392802+{ 
     
    27492812+       return tsf; 
    27502813+} 
    2751 +#else 
    2752 +#define rt2800usb_get_tsf      NULL 
    2753 +#endif 
    27542814+ 
    27552815+static const struct ieee80211_ops rt2800usb_mac80211_ops = { 
     
    27642824+       .set_key                = rt2x00mac_set_key, 
    27652825+       .get_stats              = rt2x00mac_get_stats, 
     2826+       .get_tkip_seq           = rt2800usb_get_tkip_seq, 
    27662827+       .set_rts_threshold      = rt2800usb_set_rts_threshold, 
    27672828+       .bss_info_changed       = rt2x00mac_bss_info_changed, 
     
    28022863+static const struct data_queue_desc rt2800usb_queue_rx = { 
    28032864+       .entry_num              = RX_ENTRIES, 
    2804 +       .data_size              = DATA_FRAME_SIZE, 
     2865+       .data_size              = AGGREGATION_SIZE, 
    28052866+       .desc_size              = RXD_DESC_SIZE + RXWI_DESC_SIZE, 
    28062867+       .priv_size              = sizeof(struct queue_entry_priv_usb), 
     
    28092870+static const struct data_queue_desc rt2800usb_queue_tx = { 
    28102871+       .entry_num              = TX_ENTRIES, 
    2811 +       .data_size              = DATA_FRAME_SIZE, 
     2872+       .data_size              = AGGREGATION_SIZE, 
    28122873+       .desc_size              = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, 
    28132874+       .priv_size              = sizeof(struct queue_entry_priv_usb), 
     
    28432904+static struct usb_device_id rt2800usb_device_table[] = { 
    28442905+       /* Abocom */ 
     2906+       { USB_DEVICE(0x07b8, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2907+       { USB_DEVICE(0x07b8, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28452908+       { USB_DEVICE(0x07b8, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28462909+       { USB_DEVICE(0x07b8, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    2847 +       { USB_DEVICE(0x07b8, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    2848 +       { USB_DEVICE(0x07b8, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2910+       { USB_DEVICE(0x07b8, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28492911+       { USB_DEVICE(0x1482, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2912+       /* AirTies */ 
     2913+       { USB_DEVICE(0x1eda, 0x2310), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2914+       /* Amigo */ 
     2915+       { USB_DEVICE(0x0e0b, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2916+       { USB_DEVICE(0x0e0b, 0x9041), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28502917+       /* Amit */ 
    28512918+       { USB_DEVICE(0x15c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    28542921+       { USB_DEVICE(0x0b05, 0x1732), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28552922+       { USB_DEVICE(0x0b05, 0x1742), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2923+       { USB_DEVICE(0x0b05, 0x1760), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2924+       { USB_DEVICE(0x0b05, 0x1761), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28562925+       /* AzureWave */ 
    28572926+       { USB_DEVICE(0x13d3, 0x3247), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2927+       { USB_DEVICE(0x13d3, 0x3262), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2928+       { USB_DEVICE(0x13d3, 0x3273), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28582929+       /* Belkin */ 
    28592930+       { USB_DEVICE(0x050d, 0x8053), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28602931+       { USB_DEVICE(0x050d, 0x805c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2932+       { USB_DEVICE(0x050d, 0x815c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2933+       /* Buffalo */ 
     2934+       { USB_DEVICE(0x0411, 0x012e), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28612935+       /* Conceptronic */ 
    28622936+       { USB_DEVICE(0x14b2, 0x3c06), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    28722946+       { USB_DEVICE(0x07aa, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28732947+       { USB_DEVICE(0x07aa, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2948+       { USB_DEVICE(0x18c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28742949+       { USB_DEVICE(0x18c5, 0x0012), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28752950+       /* D-Link */ 
    28762951+       { USB_DEVICE(0x07d1, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28772952+       { USB_DEVICE(0x07d1, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2953+       { USB_DEVICE(0x07d1, 0x3c13), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2954+       { USB_DEVICE(0x2001, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2955+       { USB_DEVICE(0x2001, 0x3c0a), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28782956+       /* Edimax */ 
    28792957+       { USB_DEVICE(0x7392, 0x7711), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2958+       { USB_DEVICE(0x7392, 0x7717), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2959+       { USB_DEVICE(0x7392, 0x7718), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28802960+       /* EnGenius */ 
    28812961+       { USB_DEVICE(0X1740, 0x9701), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28822962+       { USB_DEVICE(0x1740, 0x9702), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2963+       { USB_DEVICE(0x1740, 0x9703), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2964+       /* Gemtek */ 
     2965+       { USB_DEVICE(0x15a9, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28832966+       /* Gigabyte */ 
    28842967+       { USB_DEVICE(0x1044, 0x800b), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2968+       { USB_DEVICE(0x1044, 0x800c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2969+       { USB_DEVICE(0x1044, 0x800d), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28852970+       /* Hawking */ 
    28862971+       { USB_DEVICE(0x0e66, 0x0001), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28872972+       { USB_DEVICE(0x0e66, 0x0003), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2973+       { USB_DEVICE(0x0e66, 0x0009), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2974+       { USB_DEVICE(0x0e66, 0x000b), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2975+       /* LevelOne */ 
     2976+       { USB_DEVICE(0x1740, 0x0605), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2977+       { USB_DEVICE(0x1740, 0x0615), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28882978+       /* Linksys */ 
    28892979+       { USB_DEVICE(0x1737, 0x0071), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    28922982+       { USB_DEVICE(0x0789, 0x0163), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28932983+       { USB_DEVICE(0x0789, 0x0164), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2984+       /* Pegatron */ 
     2985+       { USB_DEVICE(0x1d4d, 0x0002), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28942986+       /* Philips */ 
    28952987+       { USB_DEVICE(0x0471, 0x200f), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28962988+       /* Planex */ 
    28972989+       { USB_DEVICE(0x2019, 0xed06), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2990+       { USB_DEVICE(0x2019, 0xab24), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28982991+       { USB_DEVICE(0x2019, 0xab25), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2992+       /* Qcom */ 
     2993+       { USB_DEVICE(0x18e8, 0x6259), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2994+       /* Quanta */ 
     2995+       { USB_DEVICE(0x1a32, 0x0304), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    28992996+       /* Ralink */ 
     2997+       { USB_DEVICE(0x148f, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29002998+       { USB_DEVICE(0x148f, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29012999+       { USB_DEVICE(0x148f, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29023000+       { USB_DEVICE(0x148f, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3001+       { USB_DEVICE(0x148f, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3002+       { USB_DEVICE(0x148f, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29033003+       /* Samsung */ 
    29043004+       { USB_DEVICE(0x04e8, 0x2018), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    29103010+       { USB_DEVICE(0x0df6, 0x002c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29113011+       { USB_DEVICE(0x0df6, 0x002d), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3012+       { USB_DEVICE(0x0df6, 0x0039), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3013+       { USB_DEVICE(0x0df6, 0x003b), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3014+       { USB_DEVICE(0x0df6, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3015+       { USB_DEVICE(0x0df6, 0x003d), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3016+       { USB_DEVICE(0x0df6, 0x003e), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3017+       { USB_DEVICE(0x0df6, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29123018+       /* SMC */ 
    29133019+       { USB_DEVICE(0x083a, 0x6618), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3020+       { USB_DEVICE(0x083a, 0x7511), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3021+       { USB_DEVICE(0x083a, 0x7512), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29143022+       { USB_DEVICE(0x083a, 0x7522), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     3023+       { USB_DEVICE(0x083a, 0x8522), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29153024+       { USB_DEVICE(0x083a, 0xb522), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    29163025+       { USB_DEVICE(0x083a, 0xa618), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    29613070--- /dev/null 
    29623071+++ b/drivers/net/wireless/rt2x00/rt2800usb.h 
    2963 @@ -0,0 +1,1940 @@ 
     3072@@ -0,0 +1,1932 @@ 
    29643073+/* 
    29653074+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
     
    30323141+#define BBP_BASE                       0x0000 
    30333142+#define BBP_SIZE                       0x0080 
    3034 +#define RF_BASE                                0x0000 
    3035 +#define RF_SIZE                                0x0014 
     3143+#define RF_BASE                                0x0004 
     3144+#define RF_SIZE                                0x0010 
    30363145+ 
    30373146+/* 
     
    31913300+#define WMM_TXOP1_CFG_AC2TXOP          FIELD32(0x0000ffff) 
    31923301+#define WMM_TXOP1_CFG_AC3TXOP          FIELD32(0xffff0000) 
    3193 + 
    3194 +/* 
    3195 + * RINGREG_DIFF 
    3196 + */ 
    3197 +#define RINGREG_DIFF                   0x0010 
    31983302+ 
    31993303+/* 
     
    37723876+ */ 
    37733877+#define TX_BAND_CFG                    0x132c 
     3878+#define TX_BAND_CFG_HT40_PLUS          FIELD32(0x00000001) 
    37743879+#define TX_BAND_CFG_A                  FIELD32(0x00000002) 
    37753880+#define TX_BAND_CFG_BG                 FIELD32(0x00000004) 
     
    41824287+ */ 
    41834288+#define TX_STA_FIFO                    0x1718 
    4184 +#define TX_STA_FIFO_B_VALID            FIELD32(0x00000001) 
     4289+#define TX_STA_FIFO_VALID              FIELD32(0x00000001) 
    41854290+#define TX_STA_FIFO_PID_TYPE           FIELD32(0x0000001e) 
    41864291+#define TX_STA_FIFO_TX_SUCCESS         FIELD32(0x00000020) 
     
    43074412+ 
    43084413+/* 
    4309 + * MAC_IVEIV: 
    4310 + */ 
    4311 +#define MAC_IVEIV_EIV                  FIELD32(0x20000000) 
    4312 +#define MAC_IVEIV_KEYIDX               FIELD32(0xc0000000) 
    4313 + 
    4314 +/* 
    43154414+ * MAC_WCID_ATTRIBUTE: 
    43164415+ */ 
     
    44054504+ * HW_BEACON_BASE 
    44064505+ * In order to support maximum 8 MBSS and its maximum length 
    4407 + *     is 512 bytes for each beacon 
     4506+ * is 512 bytes for each beacon 
    44084507+ * Three section discontinue memory segments will be used. 
    44094508+ * 1. The original region for BCN 0~3 
     
    44514550+ */ 
    44524551+#define BBP3_RX_ANTENNA                        FIELD8(0x18) 
     4552+#define BBP3_HT40_PLUS                 FIELD8(0x20) 
    44534553+ 
    44544554+/* 
    44554555+ * BBP 4: Bandwidth 
    44564556+ */ 
     4557+#define BBP4_TX_BF                     FIELD8(0x01) 
    44574558+#define BBP4_BANDWIDTH                 FIELD8(0x18) 
    44584559+ 
     
    45174618+#define RF4_TXPOWER_A                  FIELD32(0x00000780) 
    45184619+#define RF4_FREQ_OFFSET                        FIELD32(0x001f8000) 
    4519 +#define RF4_BW40                       FIELD32(0x00200000) 
     4620+#define RF4_HT40                       FIELD32(0x00200000) 
    45204621+ 
    45214622+/* 
Note: See TracChangeset for help on using the changeset viewer.