← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/net/wireless/rt2x00/rt2800lib.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/wireless/rt2x00/rt2800lib.c
38
38
#include <linux/kernel.h>
39
39
#include <linux/module.h>
40
40
#include <linux/slab.h>
41
 
#include <linux/sched.h>
42
41
 
43
42
#include "rt2x00.h"
44
43
#include "rt2800lib.h"
402
401
                return -EBUSY;
403
402
 
404
403
        if (rt2x00_is_pci(rt2x00dev)) {
405
 
                if (rt2x00_rt(rt2x00dev, RT5390)) {
 
404
                if (rt2x00_rt(rt2x00dev, RT3572) ||
 
405
                    rt2x00_rt(rt2x00dev, RT5390)) {
406
406
                        rt2800_register_read(rt2x00dev, AUX_CTRL, &reg);
407
407
                        rt2x00_set_field32(&reg, AUX_CTRL_FORCE_PCIE_CLK, 1);
408
408
                        rt2x00_set_field32(&reg, AUX_CTRL_WAKE_PCIE_EN, 1);
493
493
        rt2x00_set_field32(&word, TXWI_W1_BW_WIN_SIZE, txdesc->u.ht.ba_size);
494
494
        rt2x00_set_field32(&word, TXWI_W1_WIRELESS_CLI_ID,
495
495
                           test_bit(ENTRY_TXD_ENCRYPT, &txdesc->flags) ?
496
 
                           txdesc->key_idx : 0xff);
 
496
                           txdesc->key_idx : txdesc->u.ht.wcid);
497
497
        rt2x00_set_field32(&word, TXWI_W1_MPDU_TOTAL_BYTE_COUNT,
498
498
                           txdesc->length);
499
499
        rt2x00_set_field32(&word, TXWI_W1_PACKETID_QUEUE, entry->queue->qid);
601
601
}
602
602
EXPORT_SYMBOL_GPL(rt2800_process_rxwi);
603
603
 
604
 
static bool rt2800_txdone_entry_check(struct queue_entry *entry, u32 reg)
605
 
{
606
 
        __le32 *txwi;
607
 
        u32 word;
608
 
        int wcid, ack, pid;
609
 
        int tx_wcid, tx_ack, tx_pid;
610
 
 
611
 
        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
612
 
            !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) {
613
 
                WARNING(entry->queue->rt2x00dev,
614
 
                        "Data pending for entry %u in queue %u\n",
615
 
                        entry->entry_idx, entry->queue->qid);
616
 
                cond_resched();
617
 
                return false;
618
 
        }
619
 
 
620
 
        wcid    = rt2x00_get_field32(reg, TX_STA_FIFO_WCID);
621
 
        ack     = rt2x00_get_field32(reg, TX_STA_FIFO_TX_ACK_REQUIRED);
622
 
        pid     = rt2x00_get_field32(reg, TX_STA_FIFO_PID_TYPE);
623
 
 
624
 
        /*
625
 
         * This frames has returned with an IO error,
626
 
         * so the status report is not intended for this
627
 
         * frame.
628
 
         */
629
 
        if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags)) {
630
 
                rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE);
631
 
                return false;
632
 
        }
633
 
 
634
 
        /*
635
 
         * Validate if this TX status report is intended for
636
 
         * this entry by comparing the WCID/ACK/PID fields.
637
 
         */
638
 
        txwi = rt2800_drv_get_txwi(entry);
639
 
 
640
 
        rt2x00_desc_read(txwi, 1, &word);
641
 
        tx_wcid = rt2x00_get_field32(word, TXWI_W1_WIRELESS_CLI_ID);
642
 
        tx_ack  = rt2x00_get_field32(word, TXWI_W1_ACK);
643
 
        tx_pid  = rt2x00_get_field32(word, TXWI_W1_PACKETID);
644
 
 
645
 
        if ((wcid != tx_wcid) || (ack != tx_ack) || (pid != tx_pid)) {
646
 
                WARNING(entry->queue->rt2x00dev,
647
 
                        "TX status report missed for queue %d entry %d\n",
648
 
                entry->queue->qid, entry->entry_idx);
649
 
                rt2x00lib_txdone_noinfo(entry, TXDONE_UNKNOWN);
650
 
                return false;
651
 
        }
652
 
 
653
 
        return true;
654
 
}
655
 
 
656
 
void rt2800_txdone_entry(struct queue_entry *entry, u32 status)
 
604
void rt2800_txdone_entry(struct queue_entry *entry, u32 status, __le32 *txwi)
657
605
{
658
606
        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
659
607
        struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
661
609
        u32 word;
662
610
        u16 mcs, real_mcs;
663
611
        int aggr, ampdu;
664
 
        __le32 *txwi;
665
612
 
666
613
        /*
667
614
         * Obtain the status about this packet.
668
615
         */
669
616
        txdesc.flags = 0;
670
 
        txwi = rt2800_drv_get_txwi(entry);
671
617
        rt2x00_desc_read(txwi, 0, &word);
672
618
 
673
619
        mcs = rt2x00_get_field32(word, TXWI_W0_MCS);
735
681
}
736
682
EXPORT_SYMBOL_GPL(rt2800_txdone_entry);
737
683
 
738
 
void rt2800_txdone(struct rt2x00_dev *rt2x00dev)
739
 
{
740
 
        struct data_queue *queue;
741
 
        struct queue_entry *entry;
742
 
        u32 reg;
743
 
        u8 qid;
744
 
 
745
 
        while (kfifo_get(&rt2x00dev->txstatus_fifo, &reg)) {
746
 
 
747
 
                /* TX_STA_FIFO_PID_QUEUE is a 2-bit field, thus
748
 
                 * qid is guaranteed to be one of the TX QIDs
749
 
                 */
750
 
                qid = rt2x00_get_field32(reg, TX_STA_FIFO_PID_QUEUE);
751
 
                queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);
752
 
                if (unlikely(!queue)) {
753
 
                        WARNING(rt2x00dev, "Got TX status for an unavailable "
754
 
                                           "queue %u, dropping\n", qid);
755
 
                        continue;
756
 
                }
757
 
 
758
 
                /*
759
 
                 * Inside each queue, we process each entry in a chronological
760
 
                 * order. We first check that the queue is not empty.
761
 
                 */
762
 
                entry = NULL;
763
 
                while (!rt2x00queue_empty(queue)) {
764
 
                        entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
765
 
                        if (rt2800_txdone_entry_check(entry, reg))
766
 
                                break;
767
 
                        entry = NULL;
768
 
                }
769
 
 
770
 
                if (entry)
771
 
                        rt2800_txdone_entry(entry, reg);
772
 
        }
