Changeset 14172


Ignore:
Timestamp:
2009-01-25T14:33:34+01:00 (9 years ago)
Author:
juhosg
Message:

[package] mac80211: update compat-wireless to 2009-01-24 (patch by Hauke Mehrtens <hauke@…>)

Location:
trunk/package/mac80211
Files:
19 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/mac80211/Makefile

    r14154 r14172  
    1313 
    1414ifneq ($(CONFIG_LINUX_2_6_27)$(CONFIG_LINUX_2_6_28),) 
    15   PKG_VERSION:=2009-01-23 
     15  PKG_VERSION:=2009-01-24 
    1616  PKG_SOURCE_URL:= \ 
    1717        http://www.orbit-lab.org/kernel/compat-wireless-2.6/2009/01 \ 
    1818        http://wireless.kernel.org/download/compat-wireless-2.6 
    19   PKG_MD5SUM:=f4c8df5e077432d7018112849e36f438 
     19  PKG_MD5SUM:=5d5179b9bd2536b99dfc7e9aef34df91 
    2020else 
    2121  PKG_VERSION:=2008-08-06 
  • trunk/package/mac80211/patches/301-rt2x00-Implement-support-for-802.11n.patch

    r14154 r14172  
    1 From 42d5399c2743dbd1ddaaadc8cb04adbfc65cc970 Mon Sep 17 00:00:00 2001 
     1From adf33d3a207846709e2a5fb006f17dbc9225f7a9 Mon Sep 17 00:00:00 2001 
    22From: Ivo van Doorn <IvDoorn@gmail.com> 
    3 Date: Sat, 10 Jan 2009 11:01:10 +0100 
     3Date: Fri, 23 Jan 2009 17:10:06 +0100 
    44Subject: [PATCH] rt2x00: Implement support for 802.11n 
    55 
     
    5959  
    6060 /* 
    61 @@ -604,6 +608,7 @@ enum rt2x00_flags { 
     61@@ -603,6 +607,7 @@ enum rt2x00_flags { 
    6262        CONFIG_EXTERNAL_LNA_BG, 
    6363        CONFIG_DOUBLE_ANTENNA, 
     
    296296@@ -0,0 +1,69 @@ 
    297297+/* 
    298 +       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     298+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
    299299+       <http://rt2x00.serialmonkey.com> 
    300300+ 
     
    328328+void rt2x00ht_create_tx_descriptor(struct queue_entry *entry, 
    329329+                                  struct txentry_desc *txdesc, 
    330 +                                  struct ieee80211_rate *rate) 
     330+                                  const struct rt2x00_rate *hwrate) 
    331331+{ 
    332332+       struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb); 
    333 +       const struct rt2x00_rate *hwrate = rt2x00_get_rate(rate->hw_value); 
     333+       struct ieee80211_tx_rate *txrate = &tx_info->control.rates[0]; 
    334334+ 
    335335+       if (tx_info->control.sta) 
     
    343343+ 
    344344+       txdesc->mcs = rt2x00_get_rate_mcs(hwrate->mcs); 
    345 +       if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) 
     345+       if (txrate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) 
    346346+               txdesc->mcs |= 0x08; 
    347347+ 
     
    355355+        * Determine HT Mix/Greenfield rate mode 
    356356+        */ 
    357 +       if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_MCS) 
     357+       if (txrate->flags & IEEE80211_TX_RC_MCS) 
    358358+               txdesc->rate_mode = RATE_MODE_HT_MIX; 
    359 +       if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD) 
     359+       if (txrate->flags & IEEE80211_TX_RC_GREEN_FIELD) 
    360360+               txdesc->rate_mode = RATE_MODE_HT_GREENFIELD; 
    361 +       if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 
     361+       if (txrate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 
    362362+               __set_bit(ENTRY_TXD_HT_BW_40, &txdesc->flags); 
    363 +       if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI) 
     363+       if (txrate->flags & IEEE80211_TX_RC_SHORT_GI) 
    364364+               __set_bit(ENTRY_TXD_HT_SHORT_GI, &txdesc->flags); 
    365365+} 
     
    398398+void rt2x00ht_create_tx_descriptor(struct queue_entry *entry, 
    399399+                                  struct txentry_desc *txdesc, 
    400 +                                  struct ieee80211_rate *rate); 
     400+                                  const struct rt2x00_rate *hwrate); 
    401401+#else 
    402402+static inline void rt2x00ht_create_tx_descriptor(struct queue_entry *entry, 
    403403+                                                struct txentry_desc *txdesc, 
    404 +                                                struct ieee80211_rate *rate) 
     404+                                                const struct rt2x00_rate *hwrate) 
    405405+{ 
    406406+} 
     
    417417         */ 
    418418        rt2x00crypto_create_tx_descriptor(entry, txdesc); 
    419 +       rt2x00ht_create_tx_descriptor(entry, txdesc, rate); 
     419+       rt2x00ht_create_tx_descriptor(entry, txdesc, hwrate); 
    420420        rt2x00queue_create_tx_descriptor_seq(entry, txdesc); 
    421421        rt2x00queue_create_tx_descriptor_plcp(entry, txdesc, hwrate); 
  • trunk/package/mac80211/patches/302-rt2x00-Implement-support-for-rt2800pci.patch

    r14154 r14172  
    1 From dda25991ee4dc0a2ebe2e3b50857971fe1d878c4 Mon Sep 17 00:00:00 2001 
     1From 659988a6bb83536c5d0a01b0b58378cc1856c975 Mon Sep 17 00:00:00 2001 
    22From: Ivo van Doorn <IvDoorn@gmail.com> 
    3 Date: Sat, 10 Jan 2009 11:03:23 +0100 
     3Date: Fri, 23 Jan 2009 17:13:03 +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 | 2707 +++++++++++++++++++++++++++++++ 
    18  drivers/net/wireless/rt2x00/rt2800pci.h | 1879 +++++++++++++++++++++ 
     17 drivers/net/wireless/rt2x00/rt2800pci.c | 2763 +++++++++++++++++++++++++++++++ 
     18 drivers/net/wireless/rt2x00/rt2800pci.h | 1881 +++++++++++++++++++++ 
    1919 drivers/net/wireless/rt2x00/rt2x00.h    |    4 + 
    20  5 files changed, 4606 insertions(+), 0 deletions(-) 
     20 5 files changed, 4664 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,2707 @@ 
    36 +/* 
    37 +       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     35@@ -0,0 +1,2763 @@ 
     36+/* 
     37+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
    3838+       <http://rt2x00.serialmonkey.com> 
    3939+ 
     
    503503+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_TO_ME, 
    504504+                          !(filter_flags & FIF_PROMISC_IN_BSS)); 
    505 +       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 
    506 +                          !(filter_flags & FIF_OTHER_BSS)); 
     505+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 0); 
    507506+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_VER_ERROR, 1); 
    508507+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_MULTICAST, 
     
    639638+       switch (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH)) { 
    640639+       case 1: 
     640+               rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 0); 
    641641+               rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 0); 
    642642+               break; 
    643643+       case 2: 
     644+               rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 16); 
     645+               break; 
    644646+       case 3: 
    645647+               /* Do nothing */ 
     
    916918+} 
    917919+ 
     920+static void rt2800pci_config_ps(struct rt2x00_dev *rt2x00dev, 
     921+                               struct rt2x00lib_conf *libconf) 
     922+{ 
     923+       enum dev_state state = 
     924+           (libconf->conf->flags & IEEE80211_CONF_PS) ? 
     925+               STATE_SLEEP : STATE_AWAKE; 
     926+       u32 reg; 
     927+ 
     928+       if (state == STATE_SLEEP) { 
     929+               rt2x00pci_register_write(rt2x00dev, AUTOWAKEUP_CFG, 0); 
     930+ 
     931+               rt2x00pci_register_read(rt2x00dev, AUTOWAKEUP_CFG, &reg); 
     932+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTO_LEAD_TIME, 5); 
     933+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_TBCN_BEFORE_WAKE, 
     934+                                  libconf->conf->listen_interval - 1); 
     935+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTOWAKE, 1); 
     936+               rt2x00pci_register_write(rt2x00dev, AUTOWAKEUP_CFG, reg); 
     937+ 
     938+               rt2800pci_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0, 0); 
     939+       } else { 
     940+               rt2800pci_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 0); 
     941+ 
     942+               rt2x00pci_register_read(rt2x00dev, AUTOWAKEUP_CFG, &reg); 
     943+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTO_LEAD_TIME, 0); 
     944+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_TBCN_BEFORE_WAKE, 0); 
     945+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTOWAKE, 0); 
     946+               rt2x00pci_register_write(rt2x00dev, AUTOWAKEUP_CFG, reg); 
     947+       } 
     948+} 
     949+ 
    918950+static void rt2800pci_config(struct rt2x00_dev *rt2x00dev, 
    919951+                            struct rt2x00lib_conf *libconf, 
     
    932964+       if (flags & IEEE80211_CONF_CHANGE_BEACON_INTERVAL) 
    933965+               rt2800pci_config_duration(rt2x00dev, libconf); 
     966+       if (flags & IEEE80211_CONF_CHANGE_PS) 
     967+               rt2800pci_config_ps(rt2x00dev, libconf); 
    934968+} 
    935969+ 
     
    9861020+                                struct link_qual *qual, const u32 count) 
    9871021+{ 
    988 +       if (rt2x00_rev(&rt2x00dev->chip) == RT2860_VERSION_C) 
     1022+       if (rt2x00_rev(&rt2x00dev->chip) == RT2860C_VERSION) 
    9891023+               return; 
    9901024+ 
     
    10351069+       unsigned int i; 
    10361070+       u32 reg; 
     1071+ 
     1072+       if (len != 8192) { 
     1073+               ERROR(rt2x00dev, "Invalid firmware file length (len=%zu)\n", len); 
     1074+               return -ENOENT; 
     1075+       } 
    10371076+ 
    10381077+       /* 
     
    12741313+       rt2x00pci_register_read(rt2x00dev, MAX_LEN_CFG, &reg); 
    12751314+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_MPDU, AGGREGATION_SIZE); 
    1276 +       rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 1); 
     1315+       if (rt2x00_rev(&rt2x00dev->chip) >= RT2880E_VERSION && 
     1316+           rt2x00_rev(&rt2x00dev->chip) < RT3070_VERSION) 
     1317+               rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 2); 
     1318+       else 
     1319+               rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 1); 
    12771320+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_PSDU, 0); 
    12781321+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_MPDU, 0); 
     
    13761419+        */ 
    13771420+       for (i = 0; i < 254; i++) { 
    1378 +               u32 wcid[2] = { 0xffffffff, 0x0000ffff }; 
     1421+               u32 wcid[2] = { 0xffffffff, 0x00ffffff }; 
    13791422+               rt2x00pci_register_multiwrite(rt2x00dev, MAC_WCID_ENTRY(i), 
    13801423+                                             wcid, sizeof(wcid)); 
     
    15251568+       rt2800pci_bbp_write(rt2x00dev, 105, 0x05); 
    15261569+ 
    1527 +       if (rt2x00_rev(&rt2x00dev->chip) == RT2860_VERSION_C) { 
     1570+       if (rt2x00_rev(&rt2x00dev->chip) == RT2860C_VERSION) { 
    15281571+               rt2800pci_bbp_write(rt2x00dev, 69, 0x16); 
    15291572+               rt2800pci_bbp_write(rt2x00dev, 73, 0x12); 
    15301573+       } 
    15311574+ 
    1532 +       if (rt2x00_rev(&rt2x00dev->chip) == RT2860_VERSION_D) 
     1575+       if (rt2x00_rev(&rt2x00dev->chip) > RT2860D_VERSION) 
    15331576+               rt2800pci_bbp_write(rt2x00dev, 84, 0x19); 
    15341577+ 
     
    16271670+                    rt2800pci_init_queues(rt2x00dev) || 
    16281671+                    rt2800pci_init_registers(rt2x00dev) || 
     1672+                    rt2800pci_wait_wpdma_ready(rt2x00dev) || 
    16291673+                    rt2800pci_init_bbp(rt2x00dev))) 
    16301674+               return -EIO; 
     
    16351679+       rt2800pci_mcu_request(rt2x00dev, MCU_BOOT_SIGNAL, 0xff, 0, 0); 
    16361680+ 
    1637 +       /* Wait for DMA, ignore error */ 
    1638 +       rt2800pci_wait_wpdma_ready(rt2x00dev); 
    1639 + 
    16401681+       /* 
    16411682+        * Enable RX. 
    16421683+        */ 
     1684+       rt2x00pci_register_read(rt2x00dev, MAC_SYS_CTRL, &reg); 
     1685+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_TX, 1); 
     1686+       rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 0); 
     1687+       rt2x00pci_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 
     1688+ 
    16431689+       rt2x00pci_register_read(rt2x00dev, WPDMA_GLO_CFG, &reg); 
    16441690+       rt2x00_set_field32(&reg, WPDMA_GLO_CFG_ENABLE_TX_DMA, 1); 
     
    21652211+ 
    21662212+       rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &word); 
    2167 +       if (word != 0) { 
    2168 +               /* NIC configuration must always be 0. */ 
    2169 +               word = 0; 
     2213+       if (word == 0xffff) { 
     2214+               rt2x00_set_field16(&word, EEPROM_NIC_HW_RADIO, 0); 
     2215+               rt2x00_set_field16(&word, EEPROM_NIC_DYNAMIC_TX_AGC, 0); 
     2216+               rt2x00_set_field16(&word, EEPROM_NIC_EXTERNAL_LNA_BG, 0); 
     2217+               rt2x00_set_field16(&word, EEPROM_NIC_EXTERNAL_LNA_A, 0); 
     2218+               rt2x00_set_field16(&word, EEPROM_NIC_CARDBUS_ACCEL, 0); 
     2219+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_SB_BG, 0); 
     2220+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_SB_A, 0); 
     2221+               rt2x00_set_field16(&word, EEPROM_NIC_WPS_PBC, 0); 
     2222+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_BG, 0); 
     2223+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_A, 0); 
    21702224+               rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word); 
    21712225+               EEPROM(rt2x00dev, "NIC: 0x%04x\n", word); 
     
    22492303+       value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RF_TYPE); 
    22502304+       rt2x00pci_register_read(rt2x00dev, MAC_CSR0, &reg); 
    2251 +       reg = rt2x00_get_field32(reg, MAC_CSR0_ASIC_REV); 
    22522305+       rt2x00_set_chip(rt2x00dev, device, value, reg); 
    22532306+ 
     
    22552308+           !rt2x00_rf(&rt2x00dev->chip, RF2850) && 
    22562309+           !rt2x00_rf(&rt2x00dev->chip, RF2720) && 
    2257 +           !rt2x00_rf(&rt2x00dev->chip, RF2750)) { 
     2310+           !rt2x00_rf(&rt2x00dev->chip, RF2750) && 
     2311+           !rt2x00_rf(&rt2x00dev->chip, RF3020) && 
     2312+           !rt2x00_rf(&rt2x00dev->chip, RF2020)) { 
    22582313+               ERROR(rt2x00dev, "Invalid RF chipset detected.\n"); 
    22592314+               return -ENODEV; 
     
    23822437+       rt2x00dev->hw->flags = 
    23832438+           IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING | 
    2384 +           IEEE80211_HW_SIGNAL_DBM; 
     2439+           IEEE80211_HW_SIGNAL_DBM | 
     2440+           IEEE80211_HW_SUPPORTS_PS | 
     2441+           IEEE80211_HW_PS_NULLFUNC_STACK; 
    23852442+       rt2x00dev->hw->extra_tx_headroom = TXWI_DESC_SIZE; 
    23862443+ 
     
    25002557+       struct rt2x00_dev *rt2x00dev = hw->priv; 
    25012558+       u32 reg; 
     2559+       bool enabled = (value < IEEE80211_MAX_RTS_THRESHOLD); 
    25022560+ 
    25032561+       rt2x00pci_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
     
    25062564+ 
    25072565+       rt2x00pci_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
    2508 +       rt2x00_set_field32(&reg, CCK_PROT_CFG_RTS_TH_EN, 1); 
     2566+       rt2x00_set_field32(&reg, CCK_PROT_CFG_RTS_TH_EN, enabled); 
    25092567+       rt2x00pci_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
    25102568+ 
    25112569+       rt2x00pci_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
    2512 +       rt2x00_set_field32(&reg, OFDM_PROT_CFG_RTS_TH_EN, 1); 
     2570+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_RTS_TH_EN, enabled); 
    25132571+       rt2x00pci_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
    25142572+ 
    25152573+       rt2x00pci_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
    2516 +       rt2x00_set_field32(&reg, MM20_PROT_CFG_RTS_TH_EN, 1); 
     2574+       rt2x00_set_field32(&reg, MM20_PROT_CFG_RTS_TH_EN, enabled); 
    25172575+       rt2x00pci_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
    25182576+ 
    25192577+       rt2x00pci_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
    2520 +       rt2x00_set_field32(&reg, MM40_PROT_CFG_RTS_TH_EN, 1); 
     2578+       rt2x00_set_field32(&reg, MM40_PROT_CFG_RTS_TH_EN, enabled); 
    25212579+       rt2x00pci_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
    25222580+ 
    25232581+       rt2x00pci_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
    2524 +       rt2x00_set_field32(&reg, GF20_PROT_CFG_RTS_TH_EN, 1); 
     2582+       rt2x00_set_field32(&reg, GF20_PROT_CFG_RTS_TH_EN, enabled); 
    25252583+       rt2x00pci_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
    25262584+ 
    25272585+       rt2x00pci_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
    2528 +       rt2x00_set_field32(&reg, GF40_PROT_CFG_RTS_TH_EN, 1); 
     2586+       rt2x00_set_field32(&reg, GF40_PROT_CFG_RTS_TH_EN, enabled); 
    25292587+       rt2x00pci_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
    25302588+ 
     
    25522610+               return retval; 
    25532611+ 
     2612+       /* 
     2613+        * We only need to perform additional register initialization 
     2614+        * for WMM queues/ 
     2615+        */ 
     2616+       if (queue_idx >= 4) 
     2617+               return 0; 
     2618+ 
    25542619+       queue = rt2x00queue_get_queue(rt2x00dev, queue_idx); 
    25552620+ 
    25562621+       /* Update WMM TXOP register */ 
    2557 +       if (queue_idx < 2) { 
    2558 +               field.bit_offset = queue_idx * 16; 
    2559 +               field.bit_mask = 0xffff << field.bit_offset; 
    2560 + 
    2561 +               rt2x00pci_register_read(rt2x00dev, WMM_TXOP0_CFG, &reg); 
    2562 +               rt2x00_set_field32(&reg, field, queue->txop); 
    2563 +               rt2x00pci_register_write(rt2x00dev, WMM_TXOP0_CFG, reg); 
    2564 +       } else if (queue_idx < 4) { 
    2565 +               field.bit_offset = (queue_idx - 2) * 16; 
    2566 +               field.bit_mask = 0xffff << field.bit_offset; 
    2567 + 
    2568 +               rt2x00pci_register_read(rt2x00dev, WMM_TXOP1_CFG, &reg); 
    2569 +               rt2x00_set_field32(&reg, field, queue->txop); 
    2570 +               rt2x00pci_register_write(rt2x00dev, WMM_TXOP1_CFG, reg); 
    2571 +       } 
     2622+       offset = WMM_TXOP0_CFG + (sizeof(u32) * (!!(queue_idx & 2))); 
     2623+       field.bit_offset = (queue_idx & 1) * 16; 
     2624+       field.bit_mask = 0xffff << field.bit_offset; 
     2625+ 
     2626+       rt2x00pci_register_read(rt2x00dev, offset, &reg); 
     2627+       rt2x00_set_field32(&reg, field, queue->txop); 
     2628+       rt2x00pci_register_write(rt2x00dev, offset, reg); 
    25722629+ 
    25732630+       /* Update WMM registers */ 
     
    25882645+ 
    25892646+       /* Update EDCA registers */ 
    2590 +       if (queue_idx < 4) { 
    2591 +               offset = EDCA_AC0_CFG + (sizeof(u32) * queue_idx); 
    2592 + 
    2593 +               rt2x00pci_register_read(rt2x00dev, offset, &reg); 
    2594 +               rt2x00_set_field32(&reg, EDCA_AC0_CFG_AIFSN, queue->aifs); 
    2595 +               rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMIN, queue->cw_min); 
    2596 +               rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMAX, queue->cw_max); 
    2597 +               rt2x00pci_register_write(rt2x00dev, offset, reg); 
    2598 +       } 
     2647+       offset = EDCA_AC0_CFG + (sizeof(u32) * queue_idx); 
     2648+ 
     2649+       rt2x00pci_register_read(rt2x00dev, offset, &reg); 
     2650+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_TX_OP, queue->txop); 
     2651+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_AIFSN, queue->aifs); 
     2652+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMIN, queue->cw_min); 
     2653+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMAX, queue->cw_max); 
     2654+       rt2x00pci_register_write(rt2x00dev, offset, reg); 
    25992655+ 
    26002656+       return 0; 
     
    27432799--- /dev/null 
    27442800+++ b/drivers/net/wireless/rt2x00/rt2800pci.h 
    2745 @@ -0,0 +1,1879 @@ 
    2746 +/* 
    2747 +       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     2801@@ -0,0 +1,1881 @@ 
     2802+/* 
     2803+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
    27482804+       <http://rt2x00.serialmonkey.com> 
    27492805+ 
     
    27932849+ * RT2860 version 
    27942850+ */ 
    2795 +#define RT2860_VERSION_C               0x0100 
    2796 +#define RT2860_VERSION_D               0x0101 
    2797 +#define RT2860_VERSION_E               0x0200 
     2851+#define RT2860C_VERSION                        0x28600100 
     2852+#define RT2860D_VERSION                        0x28600101 
     2853+#define RT2880E_VERSION                        0x28720200 
     2854+#define RT2883_VERSION                 0x28830300 
     2855+#define RT3070_VERSION                 0x30700200 
    27982856+ 
    27992857+/* 
     
    34133471+ */ 
    34143472+#define EDCA_AC0_CFG                   0x1300 
    3415 +#define EDCA_AC0_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3473+#define EDCA_AC0_CFG_TX_OP             FIELD32(0x000000ff) 
    34163474+#define EDCA_AC0_CFG_AIFSN             FIELD32(0x00000f00) 
    34173475+#define EDCA_AC0_CFG_CWMIN             FIELD32(0x0000f000) 
     
    34223480+ */ 
    34233481+#define EDCA_AC1_CFG                   0x1304 
    3424 +#define EDCA_AC1_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3482+#define EDCA_AC1_CFG_TX_OP             FIELD32(0x000000ff) 
    34253483+#define EDCA_AC1_CFG_AIFSN             FIELD32(0x00000f00) 
    34263484+#define EDCA_AC1_CFG_CWMIN             FIELD32(0x0000f000) 
     
    34313489+ */ 
    34323490+#define EDCA_AC2_CFG                   0x1308 
    3433 +#define EDCA_AC2_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3491+#define EDCA_AC2_CFG_TX_OP             FIELD32(0x000000ff) 
    34343492+#define EDCA_AC2_CFG_AIFSN             FIELD32(0x00000f00) 
    34353493+#define EDCA_AC2_CFG_CWMIN             FIELD32(0x0000f000) 
     
    34403498+ */ 
    34413499+#define EDCA_AC3_CFG                   0x130c 
    3442 +#define EDCA_AC3_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3500+#define EDCA_AC3_CFG_TX_OP             FIELD32(0x000000ff) 
    34433501+#define EDCA_AC3_CFG_AIFSN             FIELD32(0x00000f00) 
    34443502+#define EDCA_AC3_CFG_CWMIN             FIELD32(0x0000f000) 
  • trunk/package/mac80211/patches/303-rt2x00-Implement-support-for-rt2800usb.patch

    r13961 r14172  
    1 From 22592b5df5bef2754f56e165ee0828777a95fdfd Mon Sep 17 00:00:00 2001 
     1From e380f1fa260d81cba1ebb1b6c333ef8c31f2a8c5 Mon Sep 17 00:00:00 2001 
    22From: Ivo van Doorn <IvDoorn@gmail.com> 
    3 Date: Sat, 10 Jan 2009 11:05:41 +0100 
     3Date: Fri, 23 Jan 2009 17:16:11 +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 | 2540 +++++++++++++++++++++++++++++++ 
    17  drivers/net/wireless/rt2x00/rt2800usb.h | 1892 +++++++++++++++++++++++ 
    18  drivers/net/wireless/rt2x00/rt2x00.h    |    1 + 
    19  5 files changed, 4448 insertions(+), 0 deletions(-) 
     16 drivers/net/wireless/rt2x00/rt2800usb.c | 2905 +++++++++++++++++++++++++++++++ 
     17 drivers/net/wireless/rt2x00/rt2800usb.h | 1944 +++++++++++++++++++++ 
     18 drivers/net/wireless/rt2x00/rt2x00.h    |    7 + 
     19 5 files changed, 4871 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,2540 @@ 
    33 +/* 
    34 +       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     32@@ -0,0 +1,2905 @@ 
     33+/* 
     34+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
    3535+       <http://rt2x00.serialmonkey.com> 
    3636+ 
     
    9292+#define WAIT_FOR_BBP(__dev, __reg) \ 
    9393+       rt2x00usb_regbusy_read((__dev), BBP_CSR_CFG, BBP_CSR_CFG_BUSY, (__reg)) 
     94+#define WAIT_FOR_RFCSR(__dev, __reg) \ 
     95+       rt2x00usb_regbusy_read((__dev), RF_CSR_CFG, RF_CSR_CFG_BUSY, (__reg)) 
    9496+#define WAIT_FOR_RF(__dev, __reg) \ 
    9597+       rt2x00usb_regbusy_read((__dev), RF_CSR_CFG0, RF_CSR_CFG0_BUSY, (__reg)) 
     
    149151+ 
    150152+       *value = rt2x00_get_field32(reg, BBP_CSR_CFG_VALUE); 
     153+ 
     154+       mutex_unlock(&rt2x00dev->csr_mutex); 
     155+} 
     156+ 
     157+static void rt2800usb_rfcsr_write(struct rt2x00_dev *rt2x00dev, 
     158+                                 const unsigned int word, const u8 value) 
     159+{ 
     160+       u32 reg; 
     161+ 
     162+       mutex_lock(&rt2x00dev->csr_mutex); 
     163+ 
     164+       /* 
     165+        * Wait until the RFCSR becomes available, afterwards we 
     166+        * can safely write the new data into the register. 
     167+        */ 
     168+       if (WAIT_FOR_RFCSR(rt2x00dev, &reg)) { 
     169+               reg = 0; 
     170+               rt2x00_set_field32(&reg, RF_CSR_CFG_DATA, value); 
     171+               rt2x00_set_field32(&reg, RF_CSR_CFG_REGNUM, word); 
     172+               rt2x00_set_field32(&reg, RF_CSR_CFG_WRITE, 1); 
     173+               rt2x00_set_field32(&reg, RF_CSR_CFG_BUSY, 1); 
     174+ 
     175+               rt2x00usb_register_write_lock(rt2x00dev, RF_CSR_CFG, reg); 
     176+       } 
     177+ 
     178+       mutex_unlock(&rt2x00dev->csr_mutex); 
     179+} 
     180+ 
     181+static void rt2800usb_rfcsr_read(struct rt2x00_dev *rt2x00dev, 
     182+                                const unsigned int word, u8 *value) 
     183+{ 
     184+       u32 reg; 
     185+ 
     186+       mutex_lock(&rt2x00dev->csr_mutex); 
     187+ 
     188+       /* 
     189+        * Wait until the RFCSR becomes available, afterwards we 
     190+        * can safely write the read request into the register. 
     191+        * After the data has been written, we wait until hardware 
     192+        * returns the correct value, if at any time the register 
     193+        * doesn't become available in time, reg will be 0xffffffff 
     194+        * which means we return 0xff to the caller. 
     195+        */ 
     196+       if (WAIT_FOR_RFCSR(rt2x00dev, &reg)) { 
     197+               reg = 0; 
     198+               rt2x00_set_field32(&reg, RF_CSR_CFG_REGNUM, word); 
     199+               rt2x00_set_field32(&reg, RF_CSR_CFG_WRITE, 0); 
     200+               rt2x00_set_field32(&reg, RF_CSR_CFG_BUSY, 1); 
     201+ 
     202+               rt2x00usb_register_write_lock(rt2x00dev, BBP_CSR_CFG, reg); 
     203+ 
     204+               WAIT_FOR_RFCSR(rt2x00dev, &reg); 
     205+       } 
     206+ 
     207+       *value = rt2x00_get_field32(reg, RF_CSR_CFG_DATA); 
    151208+ 
    152209+       mutex_unlock(&rt2x00dev->csr_mutex); 
     
    480537+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_TO_ME, 
    481538+                          !(filter_flags & FIF_PROMISC_IN_BSS)); 
    482 +       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 
    483 +                          !(filter_flags & FIF_OTHER_BSS)); 
     539+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_NOT_MY_BSSD, 0); 
    484540+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_VER_ERROR, 1); 
    485541+       rt2x00_set_field32(&reg, RX_FILTER_CFG_DROP_MULTICAST, 
     
    616672+       switch (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH)) { 
    617673+       case 1: 
     674+               rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 0); 
    618675+               rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 0); 
    619676+               break; 
    620677+       case 2: 
     678+               rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 16); 
     679+               break; 
    621680+       case 3: 
    622681+               /* Do nothing */ 
     
    666725+} 
    667726+ 
    668 +static void rt2800usb_config_channel(struct rt2x00_dev *rt2x00dev, 
    669 +                                    struct rf_channel *rf, 
    670 +                                    struct channel_info *info) 
    671 +{ 
    672 +       u32 reg; 
    673 +       unsigned int tx_pin; 
     727+static void rt2800usb_config_channel_rt2x(struct rt2x00_dev *rt2x00dev, 
     728+                                         struct rf_channel *rf, 
     729+                                         struct channel_info *info) 
     730+{ 
    674731+       u16 eeprom; 
    675732+ 
    676 +       tx_pin = 0; 
    677 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 1); 
    678 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A0_EN, 1); 
    679 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G0_EN, 1); 
    680 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 1); 
    681 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 1); 
    682 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_RFTR_EN, 1); 
    683 +       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_TRSW_EN, 1); 
    684 + 
    685733+       rt2x00_set_field32(&rf->rf4, RF4_FREQ_OFFSET, rt2x00dev->freq_offset); 
    686734+ 
     
    689737+        */ 
    690738+       rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
    691 +       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) == 1) { 
     739+       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) == 1) 
    692740+               rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_TX1, 1); 
    693 +               /* Turn off unused PA or LNA when only 1T or 1R */ 
    694 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A1_EN, 0); 
    695 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 0); 
    696 +       } 
    697741+ 
    698742+       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH) == 1) { 
    699743+               rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_RX1, 1); 
    700744+               rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_RX2, 1); 
    701 +               /* Turn off unused PA or LNA when only 1T or 1R */ 
    702 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 0); 
    703 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 0); 
    704745+       } else if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH) == 2) 
    705746+               rt2x00_set_field32(&rf->rf2, RF2_ANTENNA_RX2, 1); 
     
    729770+               rt2x00_set_field32(&rf->rf4, RF4_TXPOWER_A, 
    730771+                                  TXPOWER_A_TO_DEV(info->tx_power2)); 
    731 + 
    732 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A0_EN, 1); 
    733772+       } else { 
    734773+               rt2x00_set_field32(&rf->rf3, RF3_TXPOWER_G, 
     
    736775+               rt2x00_set_field32(&rf->rf4, RF4_TXPOWER_G, 
    737776+                                  TXPOWER_G_TO_DEV(info->tx_power2)); 
    738 + 
    739 +               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN, 1); 
    740777+       } 
    741778+ 
     
    761798+       rt2800usb_rf_write(rt2x00dev, 3, rf->rf3 & ~0x00000004); 
    762799+       rt2800usb_rf_write(rt2x00dev, 4, rf->rf4); 
     800+} 
     801+ 
     802+static void rt2800usb_config_channel_rt3x(struct rt2x00_dev *rt2x00dev, 
     803+                                         struct rf_channel *rf, 
     804+                                         struct channel_info *info) 
     805+{ 
     806+       u8 rfcsr; 
     807+ 
     808+       rt2800usb_rfcsr_write(rt2x00dev, 2, rf->rf1); 
     809+       rt2800usb_rfcsr_write(rt2x00dev, 2, rf->rf3); 
     810+ 
     811+       rt2800usb_rfcsr_read(rt2x00dev, 6, &rfcsr); 
     812+       rt2x00_set_field8(&rfcsr, RFCSR6_R, rf->rf2); 
     813+       rt2800usb_rfcsr_write(rt2x00dev, 6, rfcsr); 
     814+ 
     815+       rt2800usb_rfcsr_read(rt2x00dev, 12, &rfcsr); 
     816+       rt2x00_set_field8(&rfcsr, RFCSR12_TX_POWER, 
     817+                         TXPOWER_G_TO_DEV(info->tx_power1)); 
     818+       rt2800usb_rfcsr_write(rt2x00dev, 12, rfcsr); 
     819+ 
     820+       rt2800usb_rfcsr_read(rt2x00dev, 23, &rfcsr); 
     821+       rt2x00_set_field8(&rfcsr, RFCSR23_FREQ_OFFSET, rt2x00dev->freq_offset); 
     822+       rt2800usb_rfcsr_write(rt2x00dev, 23, rfcsr); 
     823+ 
     824+       if (test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags)) 
     825+               rt2800usb_rfcsr_write(rt2x00dev, 24, rt2x00dev->calibration_bw40); 
     826+       else 
     827+               rt2800usb_rfcsr_write(rt2x00dev, 24, rt2x00dev->calibration_bw20); 
     828+ 
     829+       rt2800usb_rfcsr_read(rt2x00dev, 23, &rfcsr); 
     830+       rt2x00_set_field8(&rfcsr, RFCSR7_RF_TUNING, 1); 
     831+       rt2800usb_rfcsr_write(rt2x00dev, 23, rfcsr); 
     832+} 
     833+ 
     834+static void rt2800usb_config_channel(struct rt2x00_dev *rt2x00dev, 
     835+                                    struct rf_channel *rf, 
     836+                                    struct channel_info *info) 
     837+{ 
     838+       u32 reg; 
     839+       unsigned int tx_pin; 
     840+       u16 eeprom; 
     841+ 
     842+       if (rt2x00_rev(&rt2x00dev->chip) != RT3070_VERSION) 
     843+               rt2800usb_config_channel_rt2x(rt2x00dev, rf, info); 
     844+       else 
     845+               rt2800usb_config_channel_rt3x(rt2x00dev, rf, info); 
     846+ 
     847+       tx_pin = 0; 
     848+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 1); 
     849+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A0_EN, 1); 
     850+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G0_EN, 1); 
     851+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 1); 
     852+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 1); 
     853+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_RFTR_EN, 1); 
     854+       rt2x00_set_field32(&tx_pin, TX_PIN_CFG_TRSW_EN, 1); 
     855+ 
     856+       rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom); 
     857+ 
     858+       /* Turn off unused PA or LNA when only 1T or 1R */ 
     859+       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TXPATH) == 1) { 
     860+                
     861+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A1_EN, 0); 
     862+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 0); 
     863+       } 
     864+ 
     865+       /* Turn off unused PA or LNA when only 1T or 1R */ 
     866+       if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RXPATH) == 1) { 
     867+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_A1_EN, 0); 
     868+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G1_EN, 0); 
     869+       } 
     870+ 
     871+       if (rf->channel > 14) 
     872+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A0_EN, 1); 
     873+       else 
     874+               rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN, 1); 
    763875+ 
    764876+       /* 
     
    8931005+} 
    8941006+ 
     1007+static void rt2800usb_config_ps(struct rt2x00_dev *rt2x00dev, 
     1008+                               struct rt2x00lib_conf *libconf) 
     1009+{ 
     1010+       enum dev_state state = 
     1011+           (libconf->conf->flags & IEEE80211_CONF_PS) ? 
     1012+               STATE_SLEEP : STATE_AWAKE; 
     1013+       u32 reg; 
     1014+ 
     1015+       if (state == STATE_SLEEP) { 
     1016+               rt2x00usb_register_write(rt2x00dev, AUTOWAKEUP_CFG, 0); 
     1017+ 
     1018+               rt2x00usb_register_read(rt2x00dev, AUTOWAKEUP_CFG, &reg); 
     1019+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTO_LEAD_TIME, 5); 
     1020+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_TBCN_BEFORE_WAKE, 
     1021+                                  libconf->conf->listen_interval - 1); 
     1022+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTOWAKE, 1); 
     1023+               rt2x00usb_register_write(rt2x00dev, AUTOWAKEUP_CFG, reg); 
     1024+ 
     1025+               rt2800usb_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0, 0); 
     1026+       } else { 
     1027+               rt2800usb_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 0); 
     1028+ 
     1029+               rt2x00usb_register_read(rt2x00dev, AUTOWAKEUP_CFG, &reg); 
     1030+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTO_LEAD_TIME, 0); 
     1031+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_TBCN_BEFORE_WAKE, 0); 
     1032+               rt2x00_set_field32(&reg, AUTOWAKEUP_CFG_AUTOWAKE, 0); 
     1033+               rt2x00usb_register_write(rt2x00dev, AUTOWAKEUP_CFG, reg); 
     1034+       } 
     1035+} 
     1036+ 
    8951037+static void rt2800usb_config(struct rt2x00_dev *rt2x00dev, 
    8961038+                            struct rt2x00lib_conf *libconf, 
     
    9091051+       if (flags & IEEE80211_CONF_CHANGE_BEACON_INTERVAL) 
    9101052+               rt2800usb_config_duration(rt2x00dev, libconf); 
     1053+       if (flags & IEEE80211_CONF_CHANGE_PS) 
     1054+               rt2800usb_config_ps(rt2x00dev, libconf); 
    9111055+} 
    9121056+ 
     
    9341078+static u8 rt2800usb_get_default_vgc(struct rt2x00_dev *rt2x00dev) 
    9351079+{ 
    936 +       if (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ) 
    937 +               return 0x2e + rt2x00dev->lna_gain; 
     1080+       if (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ) { 
     1081+               if (rt2x00_rev(&rt2x00dev->chip) == RT3070_VERSION) 
     1082+                       return 0x1c + (2 * rt2x00dev->lna_gain); 
     1083+               else 
     1084+                       return 0x2e + rt2x00dev->lna_gain; 
     1085+       } 
    9381086+ 
    9391087+       if (!test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags)) 
     
    9631111+                                struct link_qual *qual, const u32 count) 
    9641112+{ 
    965 +       if (rt2x00_rev(&rt2x00dev->chip) == RT2870_VERSION_C) 
     1113+       if (rt2x00_rev(&rt2x00dev->chip) == RT2860C_VERSION) 
    9661114+               return; 
    9671115+ 
     
    10131161+       int status; 
    10141162+       u32 reg; 
     1163+       u32 offset; 
     1164+       u32 length; 
     1165+       u16 chipset = (rt2x00_rev(&rt2x00dev->chip) >> 16) & 0xffff; 
     1166+ 
     1167+       /* 
     1168+        * Firmware files: 
     1169+        * There are 2 variations of the rt2870 firmware. 
     1170+        * a) size: 4kb 
     1171+        * b) size: 8kb 
     1172+        * Note that (b) contains 2 seperate firmware blobs of 4k 
     1173+        * within the file. The first blob is the same firmware as (a), 
     1174+        * but the second blob is for the additional chipsets. 
     1175+        */ 
     1176+       if (len != 4096 && len != 8192) { 
     1177+               ERROR(rt2x00dev, "Invalid firmware file length (len=%zu)\n", len); 
     1178+               return -ENOENT; 
     1179+       } 
     1180+ 
     1181+       if ((chipset == 0x2860) || (chipset == 0x2872) || (chipset == 0x3070)) { 
     1182+               offset = 0; 
     1183+               length = 4096; 
     1184+       } else if (len == 8192) { 
     1185+               offset = 4096; 
     1186+               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; 
     1194+       } 
    10151195+ 
    10161196+       /* 
     
    10351215+                                           USB_VENDOR_REQUEST_OUT, 
    10361216+                                           FIRMWARE_IMAGE_BASE, 
    1037 +                                           data, len, 
    1038 +                                           REGISTER_TIMEOUT32(len)); 
     1217+                                           data + offset, length, 
     1218+                                           REGISTER_TIMEOUT32(length)); 
    10391219+ 
    10401220+       rt2x00usb_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); 
     
    11441324+       rt2x00usb_register_write(rt2x00dev, BCN_TIME_CFG, reg); 
    11451325+ 
    1146 +       rt2x00usb_register_write(rt2x00dev, TX_SW_CFG0, 0x00040a06); 
    1147 +       rt2x00usb_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606); 
     1326+       if (rt2x00_rev(&rt2x00dev->chip) == RT3070_VERSION) { 
     1327+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG0, 0x00000400); 
     1328+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG1, 0x00000000); 
     1329+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG2, 0x00000000); 
     1330+       } else { 
     1331+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG0, 0x00040a06); 
     1332+               rt2x00usb_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606); 
     1333+       } 
    11481334+ 
    11491335+       rt2x00usb_register_read(rt2x00dev, TX_LINK_CFG, &reg); 
     
    11651351+       rt2x00usb_register_read(rt2x00dev, MAX_LEN_CFG, &reg); 
    11661352+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_MPDU, AGGREGATION_SIZE); 
    1167 +       rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 1); 
     1353+       if (rt2x00_rev(&rt2x00dev->chip) >= RT2880E_VERSION && 
     1354+           rt2x00_rev(&rt2x00dev->chip) < RT3070_VERSION) 
     1355+               rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 2); 
     1356+       else 
     1357+               rt2x00_set_field32(&reg, MAX_LEN_CFG_MAX_PSDU, 1); 
    11681358+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_PSDU, 0); 
    11691359+       rt2x00_set_field32(&reg, MAX_LEN_CFG_MIN_MPDU, 0); 
     
    12811471+        */ 
    12821472+       for (i = 0; i < 254; i++) { 
    1283 +               u32 wcid[2] = { 0xffffffff, 0x0000ffff }; 
     1473+               u32 wcid[2] = { 0xffffffff, 0x00ffffff }; 
    12841474+               rt2x00usb_register_multiwrite(rt2x00dev, MAC_WCID_ENTRY(i), 
    12851475+                                             wcid, sizeof(wcid)); 
     
    14231613+       rt2800usb_bbp_write(rt2x00dev, 91, 0x04); 
    14241614+       rt2800usb_bbp_write(rt2x00dev, 92, 0x00); 
     1615+       rt2800usb_bbp_write(rt2x00dev, 103, 0x00); 
    14251616+       rt2800usb_bbp_write(rt2x00dev, 105, 0x05); 
    14261617+ 
    1427 +       if (rt2x00_rev(&rt2x00dev->chip) == RT2870_VERSION_C) { 
     1618+       if (rt2x00_rev(&rt2x00dev->chip) == RT2860C_VERSION) { 
    14281619+               rt2800usb_bbp_write(rt2x00dev, 69, 0x16); 
    14291620+               rt2800usb_bbp_write(rt2x00dev, 73, 0x12); 
    14301621+       } 
    14311622+ 
    1432 +       if (rt2x00_rev(&rt2x00dev->chip) != RT2870_VERSION_D) 
    1433 +               rt2800usb_bbp_write(rt2x00dev, 84, 0x19); 
     1623+       if (rt2x00_rev(&rt2x00dev->chip) == RT3070_VERSION) { 
     1624+               rt2800usb_bbp_write(rt2x00dev, 70, 0x0a); 
     1625+               rt2800usb_bbp_write(rt2x00dev, 84, 0x99); 
     1626+               rt2800usb_bbp_write(rt2x00dev, 105, 0x05); 
     1627+       } 
    14341628+ 
    14351629+       for (i = 0; i < EEPROM_BBP_SIZE; i++) { 
     
    14461640+} 
    14471641+ 
     1642+static u8 rt2800usb_init_rx_filter(struct rt2x00_dev *rt2x00dev, 
     1643+                                  bool bw40, u8 rfcsr24, u8 filter_target) 
     1644+{ 
     1645+       unsigned int i; 
     1646+       u8 bbp; 
     1647+       u8 rfcsr; 
     1648+       u8 passband; 
     1649+       u8 stopband; 
     1650+       u8 overtuned = 0; 
     1651+ 
     1652+       rt2800usb_rfcsr_write(rt2x00dev, 24, rfcsr24); 
     1653+ 
     1654+       if (bw40) { 
     1655+               rt2800usb_bbp_read(rt2x00dev, 4, &bbp); 
     1656+               rt2x00_set_field8(&bbp, BBP4_BANDWIDTH, 0x10); 
     1657+               rt2800usb_bbp_write(rt2x00dev, 4, bbp); 
     1658+       } 
     1659+ 
     1660+       rt2800usb_rfcsr_read(rt2x00dev, 22, &rfcsr); 
     1661+       rt2x00_set_field8(&rfcsr, RFCSR22_BASEBAND_LOOPBACK, 1); 
     1662+       rt2800usb_rfcsr_write(rt2x00dev, 22, rfcsr); 
     1663+ 
     1664+       /* 
     1665+        * Set power & frequency of passband test tone 
     1666+        */ 
     1667+       rt2800usb_bbp_write(rt2x00dev, 24, 0); 
     1668+ 
     1669+       for (i = 0; i < 100; i++) { 
     1670+               rt2800usb_bbp_write(rt2x00dev, 25, 0x90); 
     1671+               msleep(1); 
     1672+ 
     1673+               rt2800usb_bbp_read(rt2x00dev, 55, &passband); 
     1674+               if (passband) 
     1675+                       break; 
     1676+       } 
     1677+ 
     1678+       /* 
     1679+        * Set power & frequency of stopband test tone 
     1680+        */ 
     1681+       rt2800usb_bbp_write(rt2x00dev, 24, 0x06); 
     1682+ 
     1683+       for (i = 0; i < 100; i++) { 
     1684+               rt2800usb_bbp_write(rt2x00dev, 25, 0x90); 
     1685+               msleep(1); 
     1686+ 
     1687+               rt2800usb_bbp_read(rt2x00dev, 55, &stopband); 
     1688+ 
     1689+               if ((passband - stopband) <= filter_target) { 
     1690+                       rfcsr24++; 
     1691+                       overtuned += ((passband - stopband) == filter_target); 
     1692+               } else 
     1693+                       break; 
     1694+ 
     1695+               rt2800usb_rfcsr_write(rt2x00dev, 24, rfcsr24); 
     1696+       } 
     1697+ 
     1698+       rfcsr24 -= !!overtuned; 
     1699+ 
     1700+       rt2800usb_rfcsr_write(rt2x00dev, 24, rfcsr24); 
     1701+       return rfcsr24; 
     1702+} 
     1703+ 
     1704+static int rt2800usb_init_rfcsr(struct rt2x00_dev *rt2x00dev) 
     1705+{ 
     1706+       u8 rfcsr; 
     1707+       u8 bbp; 
     1708+ 
     1709+       if (rt2x00_rev(&rt2x00dev->chip) != RT3070_VERSION) 
     1710+               return 0; 
     1711+ 
     1712+       /* 
     1713+        * Init RF calibration. 
     1714+        */ 
     1715+       rt2800usb_rfcsr_read(rt2x00dev, 30, &rfcsr); 
     1716+       rt2x00_set_field8(&rfcsr, RFCSR30_RF_CALIBRATION, 1); 
     1717+       rt2800usb_rfcsr_write(rt2x00dev, 30, rfcsr); 
     1718+       msleep(1); 
     1719+       rt2x00_set_field8(&rfcsr, RFCSR30_RF_CALIBRATION, 0); 
     1720+       rt2800usb_rfcsr_write(rt2x00dev, 30, rfcsr); 
     1721+ 
     1722+       rt2800usb_rfcsr_write(rt2x00dev, 4, 0x40); 
     1723+       rt2800usb_rfcsr_write(rt2x00dev, 5, 0x03); 
     1724+       rt2800usb_rfcsr_write(rt2x00dev, 6, 0x02); 
     1725+       rt2800usb_rfcsr_write(rt2x00dev, 7, 0x70); 
     1726+       rt2800usb_rfcsr_write(rt2x00dev, 9, 0x0f); 
     1727+       rt2800usb_rfcsr_write(rt2x00dev, 10, 0x71); 
     1728+       rt2800usb_rfcsr_write(rt2x00dev, 11, 0x21); 
     1729+       rt2800usb_rfcsr_write(rt2x00dev, 12, 0x7b); 
     1730+       rt2800usb_rfcsr_write(rt2x00dev, 14, 0x90); 
     1731+       rt2800usb_rfcsr_write(rt2x00dev, 15, 0x58); 
     1732+       rt2800usb_rfcsr_write(rt2x00dev, 16, 0xb3); 
     1733+       rt2800usb_rfcsr_write(rt2x00dev, 17, 0x92); 
     1734+       rt2800usb_rfcsr_write(rt2x00dev, 18, 0x2c); 
     1735+       rt2800usb_rfcsr_write(rt2x00dev, 19, 0x02); 
     1736+       rt2800usb_rfcsr_write(rt2x00dev, 20, 0xba); 
     1737+       rt2800usb_rfcsr_write(rt2x00dev, 21, 0xdb); 
     1738+       rt2800usb_rfcsr_write(rt2x00dev, 24, 0x16); 
     1739+       rt2800usb_rfcsr_write(rt2x00dev, 25, 0x01); 
     1740+       rt2800usb_rfcsr_write(rt2x00dev, 27, 0x03); 
     1741+       rt2800usb_rfcsr_write(rt2x00dev, 29, 0x1f); 
     1742+ 
     1743+       /* 
     1744+        * Set RX Filter calibration for 20MHz and 40MHz 
     1745+        */ 
     1746+       rt2x00dev->calibration_bw20 = 
     1747+           rt2800usb_init_rx_filter(rt2x00dev, false, 0x07, 0x16); 
     1748+       rt2x00dev->calibration_bw40 = 
     1749+           rt2800usb_init_rx_filter(rt2x00dev, true, 0x27, 0x19); 
     1750+ 
     1751+       /* 
     1752+        * Set back to initial state 
     1753+        */ 
     1754+       rt2800usb_bbp_write(rt2x00dev, 24, 0); 
     1755+ 
     1756+       rt2800usb_rfcsr_read(rt2x00dev, 22, &rfcsr); 
     1757+       rt2x00_set_field8(&rfcsr, RFCSR22_BASEBAND_LOOPBACK, 0); 
     1758+       rt2800usb_rfcsr_write(rt2x00dev, 22, rfcsr); 
     1759+ 
     1760+       /* 
     1761+        * set BBP back to BW20 
     1762+        */ 
     1763+       rt2800usb_bbp_read(rt2x00dev, 4, &bbp); 
     1764+       rt2x00_set_field8(&bbp, BBP4_BANDWIDTH, 0); 
     1765+       rt2800usb_bbp_write(rt2x00dev, 4, bbp); 
     1766+ 
     1767+       return 0; 
     1768+} 
     1769+ 
    14481770+/* 
    14491771+ * Device state switch handlers. 
     
    14891811+       if (unlikely(rt2800usb_wait_wpdma_ready(rt2x00dev) || 
    14901812+                    rt2800usb_init_registers(rt2x00dev) || 
    1491 +                    rt2800usb_init_bbp(rt2x00dev))) 
     1813+                    rt2800usb_init_bbp(rt2x00dev) || 
     1814+                    rt2800usb_init_rfcsr(rt2x00dev))) 
    14921815+               return -EIO; 
    14931816+ 
     
    16371960+{ 
    16381961+       struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb); 
    1639 +       __le32 *txd = skbdesc->desc; 
    1640 +       __le32 *txwi = txd + TXD_DESC_SIZE; 
     1962+       __le32 *txi = skbdesc->desc; 
     1963+       __le32 *txwi = txi + TXINFO_DESC_SIZE; 
    16411964+       u32 word; 
    16421965+ 
     
    16852008+        * Initialize TX descriptor 
    16862009+        */ 
    1687 +       rt2x00_desc_read(txd, 0, &word); 
    1688 +       rt2x00_set_field32(&word, TXD_W0_SD_PTR0, skbdesc->skb_dma); 
    1689 +       rt2x00_desc_write(txd, 0, word); 
    1690 + 
    1691 +       rt2x00_desc_read(txd, 1, &word); 
    1692 +       rt2x00_set_field32(&word, TXD_W1_SD_LEN1, skb->len); 
    1693 +       rt2x00_set_field32(&word, TXD_W1_LAST_SEC1, 1); 
    1694 +       rt2x00_set_field32(&word, TXD_W1_BURST, 
     2010+       rt2x00_desc_read(txi, 0, &word); 
     2011+       rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN, 
     2012+                          roundup(skb->len + TXWI_DESC_SIZE, 4)); 
     2013+       rt2x00_set_field32(&word, TXINFO_W0_WIV, 1); 
     2014+       rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2); 
     2015+       rt2x00_set_field32(&word, TXINFO_W0_SW_USE_LAST_ROUND, 0); 
     2016+       rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_NEXT_VALID, 0); 
     2017+       rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_BURST, 
    16952018+                          test_bit(ENTRY_TXD_BURST, &txdesc->flags)); 
    1696 +       rt2x00_set_field32(&word, TXD_W1_SD_LEN0, 
    1697 +                          rt2x00dev->hw->extra_tx_headroom); 
    1698 +       rt2x00_set_field32(&word, TXD_W1_LAST_SEC0, 
    1699 +                          !test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags)); 
    1700 +       rt2x00_set_field32(&word, TXD_W1_DMA_DONE, 0); 
    1701 +       rt2x00_desc_write(txd, 1, word); 
    1702 + 
    1703 +       rt2x00_desc_read(txd, 2, &word); 
    1704 +       rt2x00_set_field32(&word, TXD_W2_SD_PTR1, 
    1705 +                          skbdesc->skb_dma + rt2x00dev->hw->extra_tx_headroom); 
    1706 +       rt2x00_desc_write(txd, 2, word); 
    1707 + 
    1708 +       rt2x00_desc_read(txd, 3, &word); 
    1709 +       rt2x00_set_field32(&word, TXD_W3_WIV, 1); 
    1710 +       rt2x00_set_field32(&word, TXD_W3_QSEL, 2); 
    1711 +       rt2x00_desc_write(txd, 3, word); 
     2019+       rt2x00_desc_write(txi, 0, word); 
    17122020+} 
    17132021+ 
     
    18832191+ 
    18842192+       /* 
    1885 +        * Remove TXWI descriptor from start of buffer. 
    1886 +        */ 
    1887 +       skb_pull(entry->skb, TXWI_DESC_SIZE + skbdesc->desc_len); 
     2193+        * Remove RXWI descriptor from start of buffer. 
     2194+        */ 
     2195+       skb_pull(entry->skb, RXWI_DESC_SIZE + skbdesc->desc_len); 
    18882196+       skb_trim(entry->skb, rxdesc->size); 
    18892197+} 
     
    19212229+ 
    19222230+       rt2x00_eeprom_read(rt2x00dev, EEPROM_NIC, &word); 
    1923 +       if (word != 0) { 
    1924 +               /* NIC configuration must always be 0. */ 
    1925 +               word = 0; 
     2231+       if (word == 0xffff) { 
     2232+               rt2x00_set_field16(&word, EEPROM_NIC_HW_RADIO, 0); 
     2233+               rt2x00_set_field16(&word, EEPROM_NIC_DYNAMIC_TX_AGC, 0); 
     2234+               rt2x00_set_field16(&word, EEPROM_NIC_EXTERNAL_LNA_BG, 0); 
     2235+               rt2x00_set_field16(&word, EEPROM_NIC_EXTERNAL_LNA_A, 0); 
     2236+               rt2x00_set_field16(&word, EEPROM_NIC_CARDBUS_ACCEL, 0); 
     2237+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_SB_BG, 0); 
     2238+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_SB_A, 0); 
     2239+               rt2x00_set_field16(&word, EEPROM_NIC_WPS_PBC, 0); 
     2240+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_BG, 0); 
     2241+               rt2x00_set_field16(&word, EEPROM_NIC_BW40M_A, 0); 
    19262242+               rt2x00_eeprom_write(rt2x00dev, EEPROM_NIC, word); 
    19272243+               EEPROM(rt2x00dev, "NIC: 0x%04x\n", word); 
     
    19872303+{ 
    19882304+       u32 reg; 
    1989 +       u16 rev; 
    19902305+       u16 value; 
    19912306+       u16 eeprom; 
     
    20012316+       value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RF_TYPE); 
    20022317+       rt2x00usb_register_read(rt2x00dev, MAC_CSR0, &reg); 
    2003 +       rev = rt2x00_get_field32(reg, MAC_CSR0_ASIC_REV); 
    2004 +       rt2x00_set_chip(rt2x00dev, RT2870, value, rev); 
     2318+       rt2x00_set_chip(rt2x00dev, RT2870, value, reg); 
    20052319+ 
    20062320+       /* 
     
    20172331+           !rt2x00_rf(&rt2x00dev->chip, RF2850) && 
    20182332+           !rt2x00_rf(&rt2x00dev->chip, RF2720) && 
    2019 +           !rt2x00_rf(&rt2x00dev->chip, RF2750)) { 
     2333+           !rt2x00_rf(&rt2x00dev->chip, RF2750) && 
     2334+           !rt2x00_rf(&rt2x00dev->chip, RF3020) && 
     2335+           !rt2x00_rf(&rt2x00dev->chip, RF2020)) { 
    20202336+               ERROR(rt2x00dev, "Invalid RF chipset detected.\n"); 
    20212337+               return -ENODEV; 
     
    21322448+}; 
    21332449+ 
     2450+/* 
     2451+ * RF value list for rt3070 
     2452+ * Supports: 2.4 GHz 
     2453+ */ 
     2454+static const struct rf_channel rf_vals_3070[] = { 
     2455+       {1,  241, 2, 2 }, 
     2456+       {2,  241, 2, 7 }, 
     2457+       {3,  242, 2, 2 }, 
     2458+       {4,  242, 2, 7 }, 
     2459+       {5,  243, 2, 2 }, 
     2460+       {6,  243, 2, 7 }, 
     2461+       {7,  244, 2, 2 }, 
     2462+       {8,  244, 2, 7 }, 
     2463+       {9,  245, 2, 2 }, 
     2464+       {10, 245, 2, 7 }, 
     2465+       {11, 246, 2, 2 }, 
     2466+       {12, 246, 2, 7 }, 
     2467+       {13, 247, 2, 2 }, 
     2468+       {14, 248, 2, 4 }, 
     2469+}; 
     2470+ 
    21342471+static int rt2800usb_probe_hw_mode(struct rt2x00_dev *rt2x00dev) 
    21352472+{ 
     
    21452482+       rt2x00dev->hw->flags = 
    21462483+           IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING | 
    2147 +           IEEE80211_HW_SIGNAL_DBM; 
    2148 +       rt2x00dev->hw->extra_tx_headroom = TXD_DESC_SIZE + TXINFO_DESC_SIZE; 
     2484+           IEEE80211_HW_SIGNAL_DBM | 
     2485+           IEEE80211_HW_SUPPORTS_PS | 
     2486+           IEEE80211_HW_PS_NULLFUNC_STACK; 
     2487+       rt2x00dev->hw->extra_tx_headroom = TXINFO_DESC_SIZE + TXWI_DESC_SIZE; 
    21492488+ 
    21502489+       SET_IEEE80211_DEV(rt2x00dev->hw, rt2x00dev->dev); 
     
    21872526+               spec->num_channels = ARRAY_SIZE(rf_vals); 
    21882527+               spec->channels = rf_vals; 
     2528+       } else if (rt2x00_rf(&rt2x00dev->chip, RF3020) || 
     2529+                  rt2x00_rf(&rt2x00dev->chip, RF2020)) { 
     2530+               spec->num_channels = ARRAY_SIZE(rf_vals_3070); 
     2531+               spec->channels = rf_vals_3070; 
    21892532+       } 
    21902533+ 
     
    22642607+       struct rt2x00_dev *rt2x00dev = hw->priv; 
    22652608+       u32 reg; 
     2609+       bool enabled = (value < IEEE80211_MAX_RTS_THRESHOLD); 
    22662610+ 
    22672611+       rt2x00usb_register_read(rt2x00dev, TX_RTS_CFG, &reg); 
     
    22702614+ 
    22712615+       rt2x00usb_register_read(rt2x00dev, CCK_PROT_CFG, &reg); 
    2272 +       rt2x00_set_field32(&reg, CCK_PROT_CFG_RTS_TH_EN, 1); 
     2616+       rt2x00_set_field32(&reg, CCK_PROT_CFG_RTS_TH_EN, enabled); 
    22732617+       rt2x00usb_register_write(rt2x00dev, CCK_PROT_CFG, reg); 
    22742618+ 
    22752619+       rt2x00usb_register_read(rt2x00dev, OFDM_PROT_CFG, &reg); 
    2276 +       rt2x00_set_field32(&reg, OFDM_PROT_CFG_RTS_TH_EN, 1); 
     2620+       rt2x00_set_field32(&reg, OFDM_PROT_CFG_RTS_TH_EN, enabled); 
    22772621+       rt2x00usb_register_write(rt2x00dev, OFDM_PROT_CFG, reg); 
    22782622+ 
    22792623+       rt2x00usb_register_read(rt2x00dev, MM20_PROT_CFG, &reg); 
    2280 +       rt2x00_set_field32(&reg, MM20_PROT_CFG_RTS_TH_EN, 1); 
     2624+       rt2x00_set_field32(&reg, MM20_PROT_CFG_RTS_TH_EN, enabled); 
    22812625+       rt2x00usb_register_write(rt2x00dev, MM20_PROT_CFG, reg); 
    22822626+ 
    22832627+       rt2x00usb_register_read(rt2x00dev, MM40_PROT_CFG, &reg); 
    2284 +       rt2x00_set_field32(&reg, MM40_PROT_CFG_RTS_TH_EN, 1); 
     2628+       rt2x00_set_field32(&reg, MM40_PROT_CFG_RTS_TH_EN, enabled); 
    22852629+       rt2x00usb_register_write(rt2x00dev, MM40_PROT_CFG, reg); 
    22862630+ 
    22872631+       rt2x00usb_register_read(rt2x00dev, GF20_PROT_CFG, &reg); 
    2288 +       rt2x00_set_field32(&reg, GF20_PROT_CFG_RTS_TH_EN, 1); 
     2632+       rt2x00_set_field32(&reg, GF20_PROT_CFG_RTS_TH_EN, enabled); 
    22892633+       rt2x00usb_register_write(rt2x00dev, GF20_PROT_CFG, reg); 
    22902634+ 
    22912635+       rt2x00usb_register_read(rt2x00dev, GF40_PROT_CFG, &reg); 
    2292 +       rt2x00_set_field32(&reg, GF40_PROT_CFG_RTS_TH_EN, 1); 
     2636+       rt2x00_set_field32(&reg, GF40_PROT_CFG_RTS_TH_EN, enabled); 
    22932637+       rt2x00usb_register_write(rt2x00dev, GF40_PROT_CFG, reg); 
    22942638+ 
     
    23162660+               return retval; 
    23172661+ 
     2662+       /* 
     2663+        * We only need to perform additional register initialization 
     2664+        * for WMM queues/ 
     2665+        */ 
     2666+       if (queue_idx >= 4) 
     2667+               return 0; 
     2668+ 
    23182669+       queue = rt2x00queue_get_queue(rt2x00dev, queue_idx); 
    23192670+ 
    23202671+       /* Update WMM TXOP register */ 
    2321 +       if (queue_idx < 2) { 
    2322 +               field.bit_offset = queue_idx * 16; 
    2323 +               field.bit_mask = 0xffff << field.bit_offset; 
    2324 + 
    2325 +               rt2x00usb_register_read(rt2x00dev, WMM_TXOP0_CFG, &reg); 
    2326 +               rt2x00_set_field32(&reg, field, queue->txop); 
    2327 +               rt2x00usb_register_write(rt2x00dev, WMM_TXOP0_CFG, reg); 
    2328 +       } else if (queue_idx < 4) { 
    2329 +               field.bit_offset = (queue_idx - 2) * 16; 
    2330 +               field.bit_mask = 0xffff << field.bit_offset; 
    2331 + 
    2332 +               rt2x00usb_register_read(rt2x00dev, WMM_TXOP1_CFG, &reg); 
    2333 +               rt2x00_set_field32(&reg, field, queue->txop); 
    2334 +               rt2x00usb_register_write(rt2x00dev, WMM_TXOP1_CFG, reg); 
    2335 +       } 
     2672+       offset = WMM_TXOP0_CFG + (sizeof(u32) * (!!(queue_idx & 2))); 
     2673+       field.bit_offset = (queue_idx & 1) * 16; 
     2674+       field.bit_mask = 0xffff << field.bit_offset; 
     2675+ 
     2676+       rt2x00usb_register_read(rt2x00dev, offset, &reg); 
     2677+       rt2x00_set_field32(&reg, field, queue->txop); 
     2678+       rt2x00usb_register_write(rt2x00dev, offset, reg); 
    23362679+ 
    23372680+       /* Update WMM registers */ 
     
    23522695+ 
    23532696+       /* Update EDCA registers */ 
    2354 +       if (queue_idx < 4) { 
    2355 +               offset = EDCA_AC0_CFG + (sizeof(u32) * queue_idx); 
    2356 + 
    2357 +               rt2x00usb_register_read(rt2x00dev, offset, &reg); 
    2358 +               rt2x00_set_field32(&reg, EDCA_AC0_CFG_AIFSN, queue->aifs); 
    2359 +               rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMIN, queue->cw_min); 
    2360 +               rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMAX, queue->cw_max); 
    2361 +               rt2x00usb_register_write(rt2x00dev, offset, reg); 
    2362 +       } 
     2697+       offset = EDCA_AC0_CFG + (sizeof(u32) * queue_idx); 
     2698+ 
     2699+       rt2x00usb_register_read(rt2x00dev, offset, &reg); 
     2700+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_TX_OP, queue->txop); 
     2701+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_AIFSN, queue->aifs); 
     2702+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMIN, queue->cw_min); 
     2703+       rt2x00_set_field32(&reg, EDCA_AC0_CFG_CWMAX, queue->cw_max); 
     2704+       rt2x00usb_register_write(rt2x00dev, offset, reg); 
    23632705+ 
    23642706+       return 0; 
     
    24452787+       .entry_num              = TX_ENTRIES, 
    24462788+       .data_size              = DATA_FRAME_SIZE, 
    2447 +       .desc_size              = TXD_DESC_SIZE, 
     2789+       .desc_size              = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, 
    24482790+       .priv_size              = sizeof(struct queue_entry_priv_usb), 
    24492791+}; 
     
    24522794+       .entry_num              = 8 * BEACON_ENTRIES, 
    24532795+       .data_size              = MGMT_FRAME_SIZE, 
    2454 +       .desc_size              = TXWI_DESC_SIZE, 
     2796+       .desc_size              = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, 
    24552797+       .priv_size              = sizeof(struct queue_entry_priv_usb), 
    24562798+}; 
     
    24772819+ */ 
    24782820+static struct usb_device_id rt2800usb_device_table[] = { 
     2821+       /* Abocom */ 
     2822+       { USB_DEVICE(0x07b8, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2823+       { USB_DEVICE(0x07b8, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2824+       { USB_DEVICE(0x07b8, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2825+       { USB_DEVICE(0x07b8, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2826+       { USB_DEVICE(0x1482, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    24792827+       /* Amit */ 
    24802828+       { USB_DEVICE(0x15c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    24872835+       /* Belkin */ 
    24882836+       { USB_DEVICE(0x050d, 0x8053), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2837+       { USB_DEVICE(0x050d, 0x805c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    24892838+       /* Conceptronic */ 
    24902839+       { USB_DEVICE(0x14b2, 0x3c06), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    24912840+       { USB_DEVICE(0x14b2, 0x3c07), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2841+       { USB_DEVICE(0x14b2, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2842+       { USB_DEVICE(0x14b2, 0x3c12), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    24922843+       { USB_DEVICE(0x14b2, 0x3c23), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    24932844+       { USB_DEVICE(0x14b2, 0x3c25), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    24982849+       { USB_DEVICE(0x07aa, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    24992850+       { USB_DEVICE(0x07aa, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2851+       { USB_DEVICE(0x18c5, 0x0012), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25002852+       /* D-Link */ 
    25012853+       { USB_DEVICE(0x07d1, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25022854+       { USB_DEVICE(0x07d1, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2855+       /* Edimax */ 
     2856+       { USB_DEVICE(0x7392, 0x7711), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25032857+       /* EnGenius */ 
    25042858+       { USB_DEVICE(0X1740, 0x9701), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    25112865+       /* Linksys */ 
    25122866+       { USB_DEVICE(0x1737, 0x0071), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2867+       /* Logitec */ 
     2868+       { USB_DEVICE(0x0789, 0x0162), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2869+       { USB_DEVICE(0x0789, 0x0163), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2870+       { USB_DEVICE(0x0789, 0x0164), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25132871+       /* Philips */ 
    25142872+       { USB_DEVICE(0x0471, 0x200f), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25152873+       /* Planex */ 
    25162874+       { USB_DEVICE(0x2019, 0xed06), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2875+       { USB_DEVICE(0x2019, 0xab25), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25172876+       /* Ralink */ 
    25182877+       { USB_DEVICE(0x148f, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25192878+       { USB_DEVICE(0x148f, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2879+       { USB_DEVICE(0x148f, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2880+       /* Samsung */ 
     2881+       { USB_DEVICE(0x04e8, 0x2018), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25202882+       /* Siemens */ 
    25212883+       { USB_DEVICE(0x129b, 0x1828), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    25372899+       { USB_DEVICE(0x0cde, 0x0022), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25382900+       { USB_DEVICE(0x0cde, 0x0025), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2901+       /* Zinwell */ 
     2902+       { USB_DEVICE(0x5a57, 0x0280), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     2903+       { USB_DEVICE(0x5a57, 0x0282), USB_DEVICE_DATA(&rt2800usb_ops) }, 
    25392904+       /* Zyxel */ 
    25402905+       { USB_DEVICE(0x0586, 0x3416), USB_DEVICE_DATA(&rt2800usb_ops) }, 
     
    25732938--- /dev/null 
    25742939+++ b/drivers/net/wireless/rt2x00/rt2800usb.h 
    2575 @@ -0,0 +1,1892 @@ 
    2576 +/* 
    2577 +       Copyright (C) 2004 - 2008 rt2x00 SourceForge Project 
     2940@@ -0,0 +1,1944 @@ 
     2941+/* 
     2942+       Copyright (C) 2004 - 2009 rt2x00 SourceForge Project 
    25782943+       <http://rt2x00.serialmonkey.com> 
    25792944+ 
     
    26232988+ * RT2870 version 
    26242989+ */ 
    2625 +#define RT2870_VERSION_C               0x0100 
    2626 +#define RT2870_VERSION_D               0x0101 
    2627 +#define RT2870_VERSION_E               0x0200 
     2990+#define RT2860C_VERSION                        0x28600100 
     2991+#define RT2860D_VERSION                        0x28600101 
     2992+#define RT2880E_VERSION                        0x28720200 
     2993+#define RT2883_VERSION                 0x28830300 
     2994+#define RT3070_VERSION                 0x30700200 
    26282995+ 
    26292996+/* 
     
    29593326+ 
    29603327+/* 
     3328+ * RF registers 
     3329+ */ 
     3330+#define        RF_CSR_CFG                      0x0500 
     3331+#define RF_CSR_CFG_DATA                        FIELD32(0x000000ff) 
     3332+#define RF_CSR_CFG_REGNUM              FIELD32(0x00001f00) 
     3333+#define RF_CSR_CFG_WRITE               FIELD32(0x00010000) 
     3334+#define RF_CSR_CFG_BUSY                        FIELD32(0x00020000) 
     3335+ 
     3336+/* 
    29613337+ * MAC Control/Status Registers(CSR). 
    29623338+ * Some values are set in TU, whereas 1 TU == 1024 us. 
     
    32463622+ */ 
    32473623+#define EDCA_AC0_CFG                   0x1300 
    3248 +#define EDCA_AC0_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3624+#define EDCA_AC0_CFG_TX_OP             FIELD32(0x000000ff) 
    32493625+#define EDCA_AC0_CFG_AIFSN             FIELD32(0x00000f00) 
    32503626+#define EDCA_AC0_CFG_CWMIN             FIELD32(0x0000f000) 
     
    32553631+ */ 
    32563632+#define EDCA_AC1_CFG                   0x1304 
    3257 +#define EDCA_AC1_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3633+#define EDCA_AC1_CFG_TX_OP             FIELD32(0x000000ff) 
    32583634+#define EDCA_AC1_CFG_AIFSN             FIELD32(0x00000f00) 
    32593635+#define EDCA_AC1_CFG_CWMIN             FIELD32(0x0000f000) 
     
    32643640+ */ 
    32653641+#define EDCA_AC2_CFG                   0x1308 
    3266 +#define EDCA_AC2_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3642+#define EDCA_AC2_CFG_TX_OP             FIELD32(0x000000ff) 
    32673643+#define EDCA_AC2_CFG_AIFSN             FIELD32(0x00000f00) 
    32683644+#define EDCA_AC2_CFG_CWMIN             FIELD32(0x0000f000) 
     
    32733649+ */ 
    32743650+#define EDCA_AC3_CFG                   0x130c 
    3275 +#define EDCA_AC3_CFG_AC_TX_OP          FIELD32(0x000000ff) 
     3651+#define EDCA_AC3_CFG_TX_OP             FIELD32(0x000000ff) 
    32763652+#define EDCA_AC3_CFG_AIFSN             FIELD32(0x00000f00) 
    32773653+#define EDCA_AC3_CFG_CWMIN             FIELD32(0x0000f000) 
     
    40584434+ 
    40594435+/* 
     4436+ * BBP 4: Bandwidth 
     4437+ */ 
     4438+#define BBP4_BANDWIDTH                 FIELD8(0x18) 
     4439+ 
     4440+/* 
     4441+ * RFCSR registers 
     4442+ * The wordsize of the RFCSR is 8 bits. 
     4443+ */ 
     4444+ 
     4445+/* 
     4446+ * RFCSR 6: 
     4447+ */ 
     4448+#define RFCSR6_R                       FIELD8(0x03) 
     4449+ 
     4450+/* 
     4451+ * RFCSR 7: 
     4452+ */ 
     4453+#define RFCSR7_RF_TUNING               FIELD8(0x01) 
     4454+ 
     4455+/* 
     4456+ * RFCSR 12: 
     4457+ */ 
     4458+#define RFCSR12_TX_POWER               FIELD8(0x1f) 
     4459+ 
     4460+/* 
     4461+ * RFCSR 22: 
     4462+ */ 
     4463+#define RFCSR22_BASEBAND_LOOPBACK      FIELD8(0x01) 
     4464+ 
     4465+/* 
     4466+ * RFCSR 23: 
     4467+ */ 
     4468+#define RFCSR23_FREQ_OFFSET            FIELD8(0x7f) 
     4469+ 
     4470+/* 
     4471+ * RFCSR 30: 
     4472+ */ 
     4473+#define RFCSR30_RF_CALIBRATION         FIELD8(0x80) 
     4474+ 
     4475+/* 
    40604476+ * RF registers 
    40614477+ */ 
     
    43204736+#define TXINFO_W0_WIV                  FIELD32(0x01000000) 
    43214737+#define TXINFO_W0_QSEL                 FIELD32(0x06000000) 
     4738+#define TXINFO_W0_SW_USE_LAST_ROUND    FIELD32(0x08000000) 
    43224739+#define TXINFO_W0_USB_DMA_NEXT_VALID   FIELD32(0x40000000) 
    43234740+#define TXINFO_W0_USB_DMA_TX_BURST     FIELD32(0x80000000) 
     
    44764893        u16 rf; 
    44774894        u32 rev; 
     4895@@ -778,6 +779,12 @@ struct rt2x00_dev { 
     4896        u8 freq_offset; 
     4897  
     4898        /* 
     4899+        * Calibration information (for rt2800usb). 
     4900+        */ 
     4901+       u8 calibration_bw20; 
     4902+       u8 calibration_bw40; 
     4903+ 
     4904+       /* 
     4905         * Low level statistics which will have 
     4906         * to be kept up to date while device is running. 
     4907         */ 
Note: See TracChangeset for help on using the changeset viewer.