aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/rtlwifi/pci.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/rtlwifi/pci.c')
-rw-r--r--drivers/net/wireless/rtlwifi/pci.c853
1 files changed, 549 insertions, 304 deletions
diff --git a/drivers/net/wireless/rtlwifi/pci.c b/drivers/net/wireless/rtlwifi/pci.c
index 74a8ba4b8844..667aba81246c 100644
--- a/drivers/net/wireless/rtlwifi/pci.c
+++ b/drivers/net/wireless/rtlwifi/pci.c
@@ -33,6 +33,7 @@
33#include "base.h" 33#include "base.h"
34#include "ps.h" 34#include "ps.h"
35#include "efuse.h" 35#include "efuse.h"
36#include <linux/interrupt.h>
36#include <linux/export.h> 37#include <linux/export.h>
37#include <linux/kmemleak.h> 38#include <linux/kmemleak.h>
38#include <linux/module.h> 39#include <linux/module.h>
@@ -44,10 +45,10 @@ MODULE_LICENSE("GPL");
44MODULE_DESCRIPTION("PCI basic driver for rtlwifi"); 45MODULE_DESCRIPTION("PCI basic driver for rtlwifi");
45 46
46static const u16 pcibridge_vendors[PCI_BRIDGE_VENDOR_MAX] = { 47static const u16 pcibridge_vendors[PCI_BRIDGE_VENDOR_MAX] = {
47 PCI_VENDOR_ID_INTEL, 48 INTEL_VENDOR_ID,
48 PCI_VENDOR_ID_ATI, 49 ATI_VENDOR_ID,
49 PCI_VENDOR_ID_AMD, 50 AMD_VENDOR_ID,
50 PCI_VENDOR_ID_SI 51 SIS_VENDOR_ID
51}; 52};
52 53
53static const u8 ac_to_hwq[] = { 54static const u8 ac_to_hwq[] = {
@@ -566,27 +567,25 @@ static void _rtl_pci_tx_isr(struct ieee80211_hw *hw, int prio)
566 struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[prio]; 567 struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[prio];
567 568
568 while (skb_queue_len(&ring->queue)) { 569 while (skb_queue_len(&ring->queue)) {
569 struct rtl_tx_desc *entry = &ring->desc[ring->idx];
570 struct sk_buff *skb; 570 struct sk_buff *skb;
571 struct ieee80211_tx_info *info; 571 struct ieee80211_tx_info *info;
572 __le16 fc; 572 __le16 fc;
573 u8 tid; 573 u8 tid;
574 u8 *entry;
574 575
575 u8 own = (u8) rtlpriv->cfg->ops->get_desc((u8 *) entry, true, 576 if (rtlpriv->use_new_trx_flow)
576 HW_DESC_OWN); 577 entry = (u8 *)(&ring->buffer_desc[ring->idx]);
578 else
579 entry = (u8 *)(&ring->desc[ring->idx]);
577 580
578 /*beacon packet will only use the first 581 if (!rtlpriv->cfg->ops->is_tx_desc_closed(hw, prio, ring->idx))
579 *descriptor by defaut, and the own may not
580 *be cleared by the hardware
581 */
582 if (own)
583 return; 582 return;
584 ring->idx = (ring->idx + 1) % ring->entries; 583 ring->idx = (ring->idx + 1) % ring->entries;
585 584
586 skb = __skb_dequeue(&ring->queue); 585 skb = __skb_dequeue(&ring->queue);
587 pci_unmap_single(rtlpci->pdev, 586 pci_unmap_single(rtlpci->pdev,
588 rtlpriv->cfg->ops-> 587 rtlpriv->cfg->ops->
589 get_desc((u8 *) entry, true, 588 get_desc((u8 *)entry, true,
590 HW_DESC_TXBUFF_ADDR), 589 HW_DESC_TXBUFF_ADDR),
591 skb->len, PCI_DMA_TODEVICE); 590 skb->len, PCI_DMA_TODEVICE);
592 591
@@ -598,7 +597,7 @@ static void _rtl_pci_tx_isr(struct ieee80211_hw *hw, int prio)
598 "new ring->idx:%d, free: skb_queue_len:%d, free: seq:%x\n", 597 "new ring->idx:%d, free: skb_queue_len:%d, free: seq:%x\n",
599 ring->idx, 598 ring->idx,
600 skb_queue_len(&ring->queue), 599 skb_queue_len(&ring->queue),
601 *(u16 *) (skb->data + 22)); 600 *(u16 *)(skb->data + 22));
602 601
603 if (prio == TXCMD_QUEUE) { 602 if (prio == TXCMD_QUEUE) {
604 dev_kfree_skb(skb); 603 dev_kfree_skb(skb);
@@ -666,175 +665,276 @@ tx_status_ok:
666 } 665 }
667} 666}
668 667
669static void _rtl_receive_one(struct ieee80211_hw *hw, struct sk_buff *skb, 668static int _rtl_pci_init_one_rxdesc(struct ieee80211_hw *hw,
670 struct ieee80211_rx_status rx_status) 669 u8 *entry, int rxring_idx, int desc_idx)
671{ 670{
672 struct rtl_priv *rtlpriv = rtl_priv(hw); 671 struct rtl_priv *rtlpriv = rtl_priv(hw);
673 struct ieee80211_hdr *hdr = rtl_get_hdr(skb); 672 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
674 __le16 fc = rtl_get_fc(skb); 673 u32 bufferaddress;
675 bool unicast = false; 674 u8 tmp_one = 1;
676 struct sk_buff *uskb = NULL; 675 struct sk_buff *skb;
677 u8 *pdata; 676
678 677 skb = dev_alloc_skb(rtlpci->rxbuffersize);
679 678 if (!skb)
680 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status)); 679 return 0;
681 680 rtlpci->rx_ring[rxring_idx].rx_buf[desc_idx] = skb;
682 if (is_broadcast_ether_addr(hdr->addr1)) { 681
683 ;/*TODO*/ 682 /* just set skb->cb to mapping addr for pci_unmap_single use */
684 } else if (is_multicast_ether_addr(hdr->addr1)) { 683 *((dma_addr_t *)skb->cb) =
685 ;/*TODO*/ 684 pci_map_single(rtlpci->pdev, skb_tail_pointer(skb),
685 rtlpci->rxbuffersize, PCI_DMA_FROMDEVICE);
686 bufferaddress = *((dma_addr_t *)skb->cb);
687 if (pci_dma_mapping_error(rtlpci->pdev, bufferaddress))
688 return 0;
689 if (rtlpriv->use_new_trx_flow) {
690 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
691 HW_DESC_RX_PREPARE,
692 (u8 *)&bufferaddress);
686 } else { 693 } else {
687 unicast = true; 694 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
688 rtlpriv->stats.rxbytesunicast += skb->len; 695 HW_DESC_RXBUFF_ADDR,
696 (u8 *)&bufferaddress);
697 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
698 HW_DESC_RXPKT_LEN,
699 (u8 *)&rtlpci->rxbuffersize);
700 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
701 HW_DESC_RXOWN,
702 (u8 *)&tmp_one);
689 } 703 }
704 return 1;
705}
690 706
691 if (ieee80211_is_data(fc)) { 707/* inorder to receive 8K AMSDU we have set skb to
692 rtlpriv->cfg->ops->led_control(hw, LED_CTL_RX); 708 * 9100bytes in init rx ring, but if this packet is
693 709 * not a AMSDU, this large packet will be sent to
694 if (unicast) 710 * TCP/IP directly, this cause big packet ping fail
695 rtlpriv->link_info.num_rx_inperiod++; 711 * like: "ping -s 65507", so here we will realloc skb
712 * based on the true size of packet, Mac80211
713 * Probably will do it better, but does not yet.
714 *
715 * Some platform will fail when alloc skb sometimes.
716 * in this condition, we will send the old skb to
717 * mac80211 directly, this will not cause any other
718 * issues, but only this packet will be lost by TCP/IP
719 */
720static void _rtl_pci_rx_to_mac80211(struct ieee80211_hw *hw,
721 struct sk_buff *skb,
722 struct ieee80211_rx_status rx_status)
723{
724 if (unlikely(!rtl_action_proc(hw, skb, false))) {
725 dev_kfree_skb_any(skb);
726 } else {
727 struct sk_buff *uskb = NULL;
728 u8 *pdata;
729
730 uskb = dev_alloc_skb(skb->len + 128);
731 if (likely(uskb)) {
732 memcpy(IEEE80211_SKB_RXCB(uskb), &rx_status,
733 sizeof(rx_status));
734 pdata = (u8 *)skb_put(uskb, skb->len);
735 memcpy(pdata, skb->data, skb->len);
736 dev_kfree_skb_any(skb);
737 ieee80211_rx_irqsafe(hw, uskb);
738 } else {
739 ieee80211_rx_irqsafe(hw, skb);
740 }
696 } 741 }
742}
697 743
698 /* static bcn for roaming */ 744/*hsisr interrupt handler*/
699 rtl_beacon_statistic(hw, skb); 745static void _rtl_pci_hs_interrupt(struct ieee80211_hw *hw)
700 rtl_p2p_info(hw, (void *)skb->data, skb->len); 746{
701 747 struct rtl_priv *rtlpriv = rtl_priv(hw);
702 /* for sw lps */ 748 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
703 rtl_swlps_beacon(hw, (void *)skb->data, skb->len);
704 rtl_recognize_peer(hw, (void *)skb->data, skb->len);
705 if ((rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP) &&
706 (rtlpriv->rtlhal.current_bandtype == BAND_ON_2_4G) &&
707 (ieee80211_is_beacon(fc) || ieee80211_is_probe_resp(fc)))
708 return;
709
710 if (unlikely(!rtl_action_proc(hw, skb, false)))
711 return;
712
713 uskb = dev_alloc_skb(skb->len + 128);
714 if (!uskb)
715 return; /* exit if allocation failed */
716 memcpy(IEEE80211_SKB_RXCB(uskb), &rx_status, sizeof(rx_status));
717 pdata = (u8 *)skb_put(uskb, skb->len);
718 memcpy(pdata, skb->data, skb->len);
719 749
720 ieee80211_rx_irqsafe(hw, uskb); 750 rtl_write_byte(rtlpriv, rtlpriv->cfg->maps[MAC_HSISR],
751 rtl_read_byte(rtlpriv, rtlpriv->cfg->maps[MAC_HSISR]) |
752 rtlpci->sys_irq_mask);
721} 753}
722 754
723static void _rtl_pci_rx_interrupt(struct ieee80211_hw *hw) 755static void _rtl_pci_rx_interrupt(struct ieee80211_hw *hw)
724{ 756{
725 struct rtl_priv *rtlpriv = rtl_priv(hw); 757 struct rtl_priv *rtlpriv = rtl_priv(hw);
726 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 758 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
727 int rx_queue_idx = RTL_PCI_RX_MPDU_QUEUE; 759 int rxring_idx = RTL_PCI_RX_MPDU_QUEUE;
728
729 struct ieee80211_rx_status rx_status = { 0 }; 760 struct ieee80211_rx_status rx_status = { 0 };
730 unsigned int count = rtlpci->rxringcount; 761 unsigned int count = rtlpci->rxringcount;
731 u8 own; 762 u8 own;
732 u8 tmp_one; 763 u8 tmp_one;
733 u32 bufferaddress; 764 bool unicast = false;
734 765 u8 hw_queue = 0;
766 unsigned int rx_remained_cnt;
735 struct rtl_stats stats = { 767 struct rtl_stats stats = {
736 .signal = 0, 768 .signal = 0,
737 .rate = 0, 769 .rate = 0,
738 }; 770 };
739 int index = rtlpci->rx_ring[rx_queue_idx].idx;
740 771
741 if (rtlpci->driver_is_goingto_unload)
742 return;
743 /*RX NORMAL PKT */ 772 /*RX NORMAL PKT */
744 while (count--) { 773 while (count--) {
745 /*rx descriptor */ 774 struct ieee80211_hdr *hdr;
746 struct rtl_rx_desc *pdesc = &rtlpci->rx_ring[rx_queue_idx].desc[ 775 __le16 fc;
747 index]; 776 u16 len;
777 /*rx buffer descriptor */
778 struct rtl_rx_buffer_desc *buffer_desc = NULL;
779 /*if use new trx flow, it means wifi info */
780 struct rtl_rx_desc *pdesc = NULL;
748 /*rx pkt */ 781 /*rx pkt */
749 struct sk_buff *skb = rtlpci->rx_ring[rx_queue_idx].rx_buf[ 782 struct sk_buff *skb = rtlpci->rx_ring[rxring_idx].rx_buf[
750 index]; 783 rtlpci->rx_ring[rxring_idx].idx];
751 struct sk_buff *new_skb = NULL; 784
752 785 if (rtlpriv->use_new_trx_flow) {
753 own = (u8) rtlpriv->cfg->ops->get_desc((u8 *) pdesc, 786 rx_remained_cnt =
754 false, HW_DESC_OWN); 787 rtlpriv->cfg->ops->rx_desc_buff_remained_cnt(hw,
755 788 hw_queue);
756 /*wait data to be filled by hardware */ 789 if (rx_remained_cnt < 1)
757 if (own) 790 return;
758 break; 791
792 } else { /* rx descriptor */
793 pdesc = &rtlpci->rx_ring[rxring_idx].desc[
794 rtlpci->rx_ring[rxring_idx].idx];
795
796 own = (u8)rtlpriv->cfg->ops->get_desc((u8 *)pdesc,
797 false,
798 HW_DESC_OWN);
799 if (own) /* wait data to be filled by hardware */
800 return;
801 }
759 802
803 /* Reaching this point means: data is filled already
804 * AAAAAAttention !!!
805 * We can NOT access 'skb' before 'pci_unmap_single'
806 */
807 pci_unmap_single(rtlpci->pdev, *((dma_addr_t *)skb->cb),
808 rtlpci->rxbuffersize, PCI_DMA_FROMDEVICE);
809
810 if (rtlpriv->use_new_trx_flow) {
811 buffer_desc =
812 &rtlpci->rx_ring[rxring_idx].buffer_desc
813 [rtlpci->rx_ring[rxring_idx].idx];
814 /*means rx wifi info*/
815 pdesc = (struct rtl_rx_desc *)skb->data;
816 }
817 memset(&rx_status , 0 , sizeof(rx_status));
760 rtlpriv->cfg->ops->query_rx_desc(hw, &stats, 818 rtlpriv->cfg->ops->query_rx_desc(hw, &stats,
761 &rx_status, 819 &rx_status, (u8 *)pdesc, skb);
762 (u8 *) pdesc, skb);
763 820
764 if (stats.crc || stats.hwerror) 821 if (rtlpriv->use_new_trx_flow)
765 goto done; 822 rtlpriv->cfg->ops->rx_check_dma_ok(hw,
823 (u8 *)buffer_desc,
824 hw_queue);
766 825
767 new_skb = dev_alloc_skb(rtlpci->rxbuffersize); 826 len = rtlpriv->cfg->ops->get_desc((u8 *)pdesc, false,
768 if (unlikely(!new_skb)) { 827 HW_DESC_RXPKT_LEN);
769 RT_TRACE(rtlpriv, (COMP_INTR | COMP_RECV), DBG_DMESG,
770 "can't alloc skb for rx\n");
771 goto done;
772 }
773 kmemleak_not_leak(new_skb);
774 828
775 pci_unmap_single(rtlpci->pdev, 829 if (skb->end - skb->tail > len) {
776 *((dma_addr_t *) skb->cb), 830 skb_put(skb, len);
777 rtlpci->rxbuffersize, 831 if (rtlpriv->use_new_trx_flow)
778 PCI_DMA_FROMDEVICE); 832 skb_reserve(skb, stats.rx_drvinfo_size +
833 stats.rx_bufshift + 24);
834 else
835 skb_reserve(skb, stats.rx_drvinfo_size +
836 stats.rx_bufshift);
779 837
780 skb_put(skb, rtlpriv->cfg->ops->get_desc((u8 *) pdesc, false, 838 } else {
781 HW_DESC_RXPKT_LEN)); 839 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
782 skb_reserve(skb, stats.rx_drvinfo_size + stats.rx_bufshift); 840 "skb->end - skb->tail = %d, len is %d\n",
841 skb->end - skb->tail, len);
842 break;
843 }
844 /* handle command packet here */
845 if (rtlpriv->cfg->ops->rx_command_packet(hw, stats, skb)) {
846 dev_kfree_skb_any(skb);
847 goto end;
848 }
783 849
784 /* 850 /*
785 * NOTICE This can not be use for mac80211, 851 * NOTICE This can not be use for mac80211,
786 * this is done in mac80211 code, 852 * this is done in mac80211 code,
787 * if you done here sec DHCP will fail 853 * if done here sec DHCP will fail
788 * skb_trim(skb, skb->len - 4); 854 * skb_trim(skb, skb->len - 4);
789 */ 855 */
790 856
791 _rtl_receive_one(hw, skb, rx_status); 857 hdr = rtl_get_hdr(skb);
858 fc = rtl_get_fc(skb);
859
860 if (!stats.crc && !stats.hwerror) {
861 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status,
862 sizeof(rx_status));
863
864 if (is_broadcast_ether_addr(hdr->addr1)) {
865 ;/*TODO*/
866 } else if (is_multicast_ether_addr(hdr->addr1)) {
867 ;/*TODO*/
868 } else {
869 unicast = true;
870 rtlpriv->stats.rxbytesunicast += skb->len;
871 }
872 rtl_is_special_data(hw, skb, false);
792 873
874 if (ieee80211_is_data(fc)) {
875 rtlpriv->cfg->ops->led_control(hw, LED_CTL_RX);
876 if (unicast)
877 rtlpriv->link_info.num_rx_inperiod++;
878 }
879 /* static bcn for roaming */
880 rtl_beacon_statistic(hw, skb);
881 rtl_p2p_info(hw, (void *)skb->data, skb->len);
882 /* for sw lps */
883 rtl_swlps_beacon(hw, (void *)skb->data, skb->len);
884 rtl_recognize_peer(hw, (void *)skb->data, skb->len);
885 if ((rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP) &&
886 (rtlpriv->rtlhal.current_bandtype ==
887 BAND_ON_2_4G) &&
888 (ieee80211_is_beacon(fc) ||
889 ieee80211_is_probe_resp(fc))) {
890 dev_kfree_skb_any(skb);
891 } else {
892 _rtl_pci_rx_to_mac80211(hw, skb, rx_status);
893 }
894 } else {
895 dev_kfree_skb_any(skb);
896 }
897 if (rtlpriv->use_new_trx_flow) {
898 rtlpci->rx_ring[hw_queue].next_rx_rp += 1;
899 rtlpci->rx_ring[hw_queue].next_rx_rp %=
900 RTL_PCI_MAX_RX_COUNT;
901
902 rx_remained_cnt--;
903 rtl_write_word(rtlpriv, 0x3B4,
904 rtlpci->rx_ring[hw_queue].next_rx_rp);
905 }
793 if (((rtlpriv->link_info.num_rx_inperiod + 906 if (((rtlpriv->link_info.num_rx_inperiod +
794 rtlpriv->link_info.num_tx_inperiod) > 8) || 907 rtlpriv->link_info.num_tx_inperiod) > 8) ||
795 (rtlpriv->link_info.num_rx_inperiod > 2)) { 908 (rtlpriv->link_info.num_rx_inperiod > 2)) {
796 rtlpriv->enter_ps = false; 909 rtlpriv->enter_ps = false;
797 schedule_work(&rtlpriv->works.lps_change_work); 910 schedule_work(&rtlpriv->works.lps_change_work);
798 } 911 }
912end:
913 if (rtlpriv->use_new_trx_flow) {
914 _rtl_pci_init_one_rxdesc(hw, (u8 *)buffer_desc,
915 rxring_idx,
916 rtlpci->rx_ring[rxring_idx].idx);
917 } else {
918 _rtl_pci_init_one_rxdesc(hw, (u8 *)pdesc, rxring_idx,
919 rtlpci->rx_ring[rxring_idx].idx);
799 920
800 dev_kfree_skb_any(skb); 921 if (rtlpci->rx_ring[rxring_idx].idx ==
801 skb = new_skb; 922 rtlpci->rxringcount - 1)
802 923 rtlpriv->cfg->ops->set_desc(hw, (u8 *)pdesc,
803 rtlpci->rx_ring[rx_queue_idx].rx_buf[index] = skb; 924 false,
804 *((dma_addr_t *) skb->cb) = 925 HW_DESC_RXERO,
805 pci_map_single(rtlpci->pdev, skb_tail_pointer(skb), 926 (u8 *)&tmp_one);
806 rtlpci->rxbuffersize, 927 }
807 PCI_DMA_FROMDEVICE); 928 rtlpci->rx_ring[rxring_idx].idx =
808 929 (rtlpci->rx_ring[rxring_idx].idx + 1) %
809done: 930 rtlpci->rxringcount;
810 bufferaddress = (*((dma_addr_t *)skb->cb));
811 if (pci_dma_mapping_error(rtlpci->pdev, bufferaddress))
812 return;
813 tmp_one = 1;
814 rtlpriv->cfg->ops->set_desc(hw, (u8 *)pdesc, false,
815 HW_DESC_RXBUFF_ADDR,
816 (u8 *)&bufferaddress);
817 rtlpriv->cfg->ops->set_desc(hw, (u8 *)pdesc, false,
818 HW_DESC_RXPKT_LEN,
819 (u8 *)&rtlpci->rxbuffersize);
820
821 if (index == rtlpci->rxringcount - 1)
822 rtlpriv->cfg->ops->set_desc(hw, (u8 *)pdesc, false,
823 HW_DESC_RXERO,
824 &tmp_one);
825
826 rtlpriv->cfg->ops->set_desc(hw, (u8 *)pdesc, false, HW_DESC_RXOWN,
827 &tmp_one);
828
829 index = (index + 1) % rtlpci->rxringcount;
830 } 931 }
831
832 rtlpci->rx_ring[rx_queue_idx].idx = index;
833} 932}
834 933
835static irqreturn_t _rtl_pci_interrupt(int irq, void *dev_id) 934static irqreturn_t _rtl_pci_interrupt(int irq, void *dev_id)
836{ 935{
837 struct ieee80211_hw *hw = dev_id; 936 struct ieee80211_hw *hw = dev_id;
937 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
838 struct rtl_priv *rtlpriv = rtl_priv(hw); 938 struct rtl_priv *rtlpriv = rtl_priv(hw);
839 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 939 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
840 unsigned long flags; 940 unsigned long flags;
@@ -842,16 +942,18 @@ static irqreturn_t _rtl_pci_interrupt(int irq, void *dev_id)
842 u32 intb = 0; 942 u32 intb = 0;
843 irqreturn_t ret = IRQ_HANDLED; 943 irqreturn_t ret = IRQ_HANDLED;
844 944
845 spin_lock_irqsave(&rtlpriv->locks.irq_th_lock, flags); 945 if (rtlpci->irq_enabled == 0)
946 return ret;
947
948 spin_lock_irqsave(&rtlpriv->locks.irq_th_lock , flags);
949 rtlpriv->cfg->ops->disable_interrupt(hw);
846 950
847 /*read ISR: 4/8bytes */ 951 /*read ISR: 4/8bytes */
848 rtlpriv->cfg->ops->interrupt_recognized(hw, &inta, &intb); 952 rtlpriv->cfg->ops->interrupt_recognized(hw, &inta, &intb);
849 953
850 /*Shared IRQ or HW disappared */ 954 /*Shared IRQ or HW disappared */
851 if (!inta || inta == 0xffff) { 955 if (!inta || inta == 0xffff)
852 ret = IRQ_NONE;
853 goto done; 956 goto done;
854 }
855 957
856 /*<1> beacon related */ 958 /*<1> beacon related */
857 if (inta & rtlpriv->cfg->maps[RTL_IMR_TBDOK]) { 959 if (inta & rtlpriv->cfg->maps[RTL_IMR_TBDOK]) {
@@ -874,8 +976,8 @@ static irqreturn_t _rtl_pci_interrupt(int irq, void *dev_id)
874 tasklet_schedule(&rtlpriv->works.irq_prepare_bcn_tasklet); 976 tasklet_schedule(&rtlpriv->works.irq_prepare_bcn_tasklet);
875 } 977 }
876 978
877 /*<3> Tx related */ 979 /*<2> Tx related */
878 if (unlikely(inta & rtlpriv->cfg->maps[RTL_IMR_TXFOVW])) 980 if (unlikely(intb & rtlpriv->cfg->maps[RTL_IMR_TXFOVW]))
879 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING, "IMR_TXFOVW!\n"); 981 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING, "IMR_TXFOVW!\n");
880 982
881 if (inta & rtlpriv->cfg->maps[RTL_IMR_MGNTDOK]) { 983 if (inta & rtlpriv->cfg->maps[RTL_IMR_MGNTDOK]) {
@@ -932,7 +1034,7 @@ static irqreturn_t _rtl_pci_interrupt(int irq, void *dev_id)
932 } 1034 }
933 } 1035 }
934 1036
935 /*<2> Rx related */ 1037 /*<3> Rx related */
936 if (inta & rtlpriv->cfg->maps[RTL_IMR_ROK]) { 1038 if (inta & rtlpriv->cfg->maps[RTL_IMR_ROK]) {
937 RT_TRACE(rtlpriv, COMP_INTR, DBG_TRACE, "Rx ok interrupt!\n"); 1039 RT_TRACE(rtlpriv, COMP_INTR, DBG_TRACE, "Rx ok interrupt!\n");
938 _rtl_pci_rx_interrupt(hw); 1040 _rtl_pci_rx_interrupt(hw);
@@ -944,12 +1046,12 @@ static irqreturn_t _rtl_pci_interrupt(int irq, void *dev_id)
944 _rtl_pci_rx_interrupt(hw); 1046 _rtl_pci_rx_interrupt(hw);
945 } 1047 }
946 1048
947 if (unlikely(inta & rtlpriv->cfg->maps[RTL_IMR_RXFOVW])) { 1049 if (unlikely(intb & rtlpriv->cfg->maps[RTL_IMR_RXFOVW])) {
948 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING, "rx overflow !\n"); 1050 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING, "rx overflow !\n");
949 _rtl_pci_rx_interrupt(hw); 1051 _rtl_pci_rx_interrupt(hw);
950 } 1052 }
951 1053
952 /*fw related*/ 1054 /*<4> fw related*/
953 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8723AE) { 1055 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8723AE) {
954 if (inta & rtlpriv->cfg->maps[RTL_IMR_C2HCMD]) { 1056 if (inta & rtlpriv->cfg->maps[RTL_IMR_C2HCMD]) {
955 RT_TRACE(rtlpriv, COMP_INTR, DBG_TRACE, 1057 RT_TRACE(rtlpriv, COMP_INTR, DBG_TRACE,
@@ -959,10 +1061,26 @@ static irqreturn_t _rtl_pci_interrupt(int irq, void *dev_id)
959 } 1061 }
960 } 1062 }
961 1063
1064 /*<5> hsisr related*/
1065 /* Only 8188EE & 8723BE Supported.
1066 * If Other ICs Come in, System will corrupt,
1067 * because maps[RTL_IMR_HSISR_IND] & maps[MAC_HSISR]
1068 * are not initialized
1069 */
1070 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8188EE ||
1071 rtlhal->hw_type == HARDWARE_TYPE_RTL8723BE) {
1072 if (unlikely(inta & rtlpriv->cfg->maps[RTL_IMR_HSISR_IND])) {
1073 RT_TRACE(rtlpriv, COMP_INTR, DBG_TRACE,
1074 "hsisr interrupt!\n");
1075 _rtl_pci_hs_interrupt(hw);
1076 }
1077 }
1078
962 if (rtlpriv->rtlhal.earlymode_enable) 1079 if (rtlpriv->rtlhal.earlymode_enable)
963 tasklet_schedule(&rtlpriv->works.irq_tasklet); 1080 tasklet_schedule(&rtlpriv->works.irq_tasklet);
964 1081
965done: 1082done:
1083 rtlpriv->cfg->ops->enable_interrupt(hw);
966 spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock, flags); 1084 spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock, flags);
967 return ret; 1085 return ret;
968} 1086}
@@ -990,13 +1108,8 @@ static void _rtl_pci_prepare_bcn_tasklet(struct ieee80211_hw *hw)
990 memset(&tcb_desc, 0, sizeof(struct rtl_tcb_desc)); 1108 memset(&tcb_desc, 0, sizeof(struct rtl_tcb_desc));
991 ring = &rtlpci->tx_ring[BEACON_QUEUE]; 1109 ring = &rtlpci->tx_ring[BEACON_QUEUE];
992 pskb = __skb_dequeue(&ring->queue); 1110 pskb = __skb_dequeue(&ring->queue);
993 if (pskb) { 1111 if (pskb)
994 struct rtl_tx_desc *entry = &ring->desc[ring->idx];
995 pci_unmap_single(rtlpci->pdev, rtlpriv->cfg->ops->get_desc(
996 (u8 *) entry, true, HW_DESC_TXBUFF_ADDR),
997 pskb->len, PCI_DMA_TODEVICE);
998 kfree_skb(pskb); 1112 kfree_skb(pskb);
999 }
1000 1113
1001 /*NB: the beacon data buffer must be 32-bit aligned. */ 1114 /*NB: the beacon data buffer must be 32-bit aligned. */
1002 pskb = ieee80211_beacon_get(hw, mac->vif); 1115 pskb = ieee80211_beacon_get(hw, mac->vif);
@@ -1005,7 +1118,10 @@ static void _rtl_pci_prepare_bcn_tasklet(struct ieee80211_hw *hw)
1005 hdr = rtl_get_hdr(pskb); 1118 hdr = rtl_get_hdr(pskb);
1006 info = IEEE80211_SKB_CB(pskb); 1119 info = IEEE80211_SKB_CB(pskb);
1007 pdesc = &ring->desc[0]; 1120 pdesc = &ring->desc[0];
1008 rtlpriv->cfg->ops->fill_tx_desc(hw, hdr, (u8 *) pdesc, 1121 if (rtlpriv->use_new_trx_flow)
1122 pbuffer_desc = &ring->buffer_desc[0];
1123
1124 rtlpriv->cfg->ops->fill_tx_desc(hw, hdr, (u8 *)pdesc,
1009 (u8 *)pbuffer_desc, info, NULL, pskb, 1125 (u8 *)pbuffer_desc, info, NULL, pskb,
1010 BEACON_QUEUE, &tcb_desc); 1126 BEACON_QUEUE, &tcb_desc);
1011 1127
@@ -1020,10 +1136,18 @@ static void _rtl_pci_prepare_bcn_tasklet(struct ieee80211_hw *hw)
1020static void _rtl_pci_init_trx_var(struct ieee80211_hw *hw) 1136static void _rtl_pci_init_trx_var(struct ieee80211_hw *hw)
1021{ 1137{
1022 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1138 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1139 struct rtl_priv *rtlpriv = rtl_priv(hw);
1140 struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
1023 u8 i; 1141 u8 i;
1142 u16 desc_num;
1143
1144 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192EE)
1145 desc_num = TX_DESC_NUM_92E;
1146 else
1147 desc_num = RT_TXDESC_NUM;
1024 1148
1025 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++) 1149 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++)
1026 rtlpci->txringcount[i] = RT_TXDESC_NUM; 1150 rtlpci->txringcount[i] = desc_num;
1027 1151
1028 /* 1152 /*
1029 *we just alloc 2 desc for beacon queue, 1153 *we just alloc 2 desc for beacon queue,
@@ -1031,12 +1155,12 @@ static void _rtl_pci_init_trx_var(struct ieee80211_hw *hw)
1031 */ 1155 */
1032 rtlpci->txringcount[BEACON_QUEUE] = 2; 1156 rtlpci->txringcount[BEACON_QUEUE] = 2;
1033 1157
1034 /* 1158 /*BE queue need more descriptor for performance
1035 *BE queue need more descriptor for performance
1036 *consideration or, No more tx desc will happen, 1159 *consideration or, No more tx desc will happen,
1037 *and may cause mac80211 mem leakage. 1160 *and may cause mac80211 mem leakage.
1038 */ 1161 */
1039 rtlpci->txringcount[BE_QUEUE] = RT_TXDESC_NUM_BE_QUEUE; 1162 if (!rtl_priv(hw)->use_new_trx_flow)
1163 rtlpci->txringcount[BE_QUEUE] = RT_TXDESC_NUM_BE_QUEUE;
1040 1164
1041 rtlpci->rxbuffersize = 9100; /*2048/1024; */ 1165 rtlpci->rxbuffersize = 9100; /*2048/1024; */
1042 rtlpci->rxringcount = RTL_PCI_MAX_RX_COUNT; /*64; */ 1166 rtlpci->rxringcount = RTL_PCI_MAX_RX_COUNT; /*64; */
@@ -1087,113 +1211,124 @@ static int _rtl_pci_init_tx_ring(struct ieee80211_hw *hw,
1087{ 1211{
1088 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1212 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1089 struct rtl_priv *rtlpriv = rtl_priv(hw); 1213 struct rtl_priv *rtlpriv = rtl_priv(hw);
1090 struct rtl_tx_desc *ring; 1214 struct rtl_tx_buffer_desc *buffer_desc;
1091 dma_addr_t dma; 1215 struct rtl_tx_desc *desc;
1216 dma_addr_t buffer_desc_dma, desc_dma;
1092 u32 nextdescaddress; 1217 u32 nextdescaddress;
1093 int i; 1218 int i;
1094 1219
1095 ring = pci_zalloc_consistent(rtlpci->pdev, sizeof(*ring) * entries, 1220 /* alloc tx buffer desc for new trx flow*/
1096 &dma); 1221 if (rtlpriv->use_new_trx_flow) {
1097 if (!ring || (unsigned long)ring & 0xFF) { 1222 buffer_desc =
1223 pci_zalloc_consistent(rtlpci->pdev,
1224 sizeof(*buffer_desc) * entries,
1225 &buffer_desc_dma);
1226
1227 if (!buffer_desc || (unsigned long)buffer_desc & 0xFF) {
1228 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
1229 "Cannot allocate TX ring (prio = %d)\n",
1230 prio);
1231 return -ENOMEM;
1232 }
1233
1234 rtlpci->tx_ring[prio].buffer_desc = buffer_desc;
1235 rtlpci->tx_ring[prio].buffer_desc_dma = buffer_desc_dma;
1236
1237 rtlpci->tx_ring[prio].cur_tx_rp = 0;
1238 rtlpci->tx_ring[prio].cur_tx_wp = 0;
1239 rtlpci->tx_ring[prio].avl_desc = entries;
1240 }
1241
1242 /* alloc dma for this ring */
1243 desc = pci_zalloc_consistent(rtlpci->pdev,
1244 sizeof(*desc) * entries, &desc_dma);
1245
1246 if (!desc || (unsigned long)desc & 0xFF) {
1098 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, 1247 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
1099 "Cannot allocate TX ring (prio = %d)\n", prio); 1248 "Cannot allocate TX ring (prio = %d)\n", prio);
1100 return -ENOMEM; 1249 return -ENOMEM;
1101 } 1250 }
1102 1251
1103 rtlpci->tx_ring[prio].desc = ring; 1252 rtlpci->tx_ring[prio].desc = desc;
1104 rtlpci->tx_ring[prio].dma = dma; 1253 rtlpci->tx_ring[prio].dma = desc_dma;
1254
1105 rtlpci->tx_ring[prio].idx = 0; 1255 rtlpci->tx_ring[prio].idx = 0;
1106 rtlpci->tx_ring[prio].entries = entries; 1256 rtlpci->tx_ring[prio].entries = entries;
1107 skb_queue_head_init(&rtlpci->tx_ring[prio].queue); 1257 skb_queue_head_init(&rtlpci->tx_ring[prio].queue);
1108 1258
1109 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "queue:%d, ring_addr:%p\n", 1259 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "queue:%d, ring_addr:%p\n",
1110 prio, ring); 1260 prio, desc);
1111 1261
1112 for (i = 0; i < entries; i++) { 1262 /* init every desc in this ring */
1113 nextdescaddress = (u32) dma + 1263 if (!rtlpriv->use_new_trx_flow) {
1114 ((i + 1) % entries) * 1264 for (i = 0; i < entries; i++) {
1115 sizeof(*ring); 1265 nextdescaddress = (u32)desc_dma +
1116 1266 ((i + 1) % entries) *
1117 rtlpriv->cfg->ops->set_desc(hw, (u8 *)&(ring[i]), 1267 sizeof(*desc);
1118 true, HW_DESC_TX_NEXTDESC_ADDR, 1268
1119 (u8 *)&nextdescaddress); 1269 rtlpriv->cfg->ops->set_desc(hw, (u8 *)&desc[i],
1270 true,
1271 HW_DESC_TX_NEXTDESC_ADDR,
1272 (u8 *)&nextdescaddress);
1273 }
1120 } 1274 }
1121
1122 return 0; 1275 return 0;
1123} 1276}
1124 1277
1125static int _rtl_pci_init_rx_ring(struct ieee80211_hw *hw) 1278static int _rtl_pci_init_rx_ring(struct ieee80211_hw *hw, int rxring_idx)
1126{ 1279{
1127 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1280 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1128 struct rtl_priv *rtlpriv = rtl_priv(hw); 1281 struct rtl_priv *rtlpriv = rtl_priv(hw);
1129 struct rtl_rx_desc *entry = NULL; 1282 int i;
1130 int i, rx_queue_idx;
1131 u8 tmp_one = 1;
1132 1283
1133 /* 1284 if (rtlpriv->use_new_trx_flow) {
1134 *rx_queue_idx 0:RX_MPDU_QUEUE 1285 struct rtl_rx_buffer_desc *entry = NULL;
1135 *rx_queue_idx 1:RX_CMD_QUEUE 1286 /* alloc dma for this ring */
1136 */ 1287 rtlpci->rx_ring[rxring_idx].buffer_desc =
1137 for (rx_queue_idx = 0; rx_queue_idx < RTL_PCI_MAX_RX_QUEUE; 1288 pci_zalloc_consistent(rtlpci->pdev,
1138 rx_queue_idx++) { 1289 sizeof(*rtlpci->rx_ring[rxring_idx].
1139 rtlpci->rx_ring[rx_queue_idx].desc = 1290 buffer_desc) *
1140 pci_zalloc_consistent(rtlpci->pdev, 1291 rtlpci->rxringcount,
1141 sizeof(*rtlpci->rx_ring[rx_queue_idx].desc) * rtlpci->rxringcount, 1292 &rtlpci->rx_ring[rxring_idx].dma);
1142 &rtlpci->rx_ring[rx_queue_idx].dma); 1293 if (!rtlpci->rx_ring[rxring_idx].buffer_desc ||
1143 1294 (ulong)rtlpci->rx_ring[rxring_idx].buffer_desc & 0xFF) {
1144 if (!rtlpci->rx_ring[rx_queue_idx].desc ||
1145 (unsigned long)rtlpci->rx_ring[rx_queue_idx].desc & 0xFF) {
1146 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, 1295 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
1147 "Cannot allocate RX ring\n"); 1296 "Cannot allocate RX ring\n");
1148 return -ENOMEM; 1297 return -ENOMEM;
1149 } 1298 }
1150 1299
1151 rtlpci->rx_ring[rx_queue_idx].idx = 0; 1300 /* init every desc in this ring */
1301 rtlpci->rx_ring[rxring_idx].idx = 0;
1302 for (i = 0; i < rtlpci->rxringcount; i++) {
1303 entry = &rtlpci->rx_ring[rxring_idx].buffer_desc[i];
1304 if (!_rtl_pci_init_one_rxdesc(hw, (u8 *)entry,
1305 rxring_idx, i))
1306 return -ENOMEM;
1307 }
1308 } else {
1309 struct rtl_rx_desc *entry = NULL;
1310 u8 tmp_one = 1;
1311 /* alloc dma for this ring */
1312 rtlpci->rx_ring[rxring_idx].desc =
1313 pci_zalloc_consistent(rtlpci->pdev,
1314 sizeof(*rtlpci->rx_ring[rxring_idx].
1315 desc) * rtlpci->rxringcount,
1316 &rtlpci->rx_ring[rxring_idx].dma);
1317 if (!rtlpci->rx_ring[rxring_idx].desc ||
1318 (unsigned long)rtlpci->rx_ring[rxring_idx].desc & 0xFF) {
1319 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
1320 "Cannot allocate RX ring\n");
1321 return -ENOMEM;
1322 }
1152 1323
1153 /* If amsdu_8k is disabled, set buffersize to 4096. This 1324 /* init every desc in this ring */
1154 * change will reduce memory fragmentation. 1325 rtlpci->rx_ring[rxring_idx].idx = 0;
1155 */
1156 if (rtlpci->rxbuffersize > 4096 &&
1157 rtlpriv->rtlhal.disable_amsdu_8k)
1158 rtlpci->rxbuffersize = 4096;
1159 1326
1160 for (i = 0; i < rtlpci->rxringcount; i++) { 1327 for (i = 0; i < rtlpci->rxringcount; i++) {
1161 struct sk_buff *skb = 1328 entry = &rtlpci->rx_ring[rxring_idx].desc[i];
1162 dev_alloc_skb(rtlpci->rxbuffersize); 1329 if (!_rtl_pci_init_one_rxdesc(hw, (u8 *)entry,
1163 u32 bufferaddress; 1330 rxring_idx, i))
1164 if (!skb) 1331 return -ENOMEM;
1165 return 0;
1166 kmemleak_not_leak(skb);
1167 entry = &rtlpci->rx_ring[rx_queue_idx].desc[i];
1168
1169 /*skb->dev = dev; */
1170
1171 rtlpci->rx_ring[rx_queue_idx].rx_buf[i] = skb;
1172
1173 /*
1174 *just set skb->cb to mapping addr
1175 *for pci_unmap_single use
1176 */
1177 *((dma_addr_t *) skb->cb) =
1178 pci_map_single(rtlpci->pdev, skb_tail_pointer(skb),
1179 rtlpci->rxbuffersize,
1180 PCI_DMA_FROMDEVICE);
1181
1182 bufferaddress = (*((dma_addr_t *)skb->cb));
1183 if (pci_dma_mapping_error(rtlpci->pdev, bufferaddress)) {
1184 dev_kfree_skb_any(skb);
1185 return 1;
1186 }
1187 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
1188 HW_DESC_RXBUFF_ADDR,
1189 (u8 *)&bufferaddress);
1190 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
1191 HW_DESC_RXPKT_LEN,
1192 (u8 *)&rtlpci->
1193 rxbuffersize);
1194 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
1195 HW_DESC_RXOWN,
1196 &tmp_one);
1197 } 1332 }
1198 1333
1199 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false, 1334 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
@@ -1209,56 +1344,70 @@ static void _rtl_pci_free_tx_ring(struct ieee80211_hw *hw,
1209 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1344 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1210 struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[prio]; 1345 struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[prio];
1211 1346
1347 /* free every desc in this ring */
1212 while (skb_queue_len(&ring->queue)) { 1348 while (skb_queue_len(&ring->queue)) {
1213 struct rtl_tx_desc *entry = &ring->desc[ring->idx]; 1349 u8 *entry;
1214 struct sk_buff *skb = __skb_dequeue(&ring->queue); 1350 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1215 1351
1352 if (rtlpriv->use_new_trx_flow)
1353 entry = (u8 *)(&ring->buffer_desc[ring->idx]);
1354 else
1355 entry = (u8 *)(&ring->desc[ring->idx]);
1356
1216 pci_unmap_single(rtlpci->pdev, 1357 pci_unmap_single(rtlpci->pdev,
1217 rtlpriv->cfg-> 1358 rtlpriv->cfg->
1218 ops->get_desc((u8 *) entry, true, 1359 ops->get_desc((u8 *)entry, true,
1219 HW_DESC_TXBUFF_ADDR), 1360 HW_DESC_TXBUFF_ADDR),
1220 skb->len, PCI_DMA_TODEVICE); 1361 skb->len, PCI_DMA_TODEVICE);
1221 kfree_skb(skb); 1362 kfree_skb(skb);
1222 ring->idx = (ring->idx + 1) % ring->entries; 1363 ring->idx = (ring->idx + 1) % ring->entries;
1223 } 1364 }
1224 1365
1225 if (ring->desc) { 1366 /* free dma of this ring */
1367 pci_free_consistent(rtlpci->pdev,
1368 sizeof(*ring->desc) * ring->entries,
1369 ring->desc, ring->dma);
1370 ring->desc = NULL;
1371 if (rtlpriv->use_new_trx_flow) {
1226 pci_free_consistent(rtlpci->pdev, 1372 pci_free_consistent(rtlpci->pdev,
1227 sizeof(*ring->desc) * ring->entries, 1373 sizeof(*ring->desc) * ring->entries,
1228 ring->desc, ring->dma); 1374 ring->buffer_desc, ring->buffer_desc_dma);
1229 ring->desc = NULL; 1375 ring->desc = NULL;
1230 } 1376 }
1231} 1377}
1232 1378
1233static void _rtl_pci_free_rx_ring(struct rtl_pci *rtlpci) 1379static void _rtl_pci_free_rx_ring(struct ieee80211_hw *hw, int rxring_idx)
1234{ 1380{
1235 int i, rx_queue_idx; 1381 struct rtl_priv *rtlpriv = rtl_priv(hw);
1382 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1383 int i;
1236 1384
1237 /*rx_queue_idx 0:RX_MPDU_QUEUE */ 1385 /* free every desc in this ring */
1238 /*rx_queue_idx 1:RX_CMD_QUEUE */ 1386 for (i = 0; i < rtlpci->rxringcount; i++) {
1239 for (rx_queue_idx = 0; rx_queue_idx < RTL_PCI_MAX_RX_QUEUE; 1387 struct sk_buff *skb = rtlpci->rx_ring[rxring_idx].rx_buf[i];
1240 rx_queue_idx++) {
1241 for (i = 0; i < rtlpci->rxringcount; i++) {
1242 struct sk_buff *skb =
1243 rtlpci->rx_ring[rx_queue_idx].rx_buf[i];
1244 if (!skb)
1245 continue;
1246
1247 pci_unmap_single(rtlpci->pdev,
1248 *((dma_addr_t *) skb->cb),
1249 rtlpci->rxbuffersize,
1250 PCI_DMA_FROMDEVICE);
1251 kfree_skb(skb);
1252 }
1253 1388
1254 if (rtlpci->rx_ring[rx_queue_idx].desc) { 1389 if (!skb)
1255 pci_free_consistent(rtlpci->pdev, 1390 continue;
1256 sizeof(*rtlpci->rx_ring[rx_queue_idx]. 1391 pci_unmap_single(rtlpci->pdev, *((dma_addr_t *)skb->cb),
1257 desc) * rtlpci->rxringcount, 1392 rtlpci->rxbuffersize, PCI_DMA_FROMDEVICE);
1258 rtlpci->rx_ring[rx_queue_idx].desc, 1393 kfree_skb(skb);
1259 rtlpci->rx_ring[rx_queue_idx].dma); 1394 }
1260 rtlpci->rx_ring[rx_queue_idx].desc = NULL; 1395
1261 } 1396 /* free dma of this ring */
1397 if (rtlpriv->use_new_trx_flow) {
1398 pci_free_consistent(rtlpci->pdev,
1399 sizeof(*rtlpci->rx_ring[rxring_idx].
1400 buffer_desc) * rtlpci->rxringcount,
1401 rtlpci->rx_ring[rxring_idx].buffer_desc,
1402 rtlpci->rx_ring[rxring_idx].dma);
1403 rtlpci->rx_ring[rxring_idx].buffer_desc = NULL;
1404 } else {
1405 pci_free_consistent(rtlpci->pdev,
1406 sizeof(*rtlpci->rx_ring[rxring_idx].desc) *
1407 rtlpci->rxringcount,
1408 rtlpci->rx_ring[rxring_idx].desc,
1409 rtlpci->rx_ring[rxring_idx].dma);
1410 rtlpci->rx_ring[rxring_idx].desc = NULL;
1262 } 1411 }
1263} 1412}
1264 1413
@@ -1266,11 +1415,16 @@ static int _rtl_pci_init_trx_ring(struct ieee80211_hw *hw)
1266{ 1415{
1267 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1416 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1268 int ret; 1417 int ret;
1269 int i; 1418 int i, rxring_idx;
1270 1419
1271 ret = _rtl_pci_init_rx_ring(hw); 1420 /* rxring_idx 0:RX_MPDU_QUEUE
1272 if (ret) 1421 * rxring_idx 1:RX_CMD_QUEUE
1273 return ret; 1422 */
1423 for (rxring_idx = 0; rxring_idx < RTL_PCI_MAX_RX_QUEUE; rxring_idx++) {
1424 ret = _rtl_pci_init_rx_ring(hw, rxring_idx);
1425 if (ret)
1426 return ret;
1427 }
1274 1428
1275 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++) { 1429 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++) {
1276 ret = _rtl_pci_init_tx_ring(hw, i, 1430 ret = _rtl_pci_init_tx_ring(hw, i,
@@ -1282,10 +1436,12 @@ static int _rtl_pci_init_trx_ring(struct ieee80211_hw *hw)
1282 return 0; 1436 return 0;
1283 1437
1284err_free_rings: 1438err_free_rings:
1285 _rtl_pci_free_rx_ring(rtlpci); 1439 for (rxring_idx = 0; rxring_idx < RTL_PCI_MAX_RX_QUEUE; rxring_idx++)
1440 _rtl_pci_free_rx_ring(hw, rxring_idx);
1286 1441
1287 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++) 1442 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++)
1288 if (rtlpci->tx_ring[i].desc) 1443 if (rtlpci->tx_ring[i].desc ||
1444 rtlpci->tx_ring[i].buffer_desc)
1289 _rtl_pci_free_tx_ring(hw, i); 1445 _rtl_pci_free_tx_ring(hw, i);
1290 1446
1291 return 1; 1447 return 1;
@@ -1293,11 +1449,11 @@ err_free_rings:
1293 1449
1294static int _rtl_pci_deinit_trx_ring(struct ieee80211_hw *hw) 1450static int _rtl_pci_deinit_trx_ring(struct ieee80211_hw *hw)
1295{ 1451{
1296 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1452 u32 i, rxring_idx;
1297 u32 i;
1298 1453
1299 /*free rx rings */ 1454 /*free rx rings */
1300 _rtl_pci_free_rx_ring(rtlpci); 1455 for (rxring_idx = 0; rxring_idx < RTL_PCI_MAX_RX_QUEUE; rxring_idx++)
1456 _rtl_pci_free_rx_ring(hw, rxring_idx);
1301 1457
1302 /*free tx rings */ 1458 /*free tx rings */
1303 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++) 1459 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++)
@@ -1310,48 +1466,76 @@ int rtl_pci_reset_trx_ring(struct ieee80211_hw *hw)
1310{ 1466{
1311 struct rtl_priv *rtlpriv = rtl_priv(hw); 1467 struct rtl_priv *rtlpriv = rtl_priv(hw);
1312 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw)); 1468 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1313 int i, rx_queue_idx; 1469 int i, rxring_idx;
1314 unsigned long flags; 1470 unsigned long flags;
1315 u8 tmp_one = 1; 1471 u8 tmp_one = 1;
1316 1472 u32 bufferaddress;
1317 /*rx_queue_idx 0:RX_MPDU_QUEUE */ 1473 /* rxring_idx 0:RX_MPDU_QUEUE */
1318 /*rx_queue_idx 1:RX_CMD_QUEUE */ 1474 /* rxring_idx 1:RX_CMD_QUEUE */
1319 for (rx_queue_idx = 0; rx_queue_idx < RTL_PCI_MAX_RX_QUEUE; 1475 for (rxring_idx = 0; rxring_idx < RTL_PCI_MAX_RX_QUEUE; rxring_idx++) {
1320 rx_queue_idx++) { 1476 /* force the rx_ring[RX_MPDU_QUEUE/
1321 /* 1477 * RX_CMD_QUEUE].idx to the first one
1322 *force the rx_ring[RX_MPDU_QUEUE/ 1478 *new trx flow, do nothing
1323 *RX_CMD_QUEUE].idx to the first one 1479 */
1324 */ 1480 if (!rtlpriv->use_new_trx_flow &&
1325 if (rtlpci->rx_ring[rx_queue_idx].desc) { 1481 rtlpci->rx_ring[rxring_idx].desc) {
1326 struct rtl_rx_desc *entry = NULL; 1482 struct rtl_rx_desc *entry = NULL;
1327 1483
1484 rtlpci->rx_ring[rxring_idx].idx = 0;
1328 for (i = 0; i < rtlpci->rxringcount; i++) { 1485 for (i = 0; i < rtlpci->rxringcount; i++) {
1329 entry = &rtlpci->rx_ring[rx_queue_idx].desc[i]; 1486 entry = &rtlpci->rx_ring[rxring_idx].desc[i];
1330 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, 1487 bufferaddress =
1331 false, 1488 rtlpriv->cfg->ops->get_desc((u8 *)entry,
1332 HW_DESC_RXOWN, 1489 false , HW_DESC_RXBUFF_ADDR);
1333 &tmp_one); 1490 memset((u8 *)entry , 0 ,
1491 sizeof(*rtlpci->rx_ring
1492 [rxring_idx].desc));/*clear one entry*/
1493 if (rtlpriv->use_new_trx_flow) {
1494 rtlpriv->cfg->ops->set_desc(hw,
1495 (u8 *)entry, false,
1496 HW_DESC_RX_PREPARE,
1497 (u8 *)&bufferaddress);
1498 } else {
1499 rtlpriv->cfg->ops->set_desc(hw,
1500 (u8 *)entry, false,
1501 HW_DESC_RXBUFF_ADDR,
1502 (u8 *)&bufferaddress);
1503 rtlpriv->cfg->ops->set_desc(hw,
1504 (u8 *)entry, false,
1505 HW_DESC_RXPKT_LEN,
1506 (u8 *)&rtlpci->rxbuffersize);
1507 rtlpriv->cfg->ops->set_desc(hw,
1508 (u8 *)entry, false,
1509 HW_DESC_RXOWN,
1510 (u8 *)&tmp_one);
1511 }
1334 } 1512 }
1335 rtlpci->rx_ring[rx_queue_idx].idx = 0; 1513 rtlpriv->cfg->ops->set_desc(hw, (u8 *)entry, false,
1514 HW_DESC_RXERO, (u8 *)&tmp_one);
1336 } 1515 }
1516 rtlpci->rx_ring[rxring_idx].idx = 0;
1337 } 1517 }
1338 1518
1339 /* 1519 /*
1340 *after reset, release previous pending packet, 1520 *after reset, release previous pending packet,
1341 *and force the tx idx to the first one 1521 *and force the tx idx to the first one
1342 */ 1522 */
1523 spin_lock_irqsave(&rtlpriv->locks.irq_th_lock, flags);
1343 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++) { 1524 for (i = 0; i < RTL_PCI_MAX_TX_QUEUE_COUNT; i++) {
1344 if (rtlpci->tx_ring[i].desc) { 1525 if (rtlpci->tx_ring[i].desc ||
1526 rtlpci->tx_ring[i].buffer_desc) {
1345 struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[i]; 1527 struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[i];
1346 1528
1347 while (skb_queue_len(&ring->queue)) { 1529 while (skb_queue_len(&ring->queue)) {
1348 struct rtl_tx_desc *entry; 1530 u8 *entry;
1349 struct sk_buff *skb; 1531 struct sk_buff *skb =
1532 __skb_dequeue(&ring->queue);
1533 if (rtlpriv->use_new_trx_flow)
1534 entry = (u8 *)(&ring->buffer_desc
1535 [ring->idx]);
1536 else
1537 entry = (u8 *)(&ring->desc[ring->idx]);
1350 1538
1351 spin_lock_irqsave(&rtlpriv->locks.irq_th_lock,
1352 flags);
1353 entry = &ring->desc[ring->idx];
1354 skb = __skb_dequeue(&ring->queue);
1355 pci_unmap_single(rtlpci->pdev, 1539 pci_unmap_single(rtlpci->pdev,
1356 rtlpriv->cfg->ops-> 1540 rtlpriv->cfg->ops->
1357 get_desc((u8 *) 1541 get_desc((u8 *)
@@ -1360,13 +1544,13 @@ int rtl_pci_reset_trx_ring(struct ieee80211_hw *hw)
1360 HW_DESC_TXBUFF_ADDR), 1544 HW_DESC_TXBUFF_ADDR),
1361 skb->len, PCI_DMA_TODEVICE); 1545 skb->len, PCI_DMA_TODEVICE);
1362 ring->idx = (ring->idx + 1) % ring->entries; 1546 ring->idx = (ring->idx + 1) % ring->entries;
1363 spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock,
1364 flags);
1365 kfree_skb(skb); 1547 kfree_skb(skb);
1548 ring->idx = (ring->idx + 1) % ring->entries;
1366 } 1549 }
1367 ring->idx = 0; 1550 ring->idx = 0;
1368 } 1551 }
1369 } 1552 }
1553 spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock, flags);
1370 1554
1371 return 0; 1555 return 0;
1372} 1556}
@@ -1421,7 +1605,7 @@ static int rtl_pci_tx(struct ieee80211_hw *hw,
1421 struct rtl8192_tx_ring *ring; 1605 struct rtl8192_tx_ring *ring;
1422 struct rtl_tx_desc *pdesc; 1606 struct rtl_tx_desc *pdesc;
1423 struct rtl_tx_buffer_desc *ptx_bd_desc = NULL; 1607 struct rtl_tx_buffer_desc *ptx_bd_desc = NULL;
1424 u8 idx; 1608 u16 idx;
1425 u8 hw_queue = _rtl_mac_to_hwqueue(hw, skb); 1609 u8 hw_queue = _rtl_mac_to_hwqueue(hw, skb);
1426 unsigned long flags; 1610 unsigned long flags;
1427 struct ieee80211_hdr *hdr = rtl_get_hdr(skb); 1611 struct ieee80211_hdr *hdr = rtl_get_hdr(skb);
@@ -1454,11 +1638,15 @@ static int rtl_pci_tx(struct ieee80211_hw *hw,
1454 1638
1455 spin_lock_irqsave(&rtlpriv->locks.irq_th_lock, flags); 1639 spin_lock_irqsave(&rtlpriv->locks.irq_th_lock, flags);
1456 ring = &rtlpci->tx_ring[hw_queue]; 1640 ring = &rtlpci->tx_ring[hw_queue];
1457 if (hw_queue != BEACON_QUEUE) 1641 if (hw_queue != BEACON_QUEUE) {
1458 idx = (ring->idx + skb_queue_len(&ring->queue)) % 1642 if (rtlpriv->use_new_trx_flow)
1459 ring->entries; 1643 idx = ring->cur_tx_wp;
1460 else 1644 else
1645 idx = (ring->idx + skb_queue_len(&ring->queue)) %
1646 ring->entries;
1647 } else {
1461 idx = 0; 1648 idx = 0;
1649 }
1462 1650
1463 pdesc = &ring->desc[idx]; 1651 pdesc = &ring->desc[idx];
1464 if (rtlpriv->use_new_trx_flow) { 1652 if (rtlpriv->use_new_trx_flow) {
@@ -1525,7 +1713,7 @@ static int rtl_pci_tx(struct ieee80211_hw *hw,
1525 return 0; 1713 return 0;
1526} 1714}
1527 1715
1528static void rtl_pci_flush(struct ieee80211_hw *hw, bool drop) 1716static void rtl_pci_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
1529{ 1717{
1530 struct rtl_priv *rtlpriv = rtl_priv(hw); 1718 struct rtl_priv *rtlpriv = rtl_priv(hw);
1531 struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw); 1719 struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw);
@@ -1540,6 +1728,11 @@ static void rtl_pci_flush(struct ieee80211_hw *hw, bool drop)
1540 1728
1541 for (queue_id = RTL_PCI_MAX_TX_QUEUE_COUNT - 1; queue_id >= 0;) { 1729 for (queue_id = RTL_PCI_MAX_TX_QUEUE_COUNT - 1; queue_id >= 0;) {
1542 u32 queue_len; 1730 u32 queue_len;
1731
1732 if (((queues >> queue_id) & 0x1) == 0) {
1733 queue_id--;
1734 continue;
1735 }
1543 ring = &pcipriv->dev.tx_ring[queue_id]; 1736 ring = &pcipriv->dev.tx_ring[queue_id];
1544 queue_len = skb_queue_len(&ring->queue); 1737 queue_len = skb_queue_len(&ring->queue);
1545 if (queue_len == 0 || queue_id == BEACON_QUEUE || 1738 if (queue_len == 0 || queue_id == BEACON_QUEUE ||
@@ -1603,6 +1796,10 @@ static int rtl_pci_start(struct ieee80211_hw *hw)
1603 rtl_pci_reset_trx_ring(hw); 1796 rtl_pci_reset_trx_ring(hw);
1604 1797
1605 rtlpci->driver_is_goingto_unload = false; 1798 rtlpci->driver_is_goingto_unload = false;
1799 if (rtlpriv->cfg->ops->get_btc_status()) {
1800 rtlpriv->btcoexist.btc_ops->btc_init_variables(rtlpriv);
1801 rtlpriv->btcoexist.btc_ops->btc_init_hal_vars(rtlpriv);
1802 }
1606 err = rtlpriv->cfg->ops->hw_init(hw); 1803 err = rtlpriv->cfg->ops->hw_init(hw);
1607 if (err) { 1804 if (err) {
1608 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 1805 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
@@ -1622,7 +1819,7 @@ static int rtl_pci_start(struct ieee80211_hw *hw)
1622 1819
1623 rtlpci->up_first_time = false; 1820 rtlpci->up_first_time = false;
1624 1821
1625 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "OK\n"); 1822 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "rtl_pci_start OK\n");
1626 return 0; 1823 return 0;
1627} 1824}
1628 1825
@@ -1635,6 +1832,9 @@ static void rtl_pci_stop(struct ieee80211_hw *hw)
1635 unsigned long flags; 1832 unsigned long flags;
1636 u8 RFInProgressTimeOut = 0; 1833 u8 RFInProgressTimeOut = 0;
1637 1834
1835 if (rtlpriv->cfg->ops->get_btc_status())
1836 rtlpriv->btcoexist.btc_ops->btc_halt_notify();
1837
1638 /* 1838 /*
1639 *should be before disable interrupt&adapter 1839 *should be before disable interrupt&adapter
1640 *and will do it immediately. 1840 *and will do it immediately.
@@ -1753,6 +1953,22 @@ static bool _rtl_pci_find_adapter(struct pci_dev *pdev,
1753 rtlhal->hw_type = HARDWARE_TYPE_RTL8188EE; 1953 rtlhal->hw_type = HARDWARE_TYPE_RTL8188EE;
1754 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, 1954 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1755 "Find adapter, Hardware type is 8188EE\n"); 1955 "Find adapter, Hardware type is 8188EE\n");
1956 } else if (deviceid == RTL_PCI_8723BE_DID) {
1957 rtlhal->hw_type = HARDWARE_TYPE_RTL8723BE;
1958 RT_TRACE(rtlpriv, COMP_INIT , DBG_LOUD,
1959 "Find adapter, Hardware type is 8723BE\n");
1960 } else if (deviceid == RTL_PCI_8192EE_DID) {
1961 rtlhal->hw_type = HARDWARE_TYPE_RTL8192EE;
1962 RT_TRACE(rtlpriv, COMP_INIT , DBG_LOUD,
1963 "Find adapter, Hardware type is 8192EE\n");
1964 } else if (deviceid == RTL_PCI_8821AE_DID) {
1965 rtlhal->hw_type = HARDWARE_TYPE_RTL8821AE;
1966 RT_TRACE(rtlpriv, COMP_INIT , DBG_LOUD,
1967 "Find adapter, Hardware type is 8821AE\n");
1968 } else if (deviceid == RTL_PCI_8812AE_DID) {
1969 rtlhal->hw_type = HARDWARE_TYPE_RTL8812AE;
1970 RT_TRACE(rtlpriv, COMP_INIT , DBG_LOUD,
1971 "Find adapter, Hardware type is 8812AE\n");
1756 } else { 1972 } else {
1757 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING, 1973 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
1758 "Err: Unknown device - vid/did=%x/%x\n", 1974 "Err: Unknown device - vid/did=%x/%x\n",
@@ -1779,11 +1995,20 @@ static bool _rtl_pci_find_adapter(struct pci_dev *pdev,
1779 rtlhal->interfaceindex = 0; 1995 rtlhal->interfaceindex = 0;
1780 } 1996 }
1781 } 1997 }
1998
1999 /* 92ee use new trx flow */
2000 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8192EE)
2001 rtlpriv->use_new_trx_flow = true;
2002 else
2003 rtlpriv->use_new_trx_flow = false;
2004
1782 /*find bus info */ 2005 /*find bus info */
1783 pcipriv->ndis_adapter.busnumber = pdev->bus->number; 2006 pcipriv->ndis_adapter.busnumber = pdev->bus->number;
1784 pcipriv->ndis_adapter.devnumber = PCI_SLOT(pdev->devfn); 2007 pcipriv->ndis_adapter.devnumber = PCI_SLOT(pdev->devfn);
1785 pcipriv->ndis_adapter.funcnumber = PCI_FUNC(pdev->devfn); 2008 pcipriv->ndis_adapter.funcnumber = PCI_FUNC(pdev->devfn);
1786 2009
2010 /*find bridge info */
2011 pcipriv->ndis_adapter.pcibridge_vendor = PCI_BRIDGE_VENDOR_UNKNOWN;
1787 /* some ARM have no bridge_pdev and will crash here 2012 /* some ARM have no bridge_pdev and will crash here
1788 * so we should check if bridge_pdev is NULL 2013 * so we should check if bridge_pdev is NULL
1789 */ 2014 */
@@ -1951,6 +2176,11 @@ int rtl_pci_probe(struct pci_dev *pdev,
1951 pcipriv = (void *)rtlpriv->priv; 2176 pcipriv = (void *)rtlpriv->priv;
1952 pcipriv->dev.pdev = pdev; 2177 pcipriv->dev.pdev = pdev;
1953 init_completion(&rtlpriv->firmware_loading_complete); 2178 init_completion(&rtlpriv->firmware_loading_complete);
2179 /*proximity init here*/
2180 rtlpriv->proximity.proxim_on = false;
2181
2182 pcipriv = (void *)rtlpriv->priv;
2183 pcipriv->dev.pdev = pdev;
1954 2184
1955 /* init cfg & intf_ops */ 2185 /* init cfg & intf_ops */
1956 rtlpriv->rtlhal.interface = INTF_PCI; 2186 rtlpriv->rtlhal.interface = INTF_PCI;
@@ -2013,9 +2243,6 @@ int rtl_pci_probe(struct pci_dev *pdev,
2013 /*like read eeprom and so on */ 2243 /*like read eeprom and so on */
2014 rtlpriv->cfg->ops->read_eeprom_info(hw); 2244 rtlpriv->cfg->ops->read_eeprom_info(hw);
2015 2245
2016 /*aspm */
2017 rtl_pci_init_aspm(hw);
2018
2019 /* Init mac80211 sw */ 2246 /* Init mac80211 sw */
2020 err = rtl_init_core(hw); 2247 err = rtl_init_core(hw);
2021 if (err) { 2248 if (err) {
@@ -2036,9 +2263,20 @@ int rtl_pci_probe(struct pci_dev *pdev,
2036 err = -ENODEV; 2263 err = -ENODEV;
2037 goto fail3; 2264 goto fail3;
2038 } 2265 }
2039
2040 rtlpriv->cfg->ops->init_sw_leds(hw); 2266 rtlpriv->cfg->ops->init_sw_leds(hw);
2041 2267
2268 /*aspm */
2269 rtl_pci_init_aspm(hw);
2270
2271 err = ieee80211_register_hw(hw);
2272 if (err) {
2273 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
2274 "Can't register mac80211 hw.\n");
2275 err = -ENODEV;
2276 goto fail3;
2277 }
2278 rtlpriv->mac80211.mac80211_registered = 1;
2279
2042 err = sysfs_create_group(&pdev->dev.kobj, &rtl_attribute_group); 2280 err = sysfs_create_group(&pdev->dev.kobj, &rtl_attribute_group);
2043 if (err) { 2281 if (err) {
2044 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, 2282 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
@@ -2046,6 +2284,9 @@ int rtl_pci_probe(struct pci_dev *pdev,
2046 goto fail3; 2284 goto fail3;
2047 } 2285 }
2048 2286
2287 /*init rfkill */
2288 rtl_init_rfkill(hw); /* Init PCI sw */
2289
2049 rtlpci = rtl_pcidev(pcipriv); 2290 rtlpci = rtl_pcidev(pcipriv);
2050 err = rtl_pci_intr_mode_decide(hw); 2291 err = rtl_pci_intr_mode_decide(hw);
2051 if (err) { 2292 if (err) {
@@ -2056,9 +2297,11 @@ int rtl_pci_probe(struct pci_dev *pdev,
2056 } 2297 }
2057 rtlpci->irq_alloc = 1; 2298 rtlpci->irq_alloc = 1;
2058 2299
2300 set_bit(RTL_STATUS_INTERFACE_START, &rtlpriv->status);
2059 return 0; 2301 return 0;
2060 2302
2061fail3: 2303fail3:
2304 pci_set_drvdata(pdev, NULL);
2062 rtl_deinit_core(hw); 2305 rtl_deinit_core(hw);
2063 2306
2064 if (rtlpriv->io.pci_mem_start != 0) 2307 if (rtlpriv->io.pci_mem_start != 0)
@@ -2128,6 +2371,8 @@ void rtl_pci_disconnect(struct pci_dev *pdev)
2128 2371
2129 rtl_pci_disable_aspm(hw); 2372 rtl_pci_disable_aspm(hw);
2130 2373
2374 pci_set_drvdata(pdev, NULL);
2375
2131 ieee80211_free_hw(hw); 2376 ieee80211_free_hw(hw);
2132} 2377}
2133EXPORT_SYMBOL(rtl_pci_disconnect); 2378EXPORT_SYMBOL(rtl_pci_disconnect);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-24 08:16:54 -0500