773
 
}
774
 
EXPORT_SYMBOL_GPL(rt2800_txdone);
775
 
 
776
684
void rt2800_write_beacon(struct queue_entry *entry, struct txentry_desc *txdesc)
777
685
{
778
686
        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
989
897
        }
990
898
}
991
899
 
992
 
static int rt2800_blink_set(struct led_classdev *led_cdev,
993
 
                            unsigned long *delay_on, unsigned long *delay_off)
994
 
{
995
 
        struct rt2x00_led *led =
996
 
            container_of(led_cdev, struct rt2x00_led, led_dev);
997
 
        u32 reg;
998
 
 
999
 
        rt2800_register_read(led->rt2x00dev, LED_CFG, &reg);
1000
 
        rt2x00_set_field32(&reg, LED_CFG_ON_PERIOD, *delay_on);
1001
 
        rt2x00_set_field32(&reg, LED_CFG_OFF_PERIOD, *delay_off);
1002
 
        rt2800_register_write(led->rt2x00dev, LED_CFG, reg);
1003
 
 
1004
 
        return 0;
1005
 
}
1006
 
 
1007
900
static void rt2800_init_led(struct rt2x00_dev *rt2x00dev,
1008
901
                     struct rt2x00_led *led, enum led_type type)
1009
902
{
1010
903
        led->rt2x00dev = rt2x00dev;
1011
904
        led->type = type;
1012
905
        led->led_dev.brightness_set = rt2800_brightness_set;
1013
 
        led->led_dev.blink_set = rt2800_blink_set;
1014
906
        led->flags = LED_INITIALIZED;
1015
907
}
1016
908
#endif /* CONFIG_RT2X00_LIB_LEDS */
1018
910
/*
1019
911
 * Configuration handlers.
1020
912
 */
1021
 
static void rt2800_config_wcid_attr(struct rt2x00_dev *rt2x00dev,
1022
 
                                    struct rt2x00lib_crypto *crypto,
1023
 
                                    struct ieee80211_key_conf *key)
 
913
static void rt2800_config_wcid(struct rt2x00_dev *rt2x00dev,
 
914
                               const u8 *address,
 
915
                               int wcid)
1024
916
{
1025
917
        struct mac_wcid_entry wcid_entry;
 
918
        u32 offset;
 
919
 
 
920
        offset = MAC_WCID_ENTRY(wcid);
 
921
 
 
922
        memset(&wcid_entry, 0xff, sizeof(wcid_entry));
 
923
        if (address)
 
924
                memcpy(wcid_entry.mac, address, ETH_ALEN);
 
925
 
 
926
        rt2800_register_multiwrite(rt2x00dev, offset,
 
927
                                      &wcid_entry, sizeof(wcid_entry));
 
928
}
 
929
 
 
930
static void rt2800_delete_wcid_attr(struct rt2x00_dev *rt2x00dev, int wcid)
 
931
{
 
932
        u32 offset;
 
933
        offset = MAC_WCID_ATTR_ENTRY(wcid);
 
934
        rt2800_register_write(rt2x00dev, offset, 0);
 
935
}
 
936
 
 
937
static void rt2800_config_wcid_attr_bssidx(struct rt2x00_dev *rt2x00dev,
 
938
                                           int wcid, u32 bssidx)
 
939
{
 
940
        u32 offset = MAC_WCID_ATTR_ENTRY(wcid);
 
941
        u32 reg;
 
942
 
 
943
        /*
 
944
         * The BSS Idx numbers is split in a main value of 3 bits,
 
945
         * and a extended field for adding one additional bit to the value.
 
946
         */
 
947
        rt2800_register_read(rt2x00dev, offset, &reg);
 
948
        rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_BSS_IDX, (bssidx & 0x7));
 
949
        rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_BSS_IDX_EXT,
 
950
                           (bssidx & 0x8) >> 3);
 
951
        rt2800_register_write(rt2x00dev, offset, reg);
 
952
}
 
953
 
 
954
static void rt2800_config_wcid_attr_cipher(struct rt2x00_dev *rt2x00dev,
 
955
                                           struct rt2x00lib_crypto *crypto,
 
956
                                           struct ieee80211_key_conf *key)
 
957
{
1026
958
        struct mac_iveiv_entry iveiv_entry;
1027
959
        u32 offset;
1028
960
        u32 reg;
1042
974
                                   (crypto->cipher & 0x7));
1043
975
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_CIPHER_EXT,
1044
976
                                   (crypto->cipher & 0x8) >> 3);
1045
 
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_BSS_IDX,
1046
 
                                   (crypto->bssidx & 0x7));
1047
 
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_BSS_IDX_EXT,
1048
 
                                   (crypto->bssidx & 0x8) >> 3);
1049
977
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_RX_WIUDF, crypto->cipher);
1050
978
                rt2800_register_write(rt2x00dev, offset, reg);
1051
979
        } else {
1052
 
                rt2800_register_write(rt2x00dev, offset, 0);
 
980
                /* Delete the cipher without touching the bssidx */
 
981
                rt2800_register_read(rt2x00dev, offset, &reg);
 
982
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_KEYTAB, 0);
 
983
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_CIPHER, 0);
 
984
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_CIPHER_EXT, 0);
 
985
                rt2x00_set_field32(&reg, MAC_WCID_ATTRIBUTE_RX_WIUDF, 0);
 
986
                rt2800_register_write(rt2x00dev, offset, reg);
1053
987
        }
1054
988
 
1055
989
        offset = MAC_IVEIV_ENTRY(key->hw_key_idx);
1062
996
        iveiv_entry.iv[3] |= key->keyidx << 6;
1063
997
        rt2800_register_multiwrite(rt2x00dev, offset,
1064
998
                                      &iveiv_entry, sizeof(iveiv_entry));
1065
 
 
1066
 
        offset = MAC_WCID_ENTRY(key->hw_key_idx);
1067
 
 
1068
 
        memset(&wcid_entry, 0, sizeof(wcid_entry));
1069
 
        if (crypto->cmd == SET_KEY)
1070
 
                memcpy(wcid_entry.mac, crypto->address, ETH_ALEN);
1071
 
        rt2800_register_multiwrite(rt2x00dev, offset,
1072
 
                                      &wcid_entry, sizeof(wcid_entry));
