aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/net/wireless/rt2x00/rt2400pci.c131
-rw-r--r--drivers/net/wireless/rt2x00/rt2500pci.c131
-rw-r--r--drivers/net/wireless/rt2x00/rt2500usb.c84
-rw-r--r--drivers/net/wireless/rt2x00/rt2800pci.c129
-rw-r--r--drivers/net/wireless/rt2x00/rt2800usb.c84
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00usb.c12
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00usb.h8
-rw-r--r--drivers/net/wireless/rt2x00/rt61pci.c154
-rw-r--r--drivers/net/wireless/rt2x00/rt73usb.c84
9 files changed, 530 insertions, 287 deletions
diff --git a/drivers/net/wireless/rt2x00/rt2400pci.c b/drivers/net/wireless/rt2x00/rt2400pci.c
index 62786608951e..35d9a06a76af 100644
--- a/drivers/net/wireless/rt2x00/rt2400pci.c
+++ b/drivers/net/wireless/rt2x00/rt2400pci.c
@@ -633,6 +633,88 @@ static void rt2400pci_link_tuner(struct rt2x00_dev *rt2x00dev,
633} 633}
634 634
635/* 635/*
636 * Queue handlers.
637 */
638static void rt2400pci_start_queue(struct data_queue *queue)
639{
640 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
641 u32 reg;
642
643 switch (queue->qid) {
644 case QID_RX:
645 rt2x00pci_register_read(rt2x00dev, RXCSR0, &reg);
646 rt2x00_set_field32(&reg, RXCSR0_DISABLE_RX, 0);
647 rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
648 break;
649 case QID_BEACON:
650 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
651 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 1);
652 rt2x00_set_field32(&reg, CSR14_TBCN, 1);
653 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 1);
654 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
655 break;
656 default:
657 break;
658 }
659}
660
661static void rt2400pci_kick_queue(struct data_queue *queue)
662{
663 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
664 u32 reg;
665
666 switch (queue->qid) {
667 case QID_AC_BE:
668 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
669 rt2x00_set_field32(&reg, TXCSR0_KICK_PRIO, 1);
670 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
671 break;
672 case QID_AC_BK:
673 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
674 rt2x00_set_field32(&reg, TXCSR0_KICK_TX, 1);
675 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
676 break;
677 case QID_ATIM:
678 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
679 rt2x00_set_field32(&reg, TXCSR0_KICK_ATIM, 1);
680 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
681 break;
682 default:
683 break;
684 }
685}
686
687static void rt2400pci_stop_queue(struct data_queue *queue)
688{
689 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
690 u32 reg;
691
692 switch (queue->qid) {
693 case QID_AC_BE:
694 case QID_AC_BK:
695 case QID_ATIM:
696 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
697 rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
698 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
699 break;
700 case QID_RX:
701 rt2x00pci_register_read(rt2x00dev, RXCSR0, &reg);
702 rt2x00_set_field32(&reg, RXCSR0_DISABLE_RX, 1);
703 rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
704 break;
705 case QID_BEACON:
706 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
707 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 0);
708 rt2x00_set_field32(&reg, CSR14_TBCN, 0);
709 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0);
710 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
711 break;
712 default:
713 break;
714 }
715}
716
717/*
636 * Initialization functions. 718 * Initialization functions.
637 */ 719 */
638static bool rt2400pci_get_entry_state(struct queue_entry *entry) 720static bool rt2400pci_get_entry_state(struct queue_entry *entry)
@@ -878,17 +960,6 @@ static int rt2400pci_init_bbp(struct rt2x00_dev *rt2x00dev)
878/* 960/*
879 * Device state switch handlers. 961 * Device state switch handlers.
880 */ 962 */
881static void rt2400pci_toggle_rx(struct rt2x00_dev *rt2x00dev,
882 enum dev_state state)
883{
884 u32 reg;
885
886 rt2x00pci_register_read(rt2x00dev, RXCSR0, &reg);
887 rt2x00_set_field32(&reg, RXCSR0_DISABLE_RX,
888 (state == STATE_RADIO_RX_OFF));
889 rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
890}
891
892static void rt2400pci_toggle_irq(struct rt2x00_dev *rt2x00dev, 963static void rt2400pci_toggle_irq(struct rt2x00_dev *rt2x00dev,
893 enum dev_state state) 964 enum dev_state state)
894{ 965{
@@ -988,8 +1059,10 @@ static int rt2400pci_set_device_state(struct rt2x00_dev *rt2x00dev,
988 rt2400pci_disable_radio(rt2x00dev); 1059 rt2400pci_disable_radio(rt2x00dev);
989 break; 1060 break;
990 case STATE_RADIO_RX_ON: 1061 case STATE_RADIO_RX_ON:
1062 rt2400pci_start_queue(rt2x00dev->rx);
1063 break;
991 case STATE_RADIO_RX_OFF: 1064 case STATE_RADIO_RX_OFF:
992 rt2400pci_toggle_rx(rt2x00dev, state); 1065 rt2400pci_stop_queue(rt2x00dev->rx);
993 break; 1066 break;
994 case STATE_RADIO_IRQ_ON: 1067 case STATE_RADIO_IRQ_ON:
995 case STATE_RADIO_IRQ_ON_ISR: 1068 case STATE_RADIO_IRQ_ON_ISR:
@@ -1122,36 +1195,6 @@ static void rt2400pci_write_beacon(struct queue_entry *entry,
1122 rt2x00pci_register_write(rt2x00dev, CSR14, reg); 1195 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
1123} 1196}
1124 1197
1125static void rt2400pci_kick_tx_queue(struct data_queue *queue)
1126{
1127 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1128 u32 reg;
1129
1130 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
1131 rt2x00_set_field32(&reg, TXCSR0_KICK_PRIO, (queue->qid == QID_AC_BE));
1132 rt2x00_set_field32(&reg, TXCSR0_KICK_TX, (queue->qid == QID_AC_BK));
1133 rt2x00_set_field32(&reg, TXCSR0_KICK_ATIM, (queue->qid == QID_ATIM));
1134 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
1135}
1136
1137static void rt2400pci_kill_tx_queue(struct data_queue *queue)
1138{
1139 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1140 u32 reg;
1141
1142 if (queue->qid == QID_BEACON) {
1143 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
1144 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 0);
1145 rt2x00_set_field32(&reg, CSR14_TBCN, 0);
1146 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0);
1147 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
1148 } else {
1149 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
1150 rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
1151 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
1152 }
1153}
1154
1155/* 1198/*
1156 * RX control handlers 1199 * RX control handlers
1157 */ 1200 */
@@ -1631,8 +1674,8 @@ static const struct rt2x00lib_ops rt2400pci_rt2x00_ops = {
1631 .link_tuner = rt2400pci_link_tuner, 1674 .link_tuner = rt2400pci_link_tuner,
1632 .write_tx_desc = rt2400pci_write_tx_desc, 1675 .write_tx_desc = rt2400pci_write_tx_desc,
1633 .write_beacon = rt2400pci_write_beacon, 1676 .write_beacon = rt2400pci_write_beacon,
1634 .kick_tx_queue = rt2400pci_kick_tx_queue, 1677 .kick_tx_queue = rt2400pci_kick_queue,
1635 .kill_tx_queue = rt2400pci_kill_tx_queue, 1678 .kill_tx_queue = rt2400pci_stop_queue,
1636 .fill_rxdone = rt2400pci_fill_rxdone, 1679 .fill_rxdone = rt2400pci_fill_rxdone,
1637 .config_filter = rt2400pci_config_filter, 1680 .config_filter = rt2400pci_config_filter,
1638 .config_intf = rt2400pci_config_intf, 1681 .config_intf = rt2400pci_config_intf,
diff --git a/drivers/net/wireless/rt2x00/rt2500pci.c b/drivers/net/wireless/rt2x00/rt2500pci.c
index ce9212f28207..bee7ce14028d 100644
--- a/drivers/net/wireless/rt2x00/rt2500pci.c
+++ b/drivers/net/wireless/rt2x00/rt2500pci.c
@@ -723,6 +723,88 @@ dynamic_cca_tune:
723} 723}
724 724
725/* 725/*
726 * Queue handlers.
727 */
728static void rt2500pci_start_queue(struct data_queue *queue)
729{
730 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
731 u32 reg;
732
733 switch (queue->qid) {
734 case QID_RX:
735 rt2x00pci_register_read(rt2x00dev, RXCSR0, &reg);
736 rt2x00_set_field32(&reg, RXCSR0_DISABLE_RX, 0);
737 rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
738 break;
739 case QID_BEACON:
740 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
741 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 1);
742 rt2x00_set_field32(&reg, CSR14_TBCN, 1);
743 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 1);
744 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
745 break;
746 default:
747 break;
748 }
749}
750
751static void rt2500pci_kick_queue(struct data_queue *queue)
752{
753 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
754 u32 reg;
755
756 switch (queue->qid) {
757 case QID_AC_BE:
758 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
759 rt2x00_set_field32(&reg, TXCSR0_KICK_PRIO, 1);
760 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
761 break;
762 case QID_AC_BK:
763 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
764 rt2x00_set_field32(&reg, TXCSR0_KICK_TX, 1);
765 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
766 break;
767 case QID_ATIM:
768 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
769 rt2x00_set_field32(&reg, TXCSR0_KICK_ATIM, 1);
770 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
771 break;
772 default:
773 break;
774 }
775}
776
777static void rt2500pci_stop_queue(struct data_queue *queue)
778{
779 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
780 u32 reg;
781
782 switch (queue->qid) {
783 case QID_AC_BE:
784 case QID_AC_BK:
785 case QID_ATIM:
786 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
787 rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
788 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
789 break;
790 case QID_RX:
791 rt2x00pci_register_read(rt2x00dev, RXCSR0, &reg);
792 rt2x00_set_field32(&reg, RXCSR0_DISABLE_RX, 1);
793 rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
794 break;
795 case QID_BEACON:
796 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
797 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 0);
798 rt2x00_set_field32(&reg, CSR14_TBCN, 0);
799 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0);
800 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
801 break;
802 default:
803 break;
804 }
805}
806
807/*
726 * Initialization functions. 808 * Initialization functions.
727 */ 809 */
728static bool rt2500pci_get_entry_state(struct queue_entry *entry) 810static bool rt2500pci_get_entry_state(struct queue_entry *entry)
@@ -1033,17 +1115,6 @@ static int rt2500pci_init_bbp(struct rt2x00_dev *rt2x00dev)
1033/* 1115/*
1034 * Device state switch handlers. 1116 * Device state switch handlers.
1035 */ 1117 */
1036static void rt2500pci_toggle_rx(struct rt2x00_dev *rt2x00dev,
1037 enum dev_state state)
1038{
1039 u32 reg;
1040
1041 rt2x00pci_register_read(rt2x00dev, RXCSR0, &reg);
1042 rt2x00_set_field32(&reg, RXCSR0_DISABLE_RX,
1043 (state == STATE_RADIO_RX_OFF));
1044 rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
1045}
1046
1047static void rt2500pci_toggle_irq(struct rt2x00_dev *rt2x00dev, 1118static void rt2500pci_toggle_irq(struct rt2x00_dev *rt2x00dev,
1048 enum dev_state state) 1119 enum dev_state state)
1049{ 1120{
@@ -1143,8 +1214,10 @@ static int rt2500pci_set_device_state(struct rt2x00_dev *rt2x00dev,
1143 rt2500pci_disable_radio(rt2x00dev); 1214 rt2500pci_disable_radio(rt2x00dev);
1144 break; 1215 break;
1145 case STATE_RADIO_RX_ON: 1216 case STATE_RADIO_RX_ON:
1217 rt2500pci_start_queue(rt2x00dev->rx);
1218 break;
1146 case STATE_RADIO_RX_OFF: 1219 case STATE_RADIO_RX_OFF:
1147 rt2500pci_toggle_rx(rt2x00dev, state); 1220 rt2500pci_stop_queue(rt2x00dev->rx);
1148 break; 1221 break;
1149 case STATE_RADIO_IRQ_ON: 1222 case STATE_RADIO_IRQ_ON:
1150 case STATE_RADIO_IRQ_ON_ISR: 1223 case STATE_RADIO_IRQ_ON_ISR:
@@ -1276,36 +1349,6 @@ static void rt2500pci_write_beacon(struct queue_entry *entry,
1276 rt2x00pci_register_write(rt2x00dev, CSR14, reg); 1349 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
1277} 1350}
1278 1351
1279static void rt2500pci_kick_tx_queue(struct data_queue *queue)
1280{
1281 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1282 u32 reg;
1283
1284 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
1285 rt2x00_set_field32(&reg, TXCSR0_KICK_PRIO, (queue->qid == QID_AC_BE));
1286 rt2x00_set_field32(&reg, TXCSR0_KICK_TX, (queue->qid == QID_AC_BK));
1287 rt2x00_set_field32(&reg, TXCSR0_KICK_ATIM, (queue->qid == QID_ATIM));
1288 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
1289}
1290
1291static void rt2500pci_kill_tx_queue(struct data_queue *queue)
1292{
1293 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1294 u32 reg;
1295
1296 if (queue->qid == QID_BEACON) {
1297 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
1298 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 0);
1299 rt2x00_set_field32(&reg, CSR14_TBCN, 0);
1300 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0);
1301 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
1302 } else {
1303 rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
1304 rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
1305 rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
1306 }
1307}
1308
1309/* 1352/*
1310 * RX control handlers 1353 * RX control handlers
1311 */ 1354 */
@@ -1928,8 +1971,8 @@ static const struct rt2x00lib_ops rt2500pci_rt2x00_ops = {
1928 .link_tuner = rt2500pci_link_tuner, 1971 .link_tuner = rt2500pci_link_tuner,
1929 .write_tx_desc = rt2500pci_write_tx_desc, 1972 .write_tx_desc = rt2500pci_write_tx_desc,
1930 .write_beacon = rt2500pci_write_beacon, 1973 .write_beacon = rt2500pci_write_beacon,
1931 .kick_tx_queue = rt2500pci_kick_tx_queue, 1974 .kick_tx_queue = rt2500pci_kick_queue,
1932 .kill_tx_queue = rt2500pci_kill_tx_queue, 1975 .kill_tx_queue = rt2500pci_stop_queue,
1933 .fill_rxdone = rt2500pci_fill_rxdone, 1976 .fill_rxdone = rt2500pci_fill_rxdone,
1934 .config_filter = rt2500pci_config_filter, 1977 .config_filter = rt2500pci_config_filter,
1935 .config_intf = rt2500pci_config_intf, 1978 .config_intf = rt2500pci_config_intf,
diff --git a/drivers/net/wireless/rt2x00/rt2500usb.c b/drivers/net/wireless/rt2x00/rt2500usb.c
index bbfa671f1152..52bd0ed0872b 100644
--- a/drivers/net/wireless/rt2x00/rt2500usb.c
+++ b/drivers/net/wireless/rt2x00/rt2500usb.c
@@ -739,6 +739,57 @@ static void rt2500usb_reset_tuner(struct rt2x00_dev *rt2x00dev,
739} 739}
740 740
741/* 741/*
742 * Queue handlers.
743 */
744static void rt2500usb_start_queue(struct data_queue *queue)
745{
746 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
747 u16 reg;
748
749 switch (queue->qid) {
750 case QID_RX:
751 rt2500usb_register_read(rt2x00dev, TXRX_CSR2, &reg);
752 rt2x00_set_field16(&reg, TXRX_CSR2_DISABLE_RX, 0);
753 rt2500usb_register_write(rt2x00dev, TXRX_CSR2, reg);
754 break;
755 case QID_BEACON:
756 rt2500usb_register_read(rt2x00dev, TXRX_CSR19, &reg);
757 rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 1);
758 rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 1);
759 rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 1);
760 rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
761 break;
762 default:
763 break;
764 }
765}
766
767static void rt2500usb_stop_queue(struct data_queue *queue)
768{
769 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
770 u16 reg;
771
772 switch (queue->qid) {
773 case QID_RX:
774 rt2500usb_register_read(rt2x00dev, TXRX_CSR2, &reg);
775 rt2x00_set_field16(&reg, TXRX_CSR2_DISABLE_RX, 1);
776 rt2500usb_register_write(rt2x00dev, TXRX_CSR2, reg);
777 break;
778 case QID_BEACON:
779 rt2500usb_register_read(rt2x00dev, TXRX_CSR19, &reg);
780 rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 0);
781 rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 0);
782 rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 0);
783 rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
784 break;
785 default:
786 break;
787 }
788
789 rt2x00usb_stop_queue(queue);
790}
791
792/*
742 * Initialization functions. 793 * Initialization functions.
743 */ 794 */
744static int rt2500usb_init_registers(struct rt2x00_dev *rt2x00dev) 795static int rt2500usb_init_registers(struct rt2x00_dev *rt2x00dev)
@@ -931,17 +982,6 @@ static int rt2500usb_init_bbp(struct rt2x00_dev *rt2x00dev)
931/* 982/*
932 * Device state switch handlers. 983 * Device state switch handlers.
933 */ 984 */
934static void rt2500usb_toggle_rx(struct rt2x00_dev *rt2x00dev,
935 enum dev_state state)
936{
937 u16 reg;
938
939 rt2500usb_register_read(rt2x00dev, TXRX_CSR2, &reg);
940 rt2x00_set_field16(&reg, TXRX_CSR2_DISABLE_RX,
941 (state == STATE_RADIO_RX_OFF));
942 rt2500usb_register_write(rt2x00dev, TXRX_CSR2, reg);
943}
944
945static int rt2500usb_enable_radio(struct rt2x00_dev *rt2x00dev) 985static int rt2500usb_enable_radio(struct rt2x00_dev *rt2x00dev)
946{ 986{
947 /* 987 /*
@@ -1018,8 +1058,10 @@ static int rt2500usb_set_device_state(struct rt2x00_dev *rt2x00dev,
1018 rt2500usb_disable_radio(rt2x00dev); 1058 rt2500usb_disable_radio(rt2x00dev);
1019 break; 1059 break;
1020 case STATE_RADIO_RX_ON: 1060 case STATE_RADIO_RX_ON:
1061 rt2500usb_start_queue(rt2x00dev->rx);
1062 break;
1021 case STATE_RADIO_RX_OFF: 1063 case STATE_RADIO_RX_OFF:
1022 rt2500usb_toggle_rx(rt2x00dev, state); 1064 rt2500usb_stop_queue(rt2x00dev->rx);
1023 break; 1065 break;
1024 case STATE_RADIO_IRQ_ON: 1066 case STATE_RADIO_IRQ_ON:
1025 case STATE_RADIO_IRQ_ON_ISR: 1067 case STATE_RADIO_IRQ_ON_ISR:
@@ -1203,22 +1245,6 @@ static int rt2500usb_get_tx_data_len(struct queue_entry *entry)
1203 return length; 1245 return length;
1204} 1246}
1205 1247
1206static void rt2500usb_kill_tx_queue(struct data_queue *queue)
1207{
1208 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1209 u16 reg;
1210
1211 if (queue->qid == QID_BEACON) {
1212 rt2500usb_register_read(rt2x00dev, TXRX_CSR19, &reg);
1213 rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 0);
1214 rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 0);
1215 rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 0);
1216 rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
1217 }
1218
1219 rt2x00usb_kill_tx_queue(queue);
1220}
1221
1222/* 1248/*
1223 * RX control handlers 1249 * RX control handlers
1224 */ 1250 */
@@ -1823,7 +1849,7 @@ static const struct rt2x00lib_ops rt2500usb_rt2x00_ops = {
1823 .write_beacon = rt2500usb_write_beacon, 1849 .write_beacon = rt2500usb_write_beacon,
1824 .get_tx_data_len = rt2500usb_get_tx_data_len, 1850 .get_tx_data_len = rt2500usb_get_tx_data_len,
1825 .kick_tx_queue = rt2x00usb_kick_tx_queue, 1851 .kick_tx_queue = rt2x00usb_kick_tx_queue,
1826 .kill_tx_queue = rt2500usb_kill_tx_queue, 1852 .kill_tx_queue = rt2500usb_stop_queue,
1827 .fill_rxdone = rt2500usb_fill_rxdone, 1853 .fill_rxdone = rt2500usb_fill_rxdone,
1828 .config_shared_key = rt2500usb_config_key, 1854 .config_shared_key = rt2500usb_config_key,
1829 .config_pairwise_key = rt2500usb_config_key, 1855 .config_pairwise_key = rt2500usb_config_key,
diff --git a/drivers/net/wireless/rt2x00/rt2800pci.c b/drivers/net/wireless/rt2x00/rt2800pci.c
index 49447222e40f..a7105974a2a1 100644
--- a/drivers/net/wireless/rt2x00/rt2800pci.c
+++ b/drivers/net/wireless/rt2x00/rt2800pci.c
@@ -186,6 +186,77 @@ static inline void rt2800pci_read_eeprom_efuse(struct rt2x00_dev *rt2x00dev)
186#endif /* CONFIG_PCI */ 186#endif /* CONFIG_PCI */
187 187
188/* 188/*
189 * Queue handlers.
190 */
191static void rt2800pci_start_queue(struct data_queue *queue)
192{
193 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
194 u32 reg;
195
196 switch (queue->qid) {
197 case QID_RX:
198 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
199 rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 1);
200 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
201 break;
202 case QID_BEACON:
203 rt2800_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
204 rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1);
205 rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1);
206 rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 1);
207 rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
208 break;
209 default:
210 break;
211 };
212}
213
214static void rt2800pci_kick_queue(struct data_queue *queue)
215{
216 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
217 struct queue_entry *entry;
218
219 switch (queue->qid) {
220 case QID_AC_BE:
221 case QID_AC_BK:
222 case QID_AC_VI:
223 case QID_AC_VO:
224 entry = rt2x00queue_get_entry(queue, Q_INDEX);
225 rt2800_register_write(rt2x00dev, TX_CTX_IDX(queue->qid), entry->entry_idx);
226 break;
227 case QID_MGMT:
228 entry = rt2x00queue_get_entry(queue, Q_INDEX);
229 rt2800_register_write(rt2x00dev, TX_CTX_IDX(5), entry->entry_idx);
230 break;
231 default:
232 break;
233 }
234}
235
236static void rt2800pci_stop_queue(struct data_queue *queue)
237{
238 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
239 u32 reg;
240
241 switch (queue->qid) {
242 case QID_RX:
243 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
244 rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 0);
245 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
246 break;
247 case QID_BEACON:
248 rt2800_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
249 rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0);
250 rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0);
251 rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0);
252 rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
253 break;
254 default:
255 break;
256 }
257}
258
259/*
189 * Firmware functions 260 * Firmware functions
190 */ 261 */
191static char *rt2800pci_get_firmware_name(struct rt2x00_dev *rt2x00dev) 262static char *rt2800pci_get_firmware_name(struct rt2x00_dev *rt2x00dev)
@@ -323,17 +394,6 @@ static int rt2800pci_init_queues(struct rt2x00_dev *rt2x00dev)
323/* 394/*
324 * Device state switch handlers. 395 * Device state switch handlers.
325 */ 396 */
326static void rt2800pci_toggle_rx(struct rt2x00_dev *rt2x00dev,
327 enum dev_state state)
328{
329 u32 reg;
330
331 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
332 rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX,
333 (state == STATE_RADIO_RX_ON));
334 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
335}
336
337static void rt2800pci_toggle_irq(struct rt2x00_dev *rt2x00dev, 397static void rt2800pci_toggle_irq(struct rt2x00_dev *rt2x00dev,
338 enum dev_state state) 398 enum dev_state state)
339{ 399{
@@ -478,8 +538,10 @@ static int rt2800pci_set_device_state(struct rt2x00_dev *rt2x00dev,
478 rt2800pci_set_state(rt2x00dev, STATE_SLEEP); 538 rt2800pci_set_state(rt2x00dev, STATE_SLEEP);
479 break; 539 break;
480 case STATE_RADIO_RX_ON: 540 case STATE_RADIO_RX_ON:
541 rt2800pci_start_queue(rt2x00dev->rx);
542 break;
481 case STATE_RADIO_RX_OFF: 543 case STATE_RADIO_RX_OFF:
482 rt2800pci_toggle_rx(rt2x00dev, state); 544 rt2800pci_stop_queue(rt2x00dev->rx);
483 break; 545 break;
484 case STATE_RADIO_IRQ_ON: 546 case STATE_RADIO_IRQ_ON:
485 case STATE_RADIO_IRQ_ON_ISR: 547 case STATE_RADIO_IRQ_ON_ISR:
@@ -566,45 +628,6 @@ static void rt2800pci_write_tx_desc(struct queue_entry *entry,
566} 628}
567 629
568/* 630/*
569 * TX data initialization
570 */
571static void rt2800pci_kick_tx_queue(struct data_queue *queue)
572{
573 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
574 struct queue_entry *entry = rt2x00queue_get_entry(queue, Q_INDEX);
575 unsigned int qidx;
576
577 if (queue->qid == QID_MGMT)
578 qidx = 5;
579 else
580 qidx = queue->qid;
581
582 rt2800_register_write(rt2x00dev, TX_CTX_IDX(qidx), entry->entry_idx);
583}
584
585static void rt2800pci_kill_tx_queue(struct data_queue *queue)
586{
587 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
588 u32 reg;
589
590 if (queue->qid == QID_BEACON) {
591 rt2800_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
592 rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0);
593 rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0);
594 rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0);
595 rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
596 return;
597 }
598
599 rt2800_register_read(rt2x00dev, WPDMA_RST_IDX, &reg);
600 rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX0, (queue->qid == QID_AC_BE));
601 rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX1, (queue->qid == QID_AC_BK));
602 rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX2, (queue->qid == QID_AC_VI));
603 rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX3, (queue->qid == QID_AC_VO));
604 rt2800_register_write(rt2x00dev, WPDMA_RST_IDX, reg);
605}
606
607/*
608 * RX control handlers 631 * RX control handlers
609 */ 632 */
610static void rt2800pci_fill_rxdone(struct queue_entry *entry, 633static void rt2800pci_fill_rxdone(struct queue_entry *entry,
@@ -984,8 +1007,8 @@ static const struct rt2x00lib_ops rt2800pci_rt2x00_ops = {
984 .write_tx_desc = rt2800pci_write_tx_desc, 1007 .write_tx_desc = rt2800pci_write_tx_desc,
985 .write_tx_data = rt2800_write_tx_data, 1008 .write_tx_data = rt2800_write_tx_data,
986 .write_beacon = rt2800_write_beacon, 1009 .write_beacon = rt2800_write_beacon,
987 .kick_tx_queue = rt2800pci_kick_tx_queue, 1010 .kick_tx_queue = rt2800pci_kick_queue,
988 .kill_tx_queue = rt2800pci_kill_tx_queue, 1011 .kill_tx_queue = rt2800pci_stop_queue,
989 .fill_rxdone = rt2800pci_fill_rxdone, 1012 .fill_rxdone = rt2800pci_fill_rxdone,
990 .config_shared_key = rt2800_config_shared_key, 1013 .config_shared_key = rt2800_config_shared_key,
991 .config_pairwise_key = rt2800_config_pairwise_key, 1014 .config_pairwise_key = rt2800_config_pairwise_key,
diff --git a/drivers/net/wireless/rt2x00/rt2800usb.c b/drivers/net/wireless/rt2x00/rt2800usb.c
index 1dfa59da9272..ee51936d8d1b 100644
--- a/drivers/net/wireless/rt2x00/rt2800usb.c
+++ b/drivers/net/wireless/rt2x00/rt2800usb.c
@@ -50,6 +50,57 @@ module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
50MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption."); 50MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
51 51
52/* 52/*
53 * Queue handlers.
54 */
55static void rt2800usb_start_queue(struct data_queue *queue)
56{
57 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
58 u32 reg;
59
60 switch (queue->qid) {
61 case QID_RX:
62 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
63 rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 1);
64 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
65 break;
66 case QID_BEACON:
67 rt2800_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
68 rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1);
69 rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1);
70 rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 1);
71 rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
72 break;
73 default:
74 break;
75 }
76}
77
78static void rt2800usb_stop_queue(struct data_queue *queue)
79{
80 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
81 u32 reg;
82
83 switch (queue->qid) {
84 case QID_RX:
85 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
86 rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX, 0);
87 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
88 break;
89 case QID_BEACON:
90 rt2800_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
91 rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0);
92 rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0);
93 rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0);
94 rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
95 break;
96 default:
97 break;
98 }
99
100 rt2x00usb_stop_queue(queue);
101}
102
103/*
53 * Firmware functions 104 * Firmware functions
54 */ 105 */
55static char *rt2800usb_get_firmware_name(struct rt2x00_dev *rt2x00dev) 106static char *rt2800usb_get_firmware_name(struct rt2x00_dev *rt2x00dev)
@@ -107,17 +158,6 @@ static int rt2800usb_write_firmware(struct rt2x00_dev *rt2x00dev,
107/* 158/*
108 * Device state switch handlers. 159 * Device state switch handlers.
109 */ 160 */
110static void rt2800usb_toggle_rx(struct rt2x00_dev *rt2x00dev,
111 enum dev_state state)
112{
113 u32 reg;
114
115 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
116 rt2x00_set_field32(&reg, MAC_SYS_CTRL_ENABLE_RX,
117 (state == STATE_RADIO_RX_ON));
118 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
119}
120
121static int rt2800usb_init_registers(struct rt2x00_dev *rt2x00dev) 161static int rt2800usb_init_registers(struct rt2x00_dev *rt2x00dev)
122{ 162{
123 u32 reg; 163 u32 reg;
@@ -215,8 +255,10 @@ static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev,
215 rt2800usb_set_state(rt2x00dev, STATE_SLEEP); 255 rt2800usb_set_state(rt2x00dev, STATE_SLEEP);
216 break; 256 break;
217 case STATE_RADIO_RX_ON: 257 case STATE_RADIO_RX_ON:
258 rt2800usb_start_queue(rt2x00dev->rx);
259 break;
218 case STATE_RADIO_RX_OFF: 260 case STATE_RADIO_RX_OFF:
219 rt2800usb_toggle_rx(rt2x00dev, state); 261 rt2800usb_stop_queue(rt2x00dev->rx);
220 break; 262 break;
221 case STATE_RADIO_IRQ_ON: 263 case STATE_RADIO_IRQ_ON:
222 case STATE_RADIO_IRQ_ON_ISR: 264 case STATE_RADIO_IRQ_ON_ISR:
@@ -389,22 +431,6 @@ static void rt2800usb_work_txdone(struct work_struct *work)
389 } 431 }
390} 432}
391 433
392static void rt2800usb_kill_tx_queue(struct data_queue *queue)
393{
394 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
395 u32 reg;
396
397 if (queue->qid == QID_BEACON) {
398 rt2800_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
399 rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 0);
400 rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0);
401 rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0);
402 rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
403 }
404
405 rt2x00usb_kill_tx_queue(queue);
406}
407
408/* 434/*
409 * RX control handlers 435 * RX control handlers
410 */ 436 */
@@ -605,7 +631,7 @@ static const struct rt2x00lib_ops rt2800usb_rt2x00_ops = {
605 .write_beacon = rt2800_write_beacon, 631 .write_beacon = rt2800_write_beacon,
606 .get_tx_data_len = rt2800usb_get_tx_data_len, 632 .get_tx_data_len = rt2800usb_get_tx_data_len,
607 .kick_tx_queue = rt2x00usb_kick_tx_queue, 633 .kick_tx_queue = rt2x00usb_kick_tx_queue,
608 .kill_tx_queue = rt2800usb_kill_tx_queue, 634 .kill_tx_queue = rt2800usb_stop_queue,
609 .fill_rxdone = rt2800usb_fill_rxdone, 635 .fill_rxdone = rt2800usb_fill_rxdone,
610 .config_shared_key = rt2800_config_shared_key, 636 .config_shared_key = rt2800_config_shared_key,
611 .config_pairwise_key = rt2800_config_pairwise_key, 637 .config_pairwise_key = rt2800_config_pairwise_key,
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index 608200eaf0dc..12958a45e450 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -268,7 +268,7 @@ void rt2x00usb_kick_tx_queue(struct data_queue *queue)
268} 268}
269EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue); 269EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue);
270 270
271static void rt2x00usb_kill_tx_entry(struct queue_entry *entry) 271static void rt2x00usb_kill_entry(struct queue_entry *entry)
272{ 272{
273 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 273 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
274 struct queue_entry_priv_usb *entry_priv = entry->priv_data; 274 struct queue_entry_priv_usb *entry_priv = entry->priv_data;
@@ -287,12 +287,12 @@ static void rt2x00usb_kill_tx_entry(struct queue_entry *entry)
287 usb_kill_urb(bcn_priv->guardian_urb); 287 usb_kill_urb(bcn_priv->guardian_urb);
288} 288}
289 289
290void rt2x00usb_kill_tx_queue(struct data_queue *queue) 290void rt2x00usb_stop_queue(struct data_queue *queue)
291{ 291{
292 rt2x00queue_for_each_entry(queue, Q_INDEX_DONE, Q_INDEX, 292 rt2x00queue_for_each_entry(queue, Q_INDEX_DONE, Q_INDEX,
293 rt2x00usb_kill_tx_entry); 293 rt2x00usb_kill_entry);
294} 294}
295EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue); 295EXPORT_SYMBOL_GPL(rt2x00usb_stop_queue);
296 296
297static void rt2x00usb_watchdog_tx_dma(struct data_queue *queue) 297static void rt2x00usb_watchdog_tx_dma(struct data_queue *queue)
298{ 298{
@@ -316,7 +316,7 @@ static void rt2x00usb_watchdog_tx_dma(struct data_queue *queue)
316 * Kill all entries in the queue, afterwards we need to 316 * Kill all entries in the queue, afterwards we need to
317 * wait a bit for all URBs to be cancelled. 317 * wait a bit for all URBs to be cancelled.
318 */ 318 */
319 rt2x00usb_kill_tx_queue(queue); 319 rt2x00usb_stop_queue(queue);
320 320
321 /* 321 /*
322 * In case that a driver has overriden the txdone_work 322 * In case that a driver has overriden the txdone_work
@@ -423,7 +423,7 @@ void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
423 REGISTER_TIMEOUT); 423 REGISTER_TIMEOUT);
424 424
425 /* 425 /*
426 * The USB version of kill_tx_queue also works 426 * The USB version of also works
427 * on the RX queue. 427 * on the RX queue.
428 */ 428 */
429 rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev->rx); 429 rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev->rx);
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.h b/drivers/net/wireless/rt2x00/rt2x00usb.h
index c2d997f67b3e..656a35f421a3 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.h
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.h
@@ -387,13 +387,13 @@ struct queue_entry_priv_usb_bcn {
387void rt2x00usb_kick_tx_queue(struct data_queue *queue); 387void rt2x00usb_kick_tx_queue(struct data_queue *queue);
388 388
389/** 389/**
390 * rt2x00usb_kill_tx_queue - Kill data queue 390 * rt2x00usb_stop_queue - Stop data queue
391 * @queue: Data queue to kill 391 * @queue: Data queue to stop
392 * 392 *
393 * This will walk through all entries of the queue and kill all 393 * This will walk through all entries of the queue and kill all
394 * previously kicked frames before they can be send. 394 * URB's which were send to the device.
395 */ 395 */
396void rt2x00usb_kill_tx_queue(struct data_queue *queue); 396void rt2x00usb_stop_queue(struct data_queue *queue);
397 397
398/** 398/**
399 * rt2x00usb_watchdog - Watchdog for USB communication 399 * rt2x00usb_watchdog - Watchdog for USB communication
diff --git a/drivers/net/wireless/rt2x00/rt61pci.c b/drivers/net/wireless/rt2x00/rt61pci.c
index 6ad0c1c9ce4e..044f500ff1ab 100644
--- a/drivers/net/wireless/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/rt2x00/rt61pci.c
@@ -1140,6 +1140,106 @@ dynamic_cca_tune:
1140} 1140}
1141 1141
1142/* 1142/*
1143 * Queue handlers.
1144 */
1145static void rt61pci_start_queue(struct data_queue *queue)
1146{
1147 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1148 u32 reg;
1149
1150 switch (queue->qid) {
1151 case QID_RX:
1152 rt2x00pci_register_read(rt2x00dev, TXRX_CSR0, &reg);
1153 rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX, 0);
1154 rt2x00pci_register_write(rt2x00dev, TXRX_CSR0, reg);
1155 break;
1156 case QID_BEACON:
1157 rt2x00pci_register_read(rt2x00dev, TXRX_CSR9, &reg);
1158 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
1159 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 1);
1160 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 1);
1161 rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, reg);
1162 break;
1163 default:
1164 break;
1165 }
1166}
1167
1168static void rt61pci_kick_queue(struct data_queue *queue)
1169{
1170 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1171 u32 reg;
1172
1173 switch (queue->qid) {
1174 case QID_AC_BE:
1175 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1176 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC0, 1);
1177 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1178 break;
1179 case QID_AC_BK:
1180 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1181 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC1, 1);
1182 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1183 break;
1184 case QID_AC_VI:
1185 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1186 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC2, 1);
1187 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1188 break;
1189 case QID_AC_VO:
1190 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1191 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC3, 1);
1192 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1193 break;
1194 default:
1195 break;
1196 }
1197}
1198
1199static void rt61pci_stop_queue(struct data_queue *queue)
1200{
1201 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1202 u32 reg;
1203
1204 switch (queue->qid) {
1205 case QID_AC_BE:
1206 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1207 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC0, 1);
1208 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1209 break;
1210 case QID_AC_BK:
1211 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1212 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC1, 1);
1213 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1214 break;
1215 case QID_AC_VI:
1216 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1217 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC2, 1);
1218 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1219 break;
1220 case QID_AC_VO:
1221 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1222 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC3, 1);
1223 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1224 break;
1225 case QID_RX:
1226 rt2x00pci_register_read(rt2x00dev, TXRX_CSR0, &reg);
1227 rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX, 1);
1228 rt2x00pci_register_write(rt2x00dev, TXRX_CSR0, reg);
1229 break;
1230 case QID_BEACON:
1231 rt2x00pci_register_read(rt2x00dev, TXRX_CSR9, &reg);
1232 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 0);
1233 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 0);
1234 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
1235 rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, reg);
1236 break;
1237 default:
1238 break;
1239 }
1240}
1241
1242/*
1143 * Firmware functions 1243 * Firmware functions
1144 */ 1244 */
1145static char *rt61pci_get_firmware_name(struct rt2x00_dev *rt2x00dev) 1245static char *rt61pci_get_firmware_name(struct rt2x00_dev *rt2x00dev)
@@ -1616,17 +1716,6 @@ static int rt61pci_init_bbp(struct rt2x00_dev *rt2x00dev)
1616/* 1716/*
1617 * Device state switch handlers. 1717 * Device state switch handlers.
1618 */ 1718 */
1619static void rt61pci_toggle_rx(struct rt2x00_dev *rt2x00dev,
1620 enum dev_state state)
1621{
1622 u32 reg;
1623
1624 rt2x00pci_register_read(rt2x00dev, TXRX_CSR0, &reg);
1625 rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX,
1626 (state == STATE_RADIO_RX_OFF));
1627 rt2x00pci_register_write(rt2x00dev, TXRX_CSR0, reg);
1628}
1629
1630static void rt61pci_toggle_irq(struct rt2x00_dev *rt2x00dev, 1719static void rt61pci_toggle_irq(struct rt2x00_dev *rt2x00dev,
1631 enum dev_state state) 1720 enum dev_state state)
1632{ 1721{
@@ -1744,8 +1833,10 @@ static int rt61pci_set_device_state(struct rt2x00_dev *rt2x00dev,
1744 rt61pci_disable_radio(rt2x00dev); 1833 rt61pci_disable_radio(rt2x00dev);
1745 break; 1834 break;
1746 case STATE_RADIO_RX_ON: 1835 case STATE_RADIO_RX_ON:
1836 rt61pci_start_queue(rt2x00dev->rx);
1837 break;
1747 case STATE_RADIO_RX_OFF: 1838 case STATE_RADIO_RX_OFF:
1748 rt61pci_toggle_rx(rt2x00dev, state); 1839 rt61pci_stop_queue(rt2x00dev->rx);
1749 break; 1840 break;
1750 case STATE_RADIO_IRQ_ON: 1841 case STATE_RADIO_IRQ_ON:
1751 case STATE_RADIO_IRQ_ON_ISR: 1842 case STATE_RADIO_IRQ_ON_ISR:
@@ -1925,41 +2016,6 @@ static void rt61pci_write_beacon(struct queue_entry *entry,
1925 entry->skb = NULL; 2016 entry->skb = NULL;
1926} 2017}
1927 2018
1928static void rt61pci_kick_tx_queue(struct data_queue *queue)
1929{
1930 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1931 u32 reg;
1932
1933 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1934 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC0, (queue->qid == QID_AC_BE));
1935 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC1, (queue->qid == QID_AC_BK));
1936 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC2, (queue->qid == QID_AC_VI));
1937 rt2x00_set_field32(&reg, TX_CNTL_CSR_KICK_TX_AC3, (queue->qid == QID_AC_VO));
1938 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1939}
1940
1941static void rt61pci_kill_tx_queue(struct data_queue *queue)
1942{
1943 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1944 u32 reg;
1945
1946 if (queue->qid == QID_BEACON) {
1947 rt2x00pci_register_read(rt2x00dev, TXRX_CSR9, &reg);
1948 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 0);
1949 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 0);
1950 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
1951 rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, reg);
1952 return;
1953 }
1954
1955 rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
1956 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC0, (queue->qid == QID_AC_BE));
1957 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC1, (queue->qid == QID_AC_BK));
1958 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC2, (queue->qid == QID_AC_VI));
1959 rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC3, (queue->qid == QID_AC_VO));
1960 rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
1961}
1962
1963/* 2019/*
1964 * RX control handlers 2020 * RX control handlers
1965 */ 2021 */
@@ -2846,8 +2902,8 @@ static const struct rt2x00lib_ops rt61pci_rt2x00_ops = {
2846 .link_tuner = rt61pci_link_tuner, 2902 .link_tuner = rt61pci_link_tuner,
2847 .write_tx_desc = rt61pci_write_tx_desc, 2903 .write_tx_desc = rt61pci_write_tx_desc,
2848 .write_beacon = rt61pci_write_beacon, 2904 .write_beacon = rt61pci_write_beacon,
2849 .kick_tx_queue = rt61pci_kick_tx_queue, 2905 .kick_tx_queue = rt61pci_kick_queue,
2850 .kill_tx_queue = rt61pci_kill_tx_queue, 2906 .kill_tx_queue = rt61pci_stop_queue,
2851 .fill_rxdone = rt61pci_fill_rxdone, 2907 .fill_rxdone = rt61pci_fill_rxdone,
2852 .config_shared_key = rt61pci_config_shared_key, 2908 .config_shared_key = rt61pci_config_shared_key,
2853 .config_pairwise_key = rt61pci_config_pairwise_key, 2909 .config_pairwise_key = rt61pci_config_pairwise_key,
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index 3934dad709c6..e9b1e3d5f47c 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -1031,6 +1031,57 @@ dynamic_cca_tune:
1031} 1031}
1032 1032
1033/* 1033/*
1034 * Queue handlers.
1035 */
1036static void rt73usb_start_queue(struct data_queue *queue)
1037{
1038 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1039 u32 reg;
1040
1041 switch (queue->qid) {
1042 case QID_RX:
1043 rt2x00usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
1044 rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX, 0);
1045 rt2x00usb_register_write(rt2x00dev, TXRX_CSR0, reg);
1046 break;
1047 case QID_BEACON:
1048 rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
1049 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
1050 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 1);
1051 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 1);
1052 rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
1053 break;
1054 default:
1055 break;
1056 }
1057}
1058
1059static void rt73usb_stop_queue(struct data_queue *queue)
1060{
1061 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1062 u32 reg;
1063
1064 switch (queue->qid) {
1065 case QID_RX:
1066 rt2x00usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
1067 rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX, 1);
1068 rt2x00usb_register_write(rt2x00dev, TXRX_CSR0, reg);
1069 break;
1070 case QID_BEACON:
1071 rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
1072 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 0);
1073 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 0);
1074 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
1075 rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
1076 break;
1077 default:
1078 break;
1079 }
1080
1081 rt2x00usb_stop_queue(queue);
1082}
1083
1084/*
1034 * Firmware functions 1085 * Firmware functions
1035 */ 1086 */
1036static char *rt73usb_get_firmware_name(struct rt2x00_dev *rt2x00dev) 1087static char *rt73usb_get_firmware_name(struct rt2x00_dev *rt2x00dev)
@@ -1324,17 +1375,6 @@ static int rt73usb_init_bbp(struct rt2x00_dev *rt2x00dev)
1324/* 1375/*
1325 * Device state switch handlers. 1376 * Device state switch handlers.
1326 */ 1377 */
1327static void rt73usb_toggle_rx(struct rt2x00_dev *rt2x00dev,
1328 enum dev_state state)
1329{
1330 u32 reg;
1331
1332 rt2x00usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
1333 rt2x00_set_field32(&reg, TXRX_CSR0_DISABLE_RX,
1334 (state == STATE_RADIO_RX_OFF));
1335 rt2x00usb_register_write(rt2x00dev, TXRX_CSR0, reg);
1336}
1337
1338static int rt73usb_enable_radio(struct rt2x00_dev *rt2x00dev) 1378static int rt73usb_enable_radio(struct rt2x00_dev *rt2x00dev)
1339{ 1379{
1340 /* 1380 /*
@@ -1402,8 +1442,10 @@ static int rt73usb_set_device_state(struct rt2x00_dev *rt2x00dev,
1402 rt73usb_disable_radio(rt2x00dev); 1442 rt73usb_disable_radio(rt2x00dev);
1403 break; 1443 break;
1404 case STATE_RADIO_RX_ON: 1444 case STATE_RADIO_RX_ON:
1445 rt73usb_start_queue(rt2x00dev->rx);
1446 break;
1405 case STATE_RADIO_RX_OFF: 1447 case STATE_RADIO_RX_OFF:
1406 rt73usb_toggle_rx(rt2x00dev, state); 1448 rt73usb_stop_queue(rt2x00dev->rx);
1407 break; 1449 break;
1408 case STATE_RADIO_IRQ_ON: 1450 case STATE_RADIO_IRQ_ON:
1409 case STATE_RADIO_IRQ_ON_ISR: 1451 case STATE_RADIO_IRQ_ON_ISR:
@@ -1579,22 +1621,6 @@ static int rt73usb_get_tx_data_len(struct queue_entry *entry)
1579 return length; 1621 return length;
1580} 1622}
1581 1623
1582static void rt73usb_kill_tx_queue(struct data_queue *queue)
1583{
1584 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev;
1585 u32 reg;
1586
1587 if (queue->qid == QID_BEACON) {
1588 rt2x00usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
1589 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 0);
1590 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE, 0);
1591 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
1592 rt2x00usb_register_write(rt2x00dev, TXRX_CSR9, reg);
1593 }
1594
1595 rt2x00usb_kill_tx_queue(queue);
1596}
1597
1598/* 1624/*
1599 * RX control handlers 1625 * RX control handlers
1600 */ 1626 */
@@ -2290,7 +2316,7 @@ static const struct rt2x00lib_ops rt73usb_rt2x00_ops = {
2290 .write_beacon = rt73usb_write_beacon, 2316 .write_beacon = rt73usb_write_beacon,
2291 .get_tx_data_len = rt73usb_get_tx_data_len, 2317 .get_tx_data_len = rt73usb_get_tx_data_len,
2292 .kick_tx_queue = rt2x00usb_kick_tx_queue, 2318 .kick_tx_queue = rt2x00usb_kick_tx_queue,
2293 .kill_tx_queue = rt73usb_kill_tx_queue, 2319 .kill_tx_queue = rt73usb_stop_queue,
2294 .fill_rxdone = rt73usb_fill_rxdone, 2320 .fill_rxdone = rt73usb_fill_rxdone,
2295 .config_shared_key = rt73usb_config_shared_key, 2321 .config_shared_key = rt73usb_config_shared_key,
2296 .config_pairwise_key = rt73usb_config_pairwise_key, 2322 .config_pairwise_key = rt73usb_config_pairwise_key,
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-10 12:55:27 -0500