1073
999
}
1074
1000
 
1075
1001
int rt2800_config_shared_key(struct rt2x00_dev *rt2x00dev,
1116
1042
        /*
1117
1043
         * Update WCID information
1118
1044
         */
1119
 
        rt2800_config_wcid_attr(rt2x00dev, crypto, key);
 
1045
        rt2800_config_wcid(rt2x00dev, crypto->address, key->hw_key_idx);
 
1046
        rt2800_config_wcid_attr_bssidx(rt2x00dev, key->hw_key_idx,
 
1047
                                       crypto->bssidx);
 
1048
        rt2800_config_wcid_attr_cipher(rt2x00dev, crypto, key);
1120
1049
 
1121
1050
        return 0;
1122
1051
}
1123
1052
EXPORT_SYMBOL_GPL(rt2800_config_shared_key);
1124
1053
 
1125
 
static inline int rt2800_find_pairwise_keyslot(struct rt2x00_dev *rt2x00dev)
 
1054
static inline int rt2800_find_wcid(struct rt2x00_dev *rt2x00dev)
1126
1055
{
 
1056
        struct mac_wcid_entry wcid_entry;
1127
1057
        int idx;
1128
 
        u32 offset, reg;
 
1058
        u32 offset;
1129
1059
 
1130
1060
        /*
1131
 
         * Search for the first free pairwise key entry and return the
1132
 
         * corresponding index.
 
1061
         * Search for the first free WCID entry and return the corresponding
 
1062
         * index.
1133
1063
         *
1134
1064
         * Make sure the WCID starts _after_ the last possible shared key
1135
1065
         * entry (>32).
1139
1069
         * first 222 entries.
1140
1070
         */
1141
1071
        for (idx = 33; idx <= 222; idx++) {
1142
 
                offset = MAC_WCID_ATTR_ENTRY(idx);
1143
 
                rt2800_register_read(rt2x00dev, offset, &reg);
1144
 
                if (!reg)
 
1072
                offset = MAC_WCID_ENTRY(idx);
 
1073
                rt2800_register_multiread(rt2x00dev, offset, &wcid_entry,
 
1074
                                          sizeof(wcid_entry));
 
1075
                if (is_broadcast_ether_addr(wcid_entry.mac))
1145
1076
                        return idx;
1146
1077
        }
 
1078
 
 
1079
        /*
 
1080
         * Use -1 to indicate that we don't have any more space in the WCID
 
1081
         * table.
 
1082
         */
1147
1083
        return -1;
1148
1084
}
1149
1085
 
1153
1089
{
1154
1090
        struct hw_key_entry key_entry;
1155
1091
        u32 offset;
1156
 
        int idx;
1157
1092
 
1158
1093
        if (crypto->cmd == SET_KEY) {
1159
 
                idx = rt2800_find_pairwise_keyslot(rt2x00dev);
1160
 
                if (idx < 0)
 
1094
                /*
 
1095
                 * Allow key configuration only for STAs that are
 
1096
                 * known by the hw.
 
1097
                 */
 
1098
                if (crypto->wcid < 0)
1161
1099
                        return -ENOSPC;
1162
 
                key->hw_key_idx = idx;
 
1100
                key->hw_key_idx = crypto->wcid;
1163
1101
 
1164
1102
                memcpy(key_entry.key, crypto->key,
1165
1103
                       sizeof(key_entry.key));
1176
1114
        /*
1177
1115
         * Update WCID information
1178
1116
         */
1179
 
        rt2800_config_wcid_attr(rt2x00dev, crypto, key);
 
1117
        rt2800_config_wcid_attr_cipher(rt2x00dev, crypto, key);
1180
1118
 
1181
1119
        return 0;
1182
1120
}
1183
1121
EXPORT_SYMBOL_GPL(rt2800_config_pairwise_key);
1184
1122
 
 
1123
int rt2800_sta_add(struct rt2x00_dev *rt2x00dev, struct ieee80211_vif *vif,
 
1124
                   struct ieee80211_sta *sta)
 
1125
{
 
1126
        int wcid;
 
1127
        struct rt2x00_sta *sta_priv = sta_to_rt2x00_sta(sta);
 
1128
 
 
1129
        /*
 
1130
         * Find next free WCID.
 
1131
         */
 
1132
        wcid = rt2800_find_wcid(rt2x00dev);
 
1133
 
 
1134
        /*
 
1135
         * Store selected wcid even if it is invalid so that we can
 
1136
         * later decide if the STA is uploaded into the hw.
 
1137
         */
 
1138
        sta_priv->wcid = wcid;
 
1139
 
 
1140
        /*
 
1141
         * No space left in the device, however, we can still communicate
 
1142
         * with the STA -> No error.
 
1143
         */
 
1144
        if (wcid < 0)
 
1145
                return 0;
 
1146
 
 
1147
        /*
 
1148
         * Clean up WCID attributes and write STA address to the device.
 
1149
         */
 
1150
        rt2800_delete_wcid_attr(rt2x00dev, wcid);
 
1151
        rt2800_config_wcid(rt2x00dev, sta->addr, wcid);
 
1152
        rt2800_config_wcid_attr_bssidx(rt2x00dev, wcid,
 
1153
                                       rt2x00lib_get_bssidx(rt2x00dev, vif));
 
1154
        return 0;
 
1155
}
 
1156
EXPORT_SYMBOL_GPL(rt2800_sta_add);
 
1157
 
 
1158
int rt2800_sta_remove(struct rt2x00_dev *rt2x00dev, int wcid)
 
1159
{
 
1160
        /*
 
1161
         * Remove WCID entry, no need to clean the attributes as they will
 
1162
         * get renewed when the WCID is reused.
 
1163
         */
 
1164
        rt2800_config_wcid(rt2x00dev, NULL, wcid);
 
1165
 
 
1166
        return 0;
 
1167
}
 
1168
EXPORT_SYMBOL_GPL(rt2800_sta_remove);
 
1169
 
1185
1170
void rt2800_config_filter(struct rt2x00_dev *rt2x00dev,
1186
1171
                          const unsigned int filter_flags)
1187
1172
{
1363
1348
                        gf20_rate = gf40_rate = 0x0003;
1364
1349
                }
1365
1350
                break;
1366
 
        };
 
1351
        }
1367
1352
 
1368
1353
        /* check for STAs not supporting greenfield mode */
1369
1354
        if (any_sta_nongf)
1441
1426
}
1442
1427
EXPORT_SYMBOL_GPL(rt2800_config_erp);
1443
1428
 
 
1429
static void rt2800_config_3572bt_ant(struct rt2x00_dev *rt2x00dev)
 
1430
{
 
1431
        u32 reg;
 
1432
        u16 eeprom;
 
1433
        u8 led_ctrl, led_g_mode, led_r_mode;
 
1434
 
 
1435
        rt2800_register_read(rt2x00dev, GPIO_SWITCH, &reg);
 
1436
        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
 
1437
                rt2x00_set_field32(&reg, GPIO_SWITCH_0, 1);
 
1438
                rt2x00_set_field32(&reg, GPIO_SWITCH_1, 1);
 
1439
        } else {
 
1440
                rt2x00_set_field32(&reg, GPIO_SWITCH_0, 0);
 
1441
                rt2x00_set_field32(&reg, GPIO_SWITCH_1, 0);
 
1442
        }
 
1443
        rt2800_register_write(rt2x00dev, GPIO_SWITCH, reg);
 
1444
 
 
1445
        rt2800_register_read(rt2x00dev, LED_CFG, &reg);
 
1446
        led_g_mode = rt2x00_get_field32(reg, LED_CFG_LED_POLAR) ? 3 : 0;
 
1447
        led_r_mode = rt2x00_get_field32(reg, LED_CFG_LED_POLAR) ? 0 : 3;
 
1448
        if (led_g_mode != rt2x00_get_field32(reg, LED_CFG_G_LED_MODE) ||
 
1449
            led_r_mode != rt2x00_get_field32(reg, LED_CFG_R_LED_MODE)) {
 
1450
                rt2x00_eeprom_read(rt2x00dev, EEPROM_FREQ, &eeprom);
 
1451
                led_ctrl = rt2x00_get_field16(eeprom, EEPROM_FREQ_LED_MODE);
 
1452
                if (led_ctrl == 0 || led_ctrl > 0x40) {
 
1453
                        rt2x00_set_field32(&reg, LED_CFG_G_LED_MODE, led_g_mode);
 
1454
                        rt2x00_set_field32(&reg, LED_CFG_R_LED_MODE, led_r_mode);
 
1455
                        rt2800_register_write(rt2x00dev, LED_CFG, reg);
 
1456
                } else {
 
1457
                        rt2800_mcu_request(rt2x00dev, MCU_BAND_SELECT, 0xff,
 
1458
                                           (led_g_mode << 2) | led_r_mode, 1);
 
1459
                }
 
1460
        }
 
1461
}
 
1462
 
1444
1463
static void rt2800_set_ant_diversity(struct rt2x00_dev *rt2x00dev,
1445
1464
                                     enum antenna ant)
1446
1465
{
1471
1490
        rt2800_bbp_read(rt2x00dev, 1, &r1);
1472
1491
        rt2800_bbp_read(rt2x00dev, 3, &r3);
1473
1492
 
 
1493
        if (rt2x00_rt(rt2x00dev, RT3572) &&
 
1494
            test_bit(CAPABILITY_BT_COEXIST, &rt2x00dev->cap_flags))
 
1495
                rt2800_config_3572bt_ant(rt2x00dev);
 
1496
 
1474
1497
        /*
1475
1498
         * Configure the TX antenna.
1476
1499
         */
1479
1502
                rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 0);
1480
1503
                break;
1481
1504
        case 2:
1482
 
                rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 2);
 
1505
                if (rt2x00_rt(rt2x00dev, RT3572) &&
 
1506
                    test_bit(CAPABILITY_BT_COEXIST, &rt2x00dev->cap_flags))
 
1507
                        rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 1);
 
1508
                else
 
1509
                        rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 2);
1483
1510
                break;
1484
1511
        case 3:
1485
1512
                rt2x00_set_field8(&r1, BBP1_TX_ANTENNA, 0);
1504
1531
                rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 0);
1505
1532
                break;
1506
1533
        case 2:
1507
 
                rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 1);
 
1534
                if (rt2x00_rt(rt2x00dev, RT3572) &&
 
1535
                    test_bit(CAPABILITY_BT_COEXIST, &rt2x00dev->cap_flags)) {
 
1536
                        rt2x00_set_field8(&r3, BBP3_RX_ADC, 1);
 
1537
                        rt2x00_set_field8(&r3, BBP3_RX_ANTENNA,
 
1538
                                rt2x00dev->curr_band == IEEE80211_BAND_5GHZ);
 
1539
                        rt2800_set_ant_diversity(rt2x00dev, ANTENNA_B);
 
1540
                } else {
 
1541
                        rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 1);
 
1542
                }
1508
1543
                break;
1509
1544
        case 3:
1510
1545
                rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 2);
1638
1673
        rt2800_rfcsr_write(rt2x00dev, 7, rfcsr);
1639
1674
}
1640
1675
 
 
1676
static void rt2800_config_channel_rf3052(struct rt2x00_dev *rt2x00dev,
 
1677
                                         struct ieee80211_conf *conf,
 
1678
                                         struct rf_channel *rf,
 
1679
                                         struct channel_info *info)
 
1680
{
 
1681
        u8 rfcsr;
 
1682
        u32 reg;
 
1683
 
 
1684
        if (rf->channel <= 14) {
 
1685
                rt2800_bbp_write(rt2x00dev, 25, 0x15);
 
1686
                rt2800_bbp_write(rt2x00dev, 26, 0x85);
 
1687
        } else {
 
1688
                rt2800_bbp_write(rt2x00dev, 25, 0x09);
 
1689
                rt2800_bbp_write(rt2x00dev, 26, 0xff);
 
1690
        }
 
1691
 
 
1692
        rt2800_rfcsr_write(rt2x00dev, 2, rf->rf1);
 
1693
        rt2800_rfcsr_write(rt2x00dev, 3, rf->rf3);
 
1694
 
 
1695
        rt2800_rfcsr_read(rt2x00dev, 6, &rfcsr);
 
1696
        rt2x00_set_field8(&rfcsr, RFCSR6_R1, rf->rf2);
 
1697
        if (rf->channel <= 14)
 
1698
                rt2x00_set_field8(&rfcsr, RFCSR6_TXDIV, 2);
 
1699
        else
 
1700
                rt2x00_set_field8(&rfcsr, RFCSR6_TXDIV, 1);
 
1701
        rt2800_rfcsr_write(rt2x00dev, 6, rfcsr);
 
1702
 
 
1703
        rt2800_rfcsr_read(rt2x00dev, 5, &rfcsr);
 
1704
        if (rf->channel <= 14)
 
1705
                rt2x00_set_field8(&rfcsr, RFCSR5_R1, 1);
 
1706
        else
 
1707
                rt2x00_set_field8(&rfcsr, RFCSR5_R1, 2);
 
1708
        rt2800_rfcsr_write(rt2x00dev, 5, rfcsr);
 
1709
 
 
1710
        rt2800_rfcsr_read(rt2x00dev, 12, &rfcsr);
 
1711
        if (rf->channel <= 14) {
 
1712
                rt2x00_set_field8(&rfcsr, RFCSR12_DR0, 3);
 
1713
                rt2x00_set_field8(&rfcsr, RFCSR12_TX_POWER,
 
1714
                                (info->default_power1 & 0x3) |
 
1715
                                ((info->default_power1 & 0xC) << 1));
 
1716
        } else {
 
1717
                rt2x00_set_field8(&rfcsr, RFCSR12_DR0, 7);
 
1718
                rt2x00_set_field8(&rfcsr, RFCSR12_TX_POWER,
 
1719
                                (info->default_power1 & 0x3) |
 
1720
                                ((info->default_power1 & 0xC) << 1));
 
1721
        }
 
1722
        rt2800_rfcsr_write(rt2x00dev, 12, rfcsr);
 
1723
 
 
1724
        rt2800_rfcsr_read(rt2x00dev, 13, &rfcsr);
 
1725
        if (rf->channel <= 14) {
 
1726
                rt2x00_set_field8(&rfcsr, RFCSR13_DR0, 3);
 
1727
                rt2x00_set_field8(&rfcsr, RFCSR13_TX_POWER,
 
1728
                                (info->default_power2 & 0x3) |
 
1729
                                ((info->default_power2 & 0xC) << 1));
 
1730
        } else {
 
1731
                rt2x00_set_field8(&rfcsr, RFCSR13_DR0, 7);
 
1732
                rt2x00_set_field8(&rfcsr, RFCSR13_TX_POWER,
 
1733
                                (info->default_power2 & 0x3) |
 
1734
                                ((info->default_power2 & 0xC) << 1));
 
1735
        }
 
1736
        rt2800_rfcsr_write(rt2x00dev, 13, rfcsr);
 
1737
 
 
1738
        rt2800_rfcsr_read(rt2x00dev, 1, &rfcsr);
 
1739
        rt2x00_set_field8(&rfcsr, RFCSR1_RF_BLOCK_EN, 1);
 
1740
        rt2x00_set_field8(&rfcsr, RFCSR1_RX0_PD, 0);
 
1741
        rt2x00_set_field8(&rfcsr, RFCSR1_TX0_PD, 0);
 
1742
        rt2x00_set_field8(&rfcsr, RFCSR1_RX1_PD, 0);
 
1743
        rt2x00_set_field8(&rfcsr, RFCSR1_TX1_PD, 0);
 
1744
        if (test_bit(CAPABILITY_BT_COEXIST, &rt2x00dev->cap_flags)) {
 
1745
                if (rf->channel <= 14) {
 
1746
                        rt2x00_set_field8(&rfcsr, RFCSR1_RX0_PD, 1);
 
1747
                        rt2x00_set_field8(&rfcsr, RFCSR1_TX0_PD, 1);
 
1748
                }
 
1749
                rt2x00_set_field8(&rfcsr, RFCSR1_RX2_PD, 1);
 
1750
                rt2x00_set_field8(&rfcsr, RFCSR1_TX2_PD, 1);
 
1751
        } else {
 
1752
                switch (rt2x00dev->default_ant.tx_chain_num) {
 
1753
                case 1:
 
1754
                        rt2x00_set_field8(&rfcsr, RFCSR1_TX1_PD, 1);
 
1755
                case 2:
 
1756
                        rt2x00_set_field8(&rfcsr, RFCSR1_TX2_PD, 1);
 
1757
                        break;
 
1758
                }
 
1759
 
 
1760
                switch (rt2x00dev->default_ant.rx_chain_num) {
 
1761
                case 1:
 
1762
                        rt2x00_set_field8(&rfcsr, RFCSR1_RX1_PD, 1);
 
1763
                case 2:
 
1764
                        rt2x00_set_field8(&rfcsr, RFCSR1_RX2_PD, 1);
 
1765
                        break;
 
1766
                }
 
1767
        }
 
1768
        rt2800_rfcsr_write(rt2x00dev, 1, rfcsr);
 
1769
 
 
1770
        rt2800_rfcsr_read(rt2x00dev, 23, &rfcsr);
 
1771
        rt2x00_set_field8(&rfcsr, RFCSR23_FREQ_OFFSET, rt2x00dev->freq_offset);
 
1772
        rt2800_rfcsr_write(rt2x00dev, 23, rfcsr);
 
1773
 
 
1774
        rt2800_rfcsr_write(rt2x00dev, 24,
 
1775
                              rt2x00dev->calibration[conf_is_ht40(conf)]);
 
1776
        rt2800_rfcsr_write(rt2x00dev, 31,
 
1777
                              rt2x00dev->calibration[conf_is_ht40(conf)]);
 
1778
 
 
1779
        if (rf->channel <= 14) {
 
1780
                rt2800_rfcsr_write(rt2x00dev, 7, 0xd8);
 
1781
                rt2800_rfcsr_write(rt2x00dev, 9, 0xc3);
 
1782
                rt2800_rfcsr_write(rt2x00dev, 10, 0xf1);
 
1783
                rt2800_rfcsr_write(rt2x00dev, 11, 0xb9);
 
1784
                rt2800_rfcsr_write(rt2x00dev, 15, 0x53);
 
1785
                rt2800_rfcsr_write(rt2x00dev, 16, 0x4c);
 
1786
                rt2800_rfcsr_write(rt2x00dev, 17, 0x23);
 
1787
                rt2800_rfcsr_write(rt2x00dev, 19, 0x93);
 
1788
                rt2800_rfcsr_write(rt2x00dev, 20, 0xb3);
 
1789
                rt2800_rfcsr_write(rt2x00dev, 25, 0x15);
 
1790
                rt2800_rfcsr_write(rt2x00dev, 26, 0x85);
 
1791
                rt2800_rfcsr_write(rt2x00dev, 27, 0x00);
 
1792
                rt2800_rfcsr_write(rt2x00dev, 29, 0x9b);
 
1793
        } else {
 
1794
                rt2800_rfcsr_write(rt2x00dev, 7, 0x14);
 
1795
                rt2800_rfcsr_write(rt2x00dev, 9, 0xc0);
 
1796
                rt2800_rfcsr_write(rt2x00dev, 10, 0xf1);
 
1797
                rt2800_rfcsr_write(rt2x00dev, 11, 0x00);
 
1798
                rt2800_rfcsr_write(rt2x00dev, 15, 0x43);
 
1799
                rt2800_rfcsr_write(rt2x00dev, 16, 0x7a);
 
1800
                rt2800_rfcsr_write(rt2x00dev, 17, 0x23);
 
1801
                if (rf->channel <= 64) {
 
1802
                        rt2800_rfcsr_write(rt2x00dev, 19, 0xb7);
 
1803
                        rt2800_rfcsr_write(rt2x00dev, 20, 0xf6);
 
1804
                        rt2800_rfcsr_write(rt2x00dev, 25, 0x3d);
 
1805
                } else if (rf->channel <= 128) {
 
1806
                        rt2800_rfcsr_write(rt2x00dev, 19, 0x74);
 
1807
                        rt2800_rfcsr_write(rt2x00dev, 20, 0xf4);
 
1808
                        rt2800_rfcsr_write(rt2x00dev, 25, 0x01);
 
1809
                } else {
 
1810
                        rt2800_rfcsr_write(rt2x00dev, 19, 0x72);
 
1811
                        rt2800_rfcsr_write(rt2x00dev, 20, 0xf3);
 
1812
                        rt2800_rfcsr_write(rt2x00dev, 25, 0x01);
 
1813
                }
 
1814
                rt2800_rfcsr_write(rt2x00dev, 26, 0x87);
 
1815
                rt2800_rfcsr_write(rt2x00dev, 27, 0x01);
 
1816
                rt2800_rfcsr_write(rt2x00dev, 29, 0x9f);
 
1817
        }
 
1818
 
 
1819
        rt2800_register_read(rt2x00dev, GPIO_CTRL_CFG, &reg);
 
1820
        rt2x00_set_field32(&reg, GPIO_CTRL_CFG_GPIOD_BIT7, 0);
 
1821
        if (rf->channel <= 14)
 
1822
                rt2x00_set_field32(&reg, GPIO_CTRL_CFG_BIT7, 1);
 
1823
        else
 
1824
                rt2x00_set_field32(&reg, GPIO_CTRL_CFG_BIT7, 0);
 
1825
        rt2800_register_write(rt2x00dev, GPIO_CTRL_CFG, reg);
 
1826
 
 
1827
        rt2800_rfcsr_read(rt2x00dev, 7, &rfcsr);
 
1828
        rt2x00_set_field8(&rfcsr, RFCSR7_RF_TUNING, 1);
 
1829
        rt2800_rfcsr_write(rt2x00dev, 7, rfcsr);
 
1830
}
1641
1831
 
1642
1832
#define RT5390_POWER_BOUND     0x27
1643
1833
#define RT5390_FREQ_OFFSET_BOUND       0x5f
1756
1946
            rt2x00_rf(rt2x00dev, RF3020) ||
1757
1947
            rt2x00_rf(rt2x00dev, RF3021) ||
1758
1948
            rt2x00_rf(rt2x00dev, RF3022) ||
1759
 
            rt2x00_rf(rt2x00dev, RF3052) ||
1760
1949
            rt2x00_rf(rt2x00dev, RF3320))
1761
1950
                rt2800_config_channel_rf3xxx(rt2x00dev, conf, rf, info);
 
1951
        else if (rt2x00_rf(rt2x00dev, RF3052))
 
1952
                rt2800_config_channel_rf3052(rt2x00dev, conf, rf, info);
1762
1953
        else if (rt2x00_rf(rt2x00dev, RF5370) ||
1763
1954
                 rt2x00_rf(rt2x00dev, RF5390))
1764
1955
                rt2800_config_channel_rf53xx(rt2x00dev, conf, rf, info);
1785
1976
                        }
1786
1977
                }
1787
1978
        } else {
1788
 
                rt2800_bbp_write(rt2x00dev, 82, 0xf2);
 
1979
                if (rt2x00_rt(rt2x00dev, RT3572))
 
1980
                        rt2800_bbp_write(rt2x00dev, 82, 0x94);
 
1981
                else
 
1982
                        rt2800_bbp_write(rt2x00dev, 82, 0xf2);
1789
1983
 
1790
1984
                if (test_bit(CAPABILITY_EXTERNAL_LNA_A, &rt2x00dev->cap_flags))
1791
1985
                        rt2800_bbp_write(rt2x00dev, 75, 0x46);
1799
1993
        rt2x00_set_field32(&reg, TX_BAND_CFG_BG, rf->channel <= 14);
1800
1994
        rt2800_register_write(rt2x00dev, TX_BAND_CFG, reg);
1801
1995
 
 
1996
        if (rt2x00_rt(rt2x00dev, RT3572))
 
1997
                rt2800_rfcsr_write(rt2x00dev, 8, 0);
 
1998
 
1802
1999
        tx_pin = 0;
1803
2000
 
1804
2001
        /* Turn on unused PA or LNA when not using 1T or 1R */
1805
2002
        if (rt2x00dev->default_ant.tx_chain_num == 2) {
1806
 
                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A1_EN, 1);
1807
 
                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN, 1);
 
2003
                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A1_EN,
 
2004
                                   rf->channel > 14);
 
2005
                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G1_EN,
 
2006
                                   rf->channel <= 14);
1808
2007
        }
1809
2008
 
1810
2009
        /* Turn on unused PA or LNA when not using 1T or 1R */
1817
2016
        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_LNA_PE_G0_EN, 1);
1818
2017
        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_RFTR_EN, 1);
1819
2018
        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_TRSW_EN, 1);
1820
 
        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN, rf->channel <= 14);
 
2019
        if (test_bit(CAPABILITY_BT_COEXIST, &rt2x00dev->cap_flags))
 
2020
                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN, 1);
 
2021
        else
 
2022
                rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_G0_EN,
 
2023
                                   rf->channel <= 14);
1821
2024
        rt2x00_set_field32(&tx_pin, TX_PIN_CFG_PA_PE_A0_EN, rf->channel > 14);
1822
2025
 
1823
2026
        rt2800_register_write(rt2x00dev, TX_PIN_CFG, tx_pin);
1824
2027
 
 
2028
        if (rt2x00_rt(rt2x00dev, RT3572))
 
2029
                rt2800_rfcsr_write(rt2x00dev, 8, 0x80);
 
2030
 
1825
2031
        rt2800_bbp_read(rt2x00dev, 4, &bbp);
1826
2032
        rt2x00_set_field8(&bbp, BBP4_BANDWIDTH, 2 * conf_is_ht40(conf));
1827
2033
        rt2800_bbp_write(rt2x00dev, 4, bbp);
2421
2627
                rt2800_register_write(rt2x00dev, TX_SW_CFG0, 0x00000400);
2422
2628
                rt2800_register_write(rt2x00dev, TX_SW_CFG1, 0x00000000);
2423
2629
                rt2800_register_write(rt2x00dev, TX_SW_CFG2, 0x00000030);
 
2630
        } else if (rt2x00_rt(rt2x00dev, RT3572)) {
 
2631
                rt2800_register_write(rt2x00dev, TX_SW_CFG0, 0x00000400);
 
2632
                rt2800_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606);
2424
2633
        } else if (rt2x00_rt(rt2x00dev, RT5390)) {
2425
2634
                rt2800_register_write(rt2x00dev, TX_SW_CFG0, 0x00000404);
2426
2635
                rt2800_register_write(rt2x00dev, TX_SW_CFG1, 0x00080606);
2637
2846
                                         SHARED_KEY_MODE_ENTRY(i), 0);
2638
2847
 
2639
2848
        for (i = 0; i < 256; i++) {
2640
 
                static const u32 wcid[2] = { 0xffffffff, 0x00ffffff };
2641
 
                rt2800_register_multiwrite(rt2x00dev, MAC_WCID_ENTRY(i),
2642
 
                                              wcid, sizeof(wcid));
2643
 
 
2644
 
                rt2800_register_write(rt2x00dev, MAC_WCID_ATTR_ENTRY(i), 0);
 
2849
                rt2800_config_wcid(rt2x00dev, NULL, i);
 
2850
                rt2800_delete_wcid_attr(rt2x00dev, i);
2645
2851
                rt2800_register_write(rt2x00dev, MAC_IVEIV_ENTRY(i), 0);
2646
2852
        }
2647
2853
 
2807
3013
        }
2808
3014
 
2809
3015
        if (rt2800_is_305x_soc(rt2x00dev) ||
 
3016
            rt2x00_rt(rt2x00dev, RT3572) ||
2810
3017
            rt2x00_rt(rt2x00dev, RT5390))
2811
3018
                rt2800_bbp_write(rt2x00dev, 31, 0x08);
2812
3019
 
2836
3043
            rt2x00_rt(rt2x00dev, RT3071) ||
2837
3044
            rt2x00_rt(rt2x00dev, RT3090) ||
2838
3045
            rt2x00_rt(rt2x00dev, RT3390) ||
 
3046
            rt2x00_rt(rt2x00dev, RT3572) ||
2839
3047
            rt2x00_rt(rt2x00dev, RT5390)) {
2840
3048
                rt2800_bbp_write(rt2x00dev, 79, 0x13);
2841
3049
                rt2800_bbp_write(rt2x00dev, 80, 0x05);
2876
3084
            rt2x00_rt_rev_gte(rt2x00dev, RT3071, REV_RT3071E) ||
2877
3085
            rt2x00_rt_rev_gte(rt2x00dev, RT3090, REV_RT3090E) ||
2878
3086
            rt2x00_rt_rev_gte(rt2x00dev, RT3390, REV_RT3390E) ||
 
3087
            rt2x00_rt(rt2x00dev, RT3572) ||
2879
3088
            rt2x00_rt(rt2x00dev, RT5390) ||
2880
3089
            rt2800_is_305x_soc(rt2x00dev))
2881
3090
                rt2800_bbp_write(rt2x00dev, 103, 0xc0);
2903
3112
        if (rt2x00_rt(rt2x00dev, RT3071) ||
2904
3113
            rt2x00_rt(rt2x00dev, RT3090) ||
2905
3114
            rt2x00_rt(rt2x00dev, RT3390) ||
 
3115
            rt2x00_rt(rt2x00dev, RT3572) ||
2906
3116
            rt2x00_rt(rt2x00dev, RT5390)) {
2907
3117
                rt2800_bbp_read(rt2x00dev, 138, &value);
2908
3118
 
3039
3249
            !rt2x00_rt(rt2x00dev, RT3071) &&
3040
3250
            !rt2x00_rt(rt2x00dev, RT3090) &&
3041
3251
            !rt2x00_rt(rt2x00dev, RT3390) &&
 
3252
            !rt2x00_rt(rt2x00dev, RT3572) &&
3042
3253
            !rt2x00_rt(rt2x00dev, RT5390) &&
3043
3254
            !rt2800_is_305x_soc(rt2x00dev))
3044
3255
                return 0;
3117
3328
                rt2800_rfcsr_write(rt2x00dev, 29, 0x8f);
3118
3329
                rt2800_rfcsr_write(rt2x00dev, 30, 0x20);
3119
3330
                rt2800_rfcsr_write(rt2x00dev, 31, 0x0f);
 
3331
        } else if (rt2x00_rt(rt2x00dev, RT3572)) {
 
3332
                rt2800_rfcsr_write(rt2x00dev, 0, 0x70);
 
3333
                rt2800_rfcsr_write(rt2x00dev, 1, 0x81);
 
3334
                rt2800_rfcsr_write(rt2x00dev, 2, 0xf1);
 
3335
                rt2800_rfcsr_write(rt2x00dev, 3, 0x02);
 
3336
                rt2800_rfcsr_write(rt2x00dev, 4, 0x4c);
 
3337
                rt2800_rfcsr_write(rt2x00dev, 5, 0x05);
 
3338
                rt2800_rfcsr_write(rt2x00dev, 6, 0x4a);
 
3339
                rt2800_rfcsr_write(rt2x00dev, 7, 0xd8);
 
3340
                rt2800_rfcsr_write(rt2x00dev, 9, 0xc3);
 
3341
                rt2800_rfcsr_write(rt2x00dev, 10, 0xf1);
 
3342
                rt2800_rfcsr_write(rt2x00dev, 11, 0xb9);
 
3343
                rt2800_rfcsr_write(rt2x00dev, 12, 0x70);
 
3344
                rt2800_rfcsr_write(rt2x00dev, 13, 0x65);
 
3345
                rt2800_rfcsr_write(rt2x00dev, 14, 0xa0);
 
3346
                rt2800_rfcsr_write(rt2x00dev, 15, 0x53);
 
3347
                rt2800_rfcsr_write(rt2x00dev, 16, 0x4c);
 
3348
                rt2800_rfcsr_write(rt2x00dev, 17, 0x23);
 
3349
                rt2800_rfcsr_write(rt2x00dev, 18, 0xac);
 
3350
                rt2800_rfcsr_write(rt2x00dev, 19, 0x93);
 
3351
                rt2800_rfcsr_write(rt2x00dev, 20, 0xb3);
 
3352
                rt2800_rfcsr_write(rt2x00dev, 21, 0xd0);
 
3353
                rt2800_rfcsr_write(rt2x00dev, 22, 0x00);
 
3354
                rt2800_rfcsr_write(rt2x00dev, 23, 0x3c);
 
3355
                rt2800_rfcsr_write(rt2x00dev, 24, 0x16);
 
3356
                rt2800_rfcsr_write(rt2x00dev, 25, 0x15);
 
3357
                rt2800_rfcsr_write(rt2x00dev, 26, 0x85);
 
3358
                rt2800_rfcsr_write(rt2x00dev, 27, 0x00);
 
3359
                rt2800_rfcsr_write(rt2x00dev, 28, 0x00);
 
3360
                rt2800_rfcsr_write(rt2x00dev, 29, 0x9b);
 
3361
                rt2800_rfcsr_write(rt2x00dev, 30, 0x09);
 
3362
                rt2800_rfcsr_write(rt2x00dev, 31, 0x10);
3120
3363
        } else if (rt2800_is_305x_soc(rt2x00dev)) {
3121
3364
                rt2800_rfcsr_write(rt2x00dev, 0, 0x50);
3122
3365
                rt2800_rfcsr_write(rt2x00dev, 1, 0x01);
3266
3509
                rt2800_register_read(rt2x00dev, GPIO_SWITCH, &reg);
3267
3510
                rt2x00_set_field32(&reg, GPIO_SWITCH_5, 0);
3268
3511
                rt2800_register_write(rt2x00dev, GPIO_SWITCH, reg);
 
3512
        } else if (rt2x00_rt(rt2x00dev, RT3572)) {
 
3513
                rt2800_rfcsr_read(rt2x00dev, 6, &rfcsr);
 
3514
                rt2x00_set_field8(&rfcsr, RFCSR6_R2, 1);
 
3515
                rt2800_rfcsr_write(rt2x00dev, 6, rfcsr);
 
3516
 
 
3517
                rt2800_register_read(rt2x00dev, LDO_CFG0, &reg);
 
3518
                rt2x00_set_field32(&reg, LDO_CFG0_LDO_CORE_VLEVEL, 3);
 
3519
                rt2x00_set_field32(&reg, LDO_CFG0_BGSEL, 1);
 
3520
                rt2800_register_write(rt2x00dev, LDO_CFG0, reg);
 
3521
                msleep(1);
 
3522
                rt2800_register_read(rt2x00dev, LDO_CFG0, &reg);
 
3523
                rt2x00_set_field32(&reg, LDO_CFG0_BGSEL, 1);
 
3524
                rt2800_register_write(rt2x00dev, LDO_CFG0, reg);
3269
3525
        }
3270
3526
 
3271
3527
        /*
3278
3534
                        rt2800_init_rx_filter(rt2x00dev, true, 0x27, 0x19);
3279
3535
        } else if (rt2x00_rt(rt2x00dev, RT3071) ||
3280
3536
                   rt2x00_rt(rt2x00dev, RT3090) ||
3281
 
                   rt2x00_rt(rt2x00dev, RT3390)) {
 
3537
                   rt2x00_rt(rt2x00dev, RT3390) ||
 
3538
                   rt2x00_rt(rt2x00dev, RT3572)) {
3282
3539
                rt2x00dev->calibration[0] =
3283
3540
                        rt2800_init_rx_filter(rt2x00dev, false, 0x07, 0x13);
3284
3541
                rt2x00dev->calibration[1] =
4141
4398
}
4142
4399
EXPORT_SYMBOL_GPL(rt2800_set_rts_threshold);
4143
4400
 
4144
 
int rt2800_conf_tx(struct ieee80211_hw *hw, u16 queue_idx,
 
4401
int rt2800_conf_tx(struct ieee80211_hw *hw,
 
4402
                   struct ieee80211_vif *vif, u16 queue_idx,
4145
4403
                   const struct ieee80211_tx_queue_params *params)
4146
4404
{
4147
4405
        struct rt2x00_dev *rt2x00dev = hw->priv;
4157
4415
         * we are free to update the registers based on the value
4158
4416
         * in the queue parameter.
4159
4417
         */
4160
 
        retval = rt2x00mac_conf_tx(hw, queue_idx, params);
 
4418
        retval = rt2x00mac_conf_tx(hw, vif, queue_idx, params);
4161
4419
        if (retval)
4162
4420
                return retval;
4163
4421
 
4209
4467
}
4210
4468
EXPORT_SYMBOL_GPL(rt2800_conf_tx);
4211
4469
 
4212
 
u64 rt2800_get_tsf(struct ieee80211_hw *hw)
 
4470
u64 rt2800_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4213
4471
{
4214
4472
        struct rt2x00_dev *rt2x00dev = hw->priv;
4215
4473
        u64 tsf;
4229
4487
                        struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4230
4488
                        u8 buf_size)
4231
4489
{
 
4490
        struct rt2x00_sta *sta_priv = (struct rt2x00_sta *)sta->drv_priv;
4232
4491
        int ret = 0;
4233
4492
 
 
4493
        /*
 
4494
         * Don't allow aggregation for stations the hardware isn't aware
 
4495
         * of because tx status reports for frames to an unknown station
 
4496
         * always contain wcid=255 and thus we can't distinguish between
 
4497
         * multiple stations which leads to unwanted situations when the
 
4498
         * hw reorders frames due to aggregation.
 
4499
         */
 
4500
        if (sta_priv->wcid < 0)
 
4501
                return 1;
 
4502
 
4234
4503
        switch (action) {
4235
4504
        case IEEE80211_AMPDU_RX_START:
4236
4505
        case IEEE80211_AMPDU_RX_STOP: