1b44febedSLarry Finger // SPDX-License-Identifier: GPL-2.0 2b44febedSLarry Finger /* Copyright(c) 2009-2012 Realtek Corporation.*/ 3f1d2b4d3SLarry Finger 4f1d2b4d3SLarry Finger #include "../wifi.h" 5f1d2b4d3SLarry Finger #include "../usb.h" 6f1d2b4d3SLarry Finger #include "../ps.h" 7f1d2b4d3SLarry Finger #include "../base.h" 8f1d2b4d3SLarry Finger #include "reg.h" 9f1d2b4d3SLarry Finger #include "def.h" 10f1d2b4d3SLarry Finger #include "phy.h" 11f1d2b4d3SLarry Finger #include "rf.h" 12f1d2b4d3SLarry Finger #include "dm.h" 13f1d2b4d3SLarry Finger #include "mac.h" 14f1d2b4d3SLarry Finger #include "trx.h" 15f1d2b4d3SLarry Finger #include "../rtl8192c/fw_common.h" 16f1d2b4d3SLarry Finger 17ff970453SLarry Finger static int configvertoutep(struct ieee80211_hw *hw) 18f1d2b4d3SLarry Finger { 19f1d2b4d3SLarry Finger u8 ep_cfg, txqsele; 20f1d2b4d3SLarry Finger u8 ep_nums = 0; 21f1d2b4d3SLarry Finger 22f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 23f1d2b4d3SLarry Finger struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw); 24f1d2b4d3SLarry Finger struct rtl_usb *rtlusb = rtl_usbdev(usb_priv); 25f1d2b4d3SLarry Finger 26f1d2b4d3SLarry Finger rtlusb->out_queue_sel = 0; 27f1d2b4d3SLarry Finger ep_cfg = rtl_read_byte(rtlpriv, REG_TEST_SIE_OPTIONAL); 28f1d2b4d3SLarry Finger ep_cfg = (ep_cfg & USB_TEST_EP_MASK) >> USB_TEST_EP_SHIFT; 29f1d2b4d3SLarry Finger switch (ep_cfg) { 30f1d2b4d3SLarry Finger case 0: /* 2 bulk OUT, 1 bulk IN */ 31f1d2b4d3SLarry Finger case 3: 32f1d2b4d3SLarry Finger rtlusb->out_queue_sel = TX_SELE_HQ | TX_SELE_LQ; 33f1d2b4d3SLarry Finger ep_nums = 2; 34f1d2b4d3SLarry Finger break; 35f1d2b4d3SLarry Finger case 1: /* 1 bulk IN/OUT => map all endpoint to Low queue */ 36f1d2b4d3SLarry Finger case 2: /* 1 bulk IN, 1 bulk OUT => map all endpoint to High queue */ 37f1d2b4d3SLarry Finger txqsele = rtl_read_byte(rtlpriv, REG_TEST_USB_TXQS); 38f1d2b4d3SLarry Finger if (txqsele & 0x0F) /* /map all endpoint to High queue */ 39f1d2b4d3SLarry Finger rtlusb->out_queue_sel = TX_SELE_HQ; 40f1d2b4d3SLarry Finger else if (txqsele&0xF0) /* map all endpoint to Low queue */ 41f1d2b4d3SLarry Finger rtlusb->out_queue_sel = TX_SELE_LQ; 42f1d2b4d3SLarry Finger ep_nums = 1; 43f1d2b4d3SLarry Finger break; 44f1d2b4d3SLarry Finger default: 45f1d2b4d3SLarry Finger break; 46f1d2b4d3SLarry Finger } 47f1d2b4d3SLarry Finger return (rtlusb->out_ep_nums == ep_nums) ? 0 : -EINVAL; 48f1d2b4d3SLarry Finger } 49f1d2b4d3SLarry Finger 50ff970453SLarry Finger static int configvernoutep(struct ieee80211_hw *hw) 51f1d2b4d3SLarry Finger { 52f1d2b4d3SLarry Finger u8 ep_cfg; 53f1d2b4d3SLarry Finger u8 ep_nums = 0; 54f1d2b4d3SLarry Finger 55f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 56f1d2b4d3SLarry Finger struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw); 57f1d2b4d3SLarry Finger struct rtl_usb *rtlusb = rtl_usbdev(usb_priv); 58f1d2b4d3SLarry Finger 59f1d2b4d3SLarry Finger rtlusb->out_queue_sel = 0; 60f1d2b4d3SLarry Finger /* Normal and High queue */ 61f1d2b4d3SLarry Finger ep_cfg = rtl_read_byte(rtlpriv, (REG_NORMAL_SIE_EP + 1)); 62f1d2b4d3SLarry Finger if (ep_cfg & USB_NORMAL_SIE_EP_MASK) { 63f1d2b4d3SLarry Finger rtlusb->out_queue_sel |= TX_SELE_HQ; 64f1d2b4d3SLarry Finger ep_nums++; 65f1d2b4d3SLarry Finger } 66f1d2b4d3SLarry Finger if ((ep_cfg >> USB_NORMAL_SIE_EP_SHIFT) & USB_NORMAL_SIE_EP_MASK) { 67f1d2b4d3SLarry Finger rtlusb->out_queue_sel |= TX_SELE_NQ; 68f1d2b4d3SLarry Finger ep_nums++; 69f1d2b4d3SLarry Finger } 70f1d2b4d3SLarry Finger /* Low queue */ 71f1d2b4d3SLarry Finger ep_cfg = rtl_read_byte(rtlpriv, (REG_NORMAL_SIE_EP + 2)); 72f1d2b4d3SLarry Finger if (ep_cfg & USB_NORMAL_SIE_EP_MASK) { 73f1d2b4d3SLarry Finger rtlusb->out_queue_sel |= TX_SELE_LQ; 74f1d2b4d3SLarry Finger ep_nums++; 75f1d2b4d3SLarry Finger } 76f1d2b4d3SLarry Finger return (rtlusb->out_ep_nums == ep_nums) ? 0 : -EINVAL; 77f1d2b4d3SLarry Finger } 78f1d2b4d3SLarry Finger 79ff970453SLarry Finger static void twooutepmapping(struct ieee80211_hw *hw, bool is_chip8, 80f1d2b4d3SLarry Finger bool bwificfg, struct rtl_ep_map *ep_map) 81f1d2b4d3SLarry Finger { 82f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 83f1d2b4d3SLarry Finger 84f1d2b4d3SLarry Finger if (bwificfg) { /* for WMM */ 8534d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, 86f1d2b4d3SLarry Finger "USB Chip-B & WMM Setting.....\n"); 87f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 2; 88f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 3; 89f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 3; 90f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 91f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 92f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 93f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 94f1d2b4d3SLarry Finger } else { /* typical setting */ 9534d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, 96f1d2b4d3SLarry Finger "USB typical Setting.....\n"); 97f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 3; 98f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 3; 99f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 2; 100f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 101f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 102f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 103f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 104f1d2b4d3SLarry Finger } 105f1d2b4d3SLarry Finger } 106f1d2b4d3SLarry Finger 107ff970453SLarry Finger static void threeoutepmapping(struct ieee80211_hw *hw, bool bwificfg, 108f1d2b4d3SLarry Finger struct rtl_ep_map *ep_map) 109f1d2b4d3SLarry Finger { 110f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1116d255202SLarry Finger 112f1d2b4d3SLarry Finger if (bwificfg) { /* for WMM */ 11334d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, 114f1d2b4d3SLarry Finger "USB 3EP Setting for WMM.....\n"); 115f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 5; 116f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 3; 117f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 3; 118f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 119f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 120f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 121f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 122f1d2b4d3SLarry Finger } else { /* typical setting */ 12334d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, 124f1d2b4d3SLarry Finger "USB 3EP Setting for typical.....\n"); 125f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 5; 126f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 5; 127f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 3; 128f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 129f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 130f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 131f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 132f1d2b4d3SLarry Finger } 133f1d2b4d3SLarry Finger } 134f1d2b4d3SLarry Finger 135ff970453SLarry Finger static void oneoutepmapping(struct ieee80211_hw *hw, struct rtl_ep_map *ep_map) 136f1d2b4d3SLarry Finger { 137f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 2; 138f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 2; 139f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 2; 140f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 141f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 142f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 143f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 144f1d2b4d3SLarry Finger } 1456d255202SLarry Finger 146f1d2b4d3SLarry Finger static int _out_ep_mapping(struct ieee80211_hw *hw) 147f1d2b4d3SLarry Finger { 148f1d2b4d3SLarry Finger int err = 0; 149ff970453SLarry Finger bool ischipn, bwificfg = false; 150f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 151f1d2b4d3SLarry Finger struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw); 152f1d2b4d3SLarry Finger struct rtl_usb *rtlusb = rtl_usbdev(usb_priv); 153f1d2b4d3SLarry Finger struct rtl_ep_map *ep_map = &(rtlusb->ep_map); 154f1d2b4d3SLarry Finger 155ff970453SLarry Finger ischipn = IS_NORMAL_CHIP(rtlhal->version); 156f1d2b4d3SLarry Finger switch (rtlusb->out_ep_nums) { 157f1d2b4d3SLarry Finger case 2: 158ff970453SLarry Finger twooutepmapping(hw, ischipn, bwificfg, ep_map); 159f1d2b4d3SLarry Finger break; 160f1d2b4d3SLarry Finger case 3: 161f1d2b4d3SLarry Finger /* Test chip doesn't support three out EPs. */ 162ff970453SLarry Finger if (!ischipn) { 163f1d2b4d3SLarry Finger err = -EINVAL; 164f1d2b4d3SLarry Finger goto err_out; 165f1d2b4d3SLarry Finger } 166ff970453SLarry Finger threeoutepmapping(hw, ischipn, ep_map); 167f1d2b4d3SLarry Finger break; 168f1d2b4d3SLarry Finger case 1: 169ff970453SLarry Finger oneoutepmapping(hw, ep_map); 170f1d2b4d3SLarry Finger break; 171f1d2b4d3SLarry Finger default: 172f1d2b4d3SLarry Finger err = -EINVAL; 173f1d2b4d3SLarry Finger break; 174f1d2b4d3SLarry Finger } 175f1d2b4d3SLarry Finger err_out: 176f1d2b4d3SLarry Finger return err; 177f1d2b4d3SLarry Finger 178f1d2b4d3SLarry Finger } 1796d255202SLarry Finger 180f1d2b4d3SLarry Finger /* endpoint mapping */ 181f1d2b4d3SLarry Finger int rtl8192cu_endpoint_mapping(struct ieee80211_hw *hw) 182f1d2b4d3SLarry Finger { 183f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 184f1d2b4d3SLarry Finger int error = 0; 1856d255202SLarry Finger 186f1d2b4d3SLarry Finger if (likely(IS_NORMAL_CHIP(rtlhal->version))) 187ff970453SLarry Finger error = configvernoutep(hw); 188f1d2b4d3SLarry Finger else 189ff970453SLarry Finger error = configvertoutep(hw); 190f1d2b4d3SLarry Finger if (error) 191f1d2b4d3SLarry Finger goto err_out; 192f1d2b4d3SLarry Finger error = _out_ep_mapping(hw); 193f1d2b4d3SLarry Finger if (error) 194f1d2b4d3SLarry Finger goto err_out; 195f1d2b4d3SLarry Finger err_out: 196f1d2b4d3SLarry Finger return error; 197f1d2b4d3SLarry Finger } 198f1d2b4d3SLarry Finger 199f1d2b4d3SLarry Finger u16 rtl8192cu_mq_to_hwq(__le16 fc, u16 mac80211_queue_index) 200f1d2b4d3SLarry Finger { 201f1d2b4d3SLarry Finger u16 hw_queue_index; 202f1d2b4d3SLarry Finger 203f1d2b4d3SLarry Finger if (unlikely(ieee80211_is_beacon(fc))) { 204f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BCN; 205f1d2b4d3SLarry Finger goto out; 206f1d2b4d3SLarry Finger } 207f1d2b4d3SLarry Finger if (ieee80211_is_mgmt(fc)) { 208f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_MGT; 209f1d2b4d3SLarry Finger goto out; 210f1d2b4d3SLarry Finger } 211f1d2b4d3SLarry Finger switch (mac80211_queue_index) { 212f1d2b4d3SLarry Finger case 0: 213f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_VO; 214f1d2b4d3SLarry Finger break; 215f1d2b4d3SLarry Finger case 1: 216f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_VI; 217f1d2b4d3SLarry Finger break; 218f1d2b4d3SLarry Finger case 2: 219f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BE; 220f1d2b4d3SLarry Finger break; 221f1d2b4d3SLarry Finger case 3: 222f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BK; 223f1d2b4d3SLarry Finger break; 224f1d2b4d3SLarry Finger default: 225f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BE; 226531940f9SLarry Finger WARN_ONCE(true, "rtl8192cu: QSLT_BE queue, skb_queue:%d\n", 227f1d2b4d3SLarry Finger mac80211_queue_index); 228f1d2b4d3SLarry Finger break; 229f1d2b4d3SLarry Finger } 230f1d2b4d3SLarry Finger out: 231f1d2b4d3SLarry Finger return hw_queue_index; 232f1d2b4d3SLarry Finger } 233f1d2b4d3SLarry Finger 234f1d2b4d3SLarry Finger static enum rtl_desc_qsel _rtl8192cu_mq_to_descq(struct ieee80211_hw *hw, 235f1d2b4d3SLarry Finger __le16 fc, u16 mac80211_queue_index) 236f1d2b4d3SLarry Finger { 237f1d2b4d3SLarry Finger enum rtl_desc_qsel qsel; 238f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 239f1d2b4d3SLarry Finger 240f1d2b4d3SLarry Finger if (unlikely(ieee80211_is_beacon(fc))) { 241f1d2b4d3SLarry Finger qsel = QSLT_BEACON; 242f1d2b4d3SLarry Finger goto out; 243f1d2b4d3SLarry Finger } 244f1d2b4d3SLarry Finger if (ieee80211_is_mgmt(fc)) { 245f1d2b4d3SLarry Finger qsel = QSLT_MGNT; 246f1d2b4d3SLarry Finger goto out; 247f1d2b4d3SLarry Finger } 248f1d2b4d3SLarry Finger switch (mac80211_queue_index) { 249f1d2b4d3SLarry Finger case 0: /* VO */ 250f1d2b4d3SLarry Finger qsel = QSLT_VO; 25134d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_USB, DBG_DMESG, 252f1d2b4d3SLarry Finger "VO queue, set qsel = 0x%x\n", QSLT_VO); 253f1d2b4d3SLarry Finger break; 254f1d2b4d3SLarry Finger case 1: /* VI */ 255f1d2b4d3SLarry Finger qsel = QSLT_VI; 25634d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_USB, DBG_DMESG, 257f1d2b4d3SLarry Finger "VI queue, set qsel = 0x%x\n", QSLT_VI); 258f1d2b4d3SLarry Finger break; 259f1d2b4d3SLarry Finger case 3: /* BK */ 260f1d2b4d3SLarry Finger qsel = QSLT_BK; 26134d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_USB, DBG_DMESG, 262f1d2b4d3SLarry Finger "BK queue, set qsel = 0x%x\n", QSLT_BK); 263f1d2b4d3SLarry Finger break; 264f1d2b4d3SLarry Finger case 2: /* BE */ 265f1d2b4d3SLarry Finger default: 266f1d2b4d3SLarry Finger qsel = QSLT_BE; 26734d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_USB, DBG_DMESG, 268f1d2b4d3SLarry Finger "BE queue, set qsel = 0x%x\n", QSLT_BE); 269f1d2b4d3SLarry Finger break; 270f1d2b4d3SLarry Finger } 271f1d2b4d3SLarry Finger out: 272f1d2b4d3SLarry Finger return qsel; 273f1d2b4d3SLarry Finger } 274f1d2b4d3SLarry Finger 275f1d2b4d3SLarry Finger /* =============================================================== */ 276f1d2b4d3SLarry Finger 277f1d2b4d3SLarry Finger /*---------------------------------------------------------------------- 278f1d2b4d3SLarry Finger * 279f1d2b4d3SLarry Finger * Rx handler 280f1d2b4d3SLarry Finger * 281f1d2b4d3SLarry Finger *---------------------------------------------------------------------- */ 282f1d2b4d3SLarry Finger bool rtl92cu_rx_query_desc(struct ieee80211_hw *hw, 283f1d2b4d3SLarry Finger struct rtl_stats *stats, 284f1d2b4d3SLarry Finger struct ieee80211_rx_status *rx_status, 285afd708f7SLarry Finger u8 *pdesc8, struct sk_buff *skb) 286f1d2b4d3SLarry Finger { 287f1d2b4d3SLarry Finger struct rx_fwinfo_92c *p_drvinfo; 288afd708f7SLarry Finger struct rx_desc_92c *p_desc = (struct rx_desc_92c *)pdesc8; 289afd708f7SLarry Finger __le32 *pdesc = (__le32 *)pdesc8; 2903925ae06SLarry Finger u32 phystatus = get_rx_desc_phy_status(pdesc); 291f1d2b4d3SLarry Finger 2923925ae06SLarry Finger stats->length = (u16)get_rx_desc_pkt_len(pdesc); 2933925ae06SLarry Finger stats->rx_drvinfo_size = (u8)get_rx_desc_drvinfo_size(pdesc) * 294f1d2b4d3SLarry Finger RX_DRV_INFO_SIZE_UNIT; 2953925ae06SLarry Finger stats->rx_bufshift = (u8)(get_rx_desc_shift(pdesc) & 0x03); 2963925ae06SLarry Finger stats->icv = (u16)get_rx_desc_icv(pdesc); 2973925ae06SLarry Finger stats->crc = (u16)get_rx_desc_crc32(pdesc); 298f1d2b4d3SLarry Finger stats->hwerror = (stats->crc | stats->icv); 2993925ae06SLarry Finger stats->decrypted = !get_rx_desc_swdec(pdesc); 3003925ae06SLarry Finger stats->rate = (u8)get_rx_desc_rx_mcs(pdesc); 3013925ae06SLarry Finger stats->shortpreamble = (u16)get_rx_desc_splcp(pdesc); 3023925ae06SLarry Finger stats->isampdu = (bool)(get_rx_desc_paggr(pdesc) == 1); 3033925ae06SLarry Finger stats->isfirst_ampdu = (bool)((get_rx_desc_paggr(pdesc) == 1) && 3043925ae06SLarry Finger (get_rx_desc_faggr(pdesc) == 1)); 3053925ae06SLarry Finger stats->timestamp_low = get_rx_desc_tsfl(pdesc); 3063925ae06SLarry Finger stats->rx_is40mhzpacket = (bool)get_rx_desc_bw(pdesc); 3073925ae06SLarry Finger stats->is_ht = (bool)get_rx_desc_rx_ht(pdesc); 308f1d2b4d3SLarry Finger rx_status->freq = hw->conf.chandef.chan->center_freq; 309f1d2b4d3SLarry Finger rx_status->band = hw->conf.chandef.chan->band; 3103925ae06SLarry Finger if (get_rx_desc_crc32(pdesc)) 311f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_FAILED_FCS_CRC; 3123925ae06SLarry Finger if (!get_rx_desc_swdec(pdesc)) 313f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_DECRYPTED; 3143925ae06SLarry Finger if (get_rx_desc_bw(pdesc)) 315da6a4352SJohannes Berg rx_status->bw = RATE_INFO_BW_40; 3163925ae06SLarry Finger if (get_rx_desc_rx_ht(pdesc)) 317da6a4352SJohannes Berg rx_status->encoding = RX_ENC_HT; 318f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_MACTIME_START; 319f1d2b4d3SLarry Finger if (stats->decrypted) 320f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_DECRYPTED; 321f1d2b4d3SLarry Finger rx_status->rate_idx = rtlwifi_rate_mapping(hw, stats->is_ht, 322f1d2b4d3SLarry Finger false, stats->rate); 3233925ae06SLarry Finger rx_status->mactime = get_rx_desc_tsfl(pdesc); 324f1d2b4d3SLarry Finger if (phystatus) { 325f1d2b4d3SLarry Finger p_drvinfo = (struct rx_fwinfo_92c *)(skb->data + 326f1d2b4d3SLarry Finger stats->rx_bufshift); 327f1d2b4d3SLarry Finger rtl92c_translate_rx_signal_stuff(hw, skb, stats, p_desc, 328f1d2b4d3SLarry Finger p_drvinfo); 329f1d2b4d3SLarry Finger } 330f1d2b4d3SLarry Finger /*rx_status->qual = stats->signal; */ 331f1d2b4d3SLarry Finger rx_status->signal = stats->recvsignalpower + 10; 332f1d2b4d3SLarry Finger return true; 333f1d2b4d3SLarry Finger } 334f1d2b4d3SLarry Finger 335f1d2b4d3SLarry Finger #define RTL_RX_DRV_INFO_UNIT 8 336f1d2b4d3SLarry Finger 337f1d2b4d3SLarry Finger static void _rtl_rx_process(struct ieee80211_hw *hw, struct sk_buff *skb) 338f1d2b4d3SLarry Finger { 339f1d2b4d3SLarry Finger struct ieee80211_rx_status *rx_status = 340f1d2b4d3SLarry Finger (struct ieee80211_rx_status *)IEEE80211_SKB_RXCB(skb); 341f1d2b4d3SLarry Finger u32 skb_len, pkt_len, drvinfo_len; 342f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 343afd708f7SLarry Finger __le32 *rxdesc; 344f1d2b4d3SLarry Finger struct rtl_stats stats = { 345f1d2b4d3SLarry Finger .signal = 0, 346f1d2b4d3SLarry Finger .rate = 0, 347f1d2b4d3SLarry Finger }; 348f1d2b4d3SLarry Finger struct rx_fwinfo_92c *p_drvinfo; 349f1d2b4d3SLarry Finger bool bv; 350f1d2b4d3SLarry Finger __le16 fc; 351f1d2b4d3SLarry Finger struct ieee80211_hdr *hdr; 352f1d2b4d3SLarry Finger 353f1d2b4d3SLarry Finger memset(rx_status, 0, sizeof(*rx_status)); 354afd708f7SLarry Finger rxdesc = (__le32 *)skb->data; 355f1d2b4d3SLarry Finger skb_len = skb->len; 3563925ae06SLarry Finger drvinfo_len = (get_rx_desc_drvinfo_size(rxdesc) * RTL_RX_DRV_INFO_UNIT); 3573925ae06SLarry Finger pkt_len = get_rx_desc_pkt_len(rxdesc); 358f1d2b4d3SLarry Finger /* TODO: Error recovery. drop this skb or something. */ 359f1d2b4d3SLarry Finger WARN_ON(skb_len < (pkt_len + RTL_RX_DESC_SIZE + drvinfo_len)); 3603925ae06SLarry Finger stats.length = (u16)get_rx_desc_pkt_len(rxdesc); 3613925ae06SLarry Finger stats.rx_drvinfo_size = (u8)get_rx_desc_drvinfo_size(rxdesc) * 362f1d2b4d3SLarry Finger RX_DRV_INFO_SIZE_UNIT; 3633925ae06SLarry Finger stats.rx_bufshift = (u8)(get_rx_desc_shift(rxdesc) & 0x03); 3643925ae06SLarry Finger stats.icv = (u16)get_rx_desc_icv(rxdesc); 3653925ae06SLarry Finger stats.crc = (u16)get_rx_desc_crc32(rxdesc); 366f1d2b4d3SLarry Finger stats.hwerror = (stats.crc | stats.icv); 3673925ae06SLarry Finger stats.decrypted = !get_rx_desc_swdec(rxdesc); 3683925ae06SLarry Finger stats.rate = (u8)get_rx_desc_rx_mcs(rxdesc); 3693925ae06SLarry Finger stats.shortpreamble = (u16)get_rx_desc_splcp(rxdesc); 3703925ae06SLarry Finger stats.isampdu = (bool)((get_rx_desc_paggr(rxdesc) == 1) && 3713925ae06SLarry Finger (get_rx_desc_faggr(rxdesc) == 1)); 3723925ae06SLarry Finger stats.timestamp_low = get_rx_desc_tsfl(rxdesc); 3733925ae06SLarry Finger stats.rx_is40mhzpacket = (bool)get_rx_desc_bw(rxdesc); 3743925ae06SLarry Finger stats.is_ht = (bool)get_rx_desc_rx_ht(rxdesc); 375f1d2b4d3SLarry Finger /* TODO: is center_freq changed when doing scan? */ 376f1d2b4d3SLarry Finger /* TODO: Shall we add protection or just skip those two step? */ 377f1d2b4d3SLarry Finger rx_status->freq = hw->conf.chandef.chan->center_freq; 378f1d2b4d3SLarry Finger rx_status->band = hw->conf.chandef.chan->band; 3793925ae06SLarry Finger if (get_rx_desc_crc32(rxdesc)) 380f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_FAILED_FCS_CRC; 3813925ae06SLarry Finger if (!get_rx_desc_swdec(rxdesc)) 382f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_DECRYPTED; 3833925ae06SLarry Finger if (get_rx_desc_bw(rxdesc)) 384da6a4352SJohannes Berg rx_status->bw = RATE_INFO_BW_40; 3853925ae06SLarry Finger if (get_rx_desc_rx_ht(rxdesc)) 386da6a4352SJohannes Berg rx_status->encoding = RX_ENC_HT; 387f1d2b4d3SLarry Finger /* Data rate */ 388f1d2b4d3SLarry Finger rx_status->rate_idx = rtlwifi_rate_mapping(hw, stats.is_ht, 389f1d2b4d3SLarry Finger false, stats.rate); 390f1d2b4d3SLarry Finger /* There is a phy status after this rx descriptor. */ 3913925ae06SLarry Finger if (get_rx_desc_phy_status(rxdesc)) { 392f1d2b4d3SLarry Finger p_drvinfo = (struct rx_fwinfo_92c *)(rxdesc + RTL_RX_DESC_SIZE); 393f1d2b4d3SLarry Finger rtl92c_translate_rx_signal_stuff(hw, skb, &stats, 394f1d2b4d3SLarry Finger (struct rx_desc_92c *)rxdesc, p_drvinfo); 395f1d2b4d3SLarry Finger } 396f1d2b4d3SLarry Finger skb_pull(skb, (drvinfo_len + RTL_RX_DESC_SIZE)); 397f1d2b4d3SLarry Finger hdr = (struct ieee80211_hdr *)(skb->data); 398f1d2b4d3SLarry Finger fc = hdr->frame_control; 399f1d2b4d3SLarry Finger bv = ieee80211_is_probe_resp(fc); 400f1d2b4d3SLarry Finger if (bv) 40134d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, 402f1d2b4d3SLarry Finger "Got probe response frame\n"); 403f1d2b4d3SLarry Finger if (ieee80211_is_beacon(fc)) 40434d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, "Got beacon frame\n"); 405f1d2b4d3SLarry Finger if (ieee80211_is_data(fc)) 40634d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, "Got data frame\n"); 40734d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, 408f1d2b4d3SLarry Finger "Fram: fc = 0x%X addr1 = 0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X\n", 409f1d2b4d3SLarry Finger fc, 410f1d2b4d3SLarry Finger (u32)hdr->addr1[0], (u32)hdr->addr1[1], 411f1d2b4d3SLarry Finger (u32)hdr->addr1[2], (u32)hdr->addr1[3], 412f1d2b4d3SLarry Finger (u32)hdr->addr1[4], (u32)hdr->addr1[5]); 413f1d2b4d3SLarry Finger ieee80211_rx(hw, skb); 414f1d2b4d3SLarry Finger } 415f1d2b4d3SLarry Finger 416f1d2b4d3SLarry Finger void rtl8192cu_rx_hdl(struct ieee80211_hw *hw, struct sk_buff * skb) 417f1d2b4d3SLarry Finger { 418f1d2b4d3SLarry Finger _rtl_rx_process(hw, skb); 419f1d2b4d3SLarry Finger } 420f1d2b4d3SLarry Finger 421f1d2b4d3SLarry Finger /*---------------------------------------------------------------------- 422f1d2b4d3SLarry Finger * 423f1d2b4d3SLarry Finger * Tx handler 424f1d2b4d3SLarry Finger * 425f1d2b4d3SLarry Finger *---------------------------------------------------------------------- */ 426f1d2b4d3SLarry Finger void rtl8192c_tx_cleanup(struct ieee80211_hw *hw, struct sk_buff *skb) 427f1d2b4d3SLarry Finger { 428f1d2b4d3SLarry Finger } 429f1d2b4d3SLarry Finger 430f1d2b4d3SLarry Finger int rtl8192c_tx_post_hdl(struct ieee80211_hw *hw, struct urb *urb, 431f1d2b4d3SLarry Finger struct sk_buff *skb) 432f1d2b4d3SLarry Finger { 433f1d2b4d3SLarry Finger return 0; 434f1d2b4d3SLarry Finger } 435f1d2b4d3SLarry Finger 436f1d2b4d3SLarry Finger struct sk_buff *rtl8192c_tx_aggregate_hdl(struct ieee80211_hw *hw, 437f1d2b4d3SLarry Finger struct sk_buff_head *list) 438f1d2b4d3SLarry Finger { 439f1d2b4d3SLarry Finger return skb_dequeue(list); 440f1d2b4d3SLarry Finger } 441f1d2b4d3SLarry Finger 442f1d2b4d3SLarry Finger /*======================================== trx ===============================*/ 443f1d2b4d3SLarry Finger 444afd708f7SLarry Finger static void _rtl_fill_usb_tx_desc(__le32 *txdesc) 445f1d2b4d3SLarry Finger { 4463925ae06SLarry Finger set_tx_desc_own(txdesc, 1); 4473925ae06SLarry Finger set_tx_desc_last_seg(txdesc, 1); 4483925ae06SLarry Finger set_tx_desc_first_seg(txdesc, 1); 449f1d2b4d3SLarry Finger } 4506d255202SLarry Finger 451f1d2b4d3SLarry Finger /** 452f1d2b4d3SLarry Finger * For HW recovery information 453f1d2b4d3SLarry Finger */ 454afd708f7SLarry Finger static void _rtl_tx_desc_checksum(__le32 *txdesc) 455f1d2b4d3SLarry Finger { 45669d8597eSLarry Finger __le16 *ptr = (__le16 *)txdesc; 457f1d2b4d3SLarry Finger u16 checksum = 0; 458f1d2b4d3SLarry Finger u32 index; 459f1d2b4d3SLarry Finger 460f1d2b4d3SLarry Finger /* Clear first */ 4613925ae06SLarry Finger set_tx_desc_tx_desc_checksum(txdesc, 0); 462f1d2b4d3SLarry Finger for (index = 0; index < 16; index++) 46369d8597eSLarry Finger checksum = checksum ^ le16_to_cpu(*(ptr + index)); 4643925ae06SLarry Finger set_tx_desc_tx_desc_checksum(txdesc, checksum); 465f1d2b4d3SLarry Finger } 466f1d2b4d3SLarry Finger 467f1d2b4d3SLarry Finger void rtl92cu_tx_fill_desc(struct ieee80211_hw *hw, 468f1d2b4d3SLarry Finger struct ieee80211_hdr *hdr, u8 *pdesc_tx, 469f1d2b4d3SLarry Finger u8 *pbd_desc_tx, struct ieee80211_tx_info *info, 470f1d2b4d3SLarry Finger struct ieee80211_sta *sta, 471f1d2b4d3SLarry Finger struct sk_buff *skb, 472f1d2b4d3SLarry Finger u8 queue_index, 473f1d2b4d3SLarry Finger struct rtl_tcb_desc *tcb_desc) 474f1d2b4d3SLarry Finger { 475f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 476f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 477f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 478f1d2b4d3SLarry Finger bool defaultadapter = true; 479f1d2b4d3SLarry Finger u8 *qc = ieee80211_get_qos_ctl(hdr); 480f1d2b4d3SLarry Finger u8 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK; 481f1d2b4d3SLarry Finger u16 seq_number; 482f1d2b4d3SLarry Finger __le16 fc = hdr->frame_control; 483f1d2b4d3SLarry Finger u8 rate_flag = info->control.rates[0].flags; 484f1d2b4d3SLarry Finger u16 pktlen = skb->len; 485f1d2b4d3SLarry Finger enum rtl_desc_qsel fw_qsel = _rtl8192cu_mq_to_descq(hw, fc, 486f1d2b4d3SLarry Finger skb_get_queue_mapping(skb)); 487afd708f7SLarry Finger u8 *txdesc8; 488afd708f7SLarry Finger __le32 *txdesc; 489f1d2b4d3SLarry Finger 490f1d2b4d3SLarry Finger seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4; 491f1d2b4d3SLarry Finger rtl_get_tcb_desc(hw, info, sta, skb, tcb_desc); 492afd708f7SLarry Finger txdesc8 = skb_push(skb, RTL_TX_HEADER_SIZE); 493afd708f7SLarry Finger txdesc = (__le32 *)txdesc8; 494f1d2b4d3SLarry Finger memset(txdesc, 0, RTL_TX_HEADER_SIZE); 4953925ae06SLarry Finger set_tx_desc_pkt_size(txdesc, pktlen); 4963925ae06SLarry Finger set_tx_desc_linip(txdesc, 0); 4973925ae06SLarry Finger set_tx_desc_pkt_offset(txdesc, RTL_DUMMY_OFFSET); 4983925ae06SLarry Finger set_tx_desc_offset(txdesc, RTL_TX_HEADER_SIZE); 4993925ae06SLarry Finger set_tx_desc_tx_rate(txdesc, tcb_desc->hw_rate); 500f1d2b4d3SLarry Finger if (tcb_desc->use_shortgi || tcb_desc->use_shortpreamble) 5013925ae06SLarry Finger set_tx_desc_data_shortgi(txdesc, 1); 502f1d2b4d3SLarry Finger if (mac->tids[tid].agg.agg_state == RTL_AGG_ON && 503f1d2b4d3SLarry Finger info->flags & IEEE80211_TX_CTL_AMPDU) { 5043925ae06SLarry Finger set_tx_desc_agg_enable(txdesc, 1); 5053925ae06SLarry Finger set_tx_desc_max_agg_num(txdesc, 0x14); 506f1d2b4d3SLarry Finger } else { 5073925ae06SLarry Finger set_tx_desc_agg_break(txdesc, 1); 508f1d2b4d3SLarry Finger } 5093925ae06SLarry Finger set_tx_desc_seq(txdesc, seq_number); 5103925ae06SLarry Finger set_tx_desc_rts_enable(txdesc, 5113925ae06SLarry Finger ((tcb_desc->rts_enable && 512f1d2b4d3SLarry Finger !tcb_desc->cts_enable) ? 1 : 0)); 5133925ae06SLarry Finger set_tx_desc_hw_rts_enable(txdesc, 5143925ae06SLarry Finger ((tcb_desc->rts_enable || 515f1d2b4d3SLarry Finger tcb_desc->cts_enable) ? 1 : 0)); 5163925ae06SLarry Finger set_tx_desc_cts2self(txdesc, ((tcb_desc->cts_enable) ? 1 : 0)); 5173925ae06SLarry Finger set_tx_desc_rts_stbc(txdesc, ((tcb_desc->rts_stbc) ? 1 : 0)); 5183925ae06SLarry Finger set_tx_desc_rts_rate(txdesc, tcb_desc->rts_rate); 5193925ae06SLarry Finger set_tx_desc_rts_bw(txdesc, 0); 5203925ae06SLarry Finger set_tx_desc_rts_sc(txdesc, tcb_desc->rts_sc); 5213925ae06SLarry Finger set_tx_desc_rts_short(txdesc, 522f1d2b4d3SLarry Finger ((tcb_desc->rts_rate <= DESC_RATE54M) ? 523f1d2b4d3SLarry Finger (tcb_desc->rts_use_shortpreamble ? 1 : 0) 524f1d2b4d3SLarry Finger : (tcb_desc->rts_use_shortgi ? 1 : 0))); 525f1d2b4d3SLarry Finger if (mac->bw_40) { 526f1d2b4d3SLarry Finger if (rate_flag & IEEE80211_TX_RC_DUP_DATA) { 5273925ae06SLarry Finger set_tx_desc_data_bw(txdesc, 1); 5283925ae06SLarry Finger set_tx_desc_data_sc(txdesc, 3); 529f1d2b4d3SLarry Finger } else if(rate_flag & IEEE80211_TX_RC_40_MHZ_WIDTH){ 5303925ae06SLarry Finger set_tx_desc_data_bw(txdesc, 1); 5313925ae06SLarry Finger set_tx_desc_data_sc(txdesc, mac->cur_40_prime_sc); 532f1d2b4d3SLarry Finger } else { 5333925ae06SLarry Finger set_tx_desc_data_bw(txdesc, 0); 5343925ae06SLarry Finger set_tx_desc_data_sc(txdesc, 0); 535f1d2b4d3SLarry Finger } 536f1d2b4d3SLarry Finger } else { 5373925ae06SLarry Finger set_tx_desc_data_bw(txdesc, 0); 5383925ae06SLarry Finger set_tx_desc_data_sc(txdesc, 0); 539f1d2b4d3SLarry Finger } 540f1d2b4d3SLarry Finger rcu_read_lock(); 541f1d2b4d3SLarry Finger sta = ieee80211_find_sta(mac->vif, mac->bssid); 542f1d2b4d3SLarry Finger if (sta) { 543f1d2b4d3SLarry Finger u8 ampdu_density = sta->ht_cap.ampdu_density; 5446d255202SLarry Finger 5453925ae06SLarry Finger set_tx_desc_ampdu_density(txdesc, ampdu_density); 546f1d2b4d3SLarry Finger } 547f1d2b4d3SLarry Finger rcu_read_unlock(); 548f1d2b4d3SLarry Finger if (info->control.hw_key) { 549f1d2b4d3SLarry Finger struct ieee80211_key_conf *keyconf = info->control.hw_key; 5506d255202SLarry Finger 551f1d2b4d3SLarry Finger switch (keyconf->cipher) { 552f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_WEP40: 553f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_WEP104: 554f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_TKIP: 5553925ae06SLarry Finger set_tx_desc_sec_type(txdesc, 0x1); 556f1d2b4d3SLarry Finger break; 557f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_CCMP: 5583925ae06SLarry Finger set_tx_desc_sec_type(txdesc, 0x3); 559f1d2b4d3SLarry Finger break; 560f1d2b4d3SLarry Finger default: 5613925ae06SLarry Finger set_tx_desc_sec_type(txdesc, 0x0); 562f1d2b4d3SLarry Finger break; 563f1d2b4d3SLarry Finger } 564f1d2b4d3SLarry Finger } 5653925ae06SLarry Finger set_tx_desc_pkt_id(txdesc, 0); 5663925ae06SLarry Finger set_tx_desc_queue_sel(txdesc, fw_qsel); 5673925ae06SLarry Finger set_tx_desc_data_rate_fb_limit(txdesc, 0x1F); 5683925ae06SLarry Finger set_tx_desc_rts_rate_fb_limit(txdesc, 0xF); 5693925ae06SLarry Finger set_tx_desc_disable_fb(txdesc, 0); 5703925ae06SLarry Finger set_tx_desc_use_rate(txdesc, tcb_desc->use_driver_rate ? 1 : 0); 571f1d2b4d3SLarry Finger if (ieee80211_is_data_qos(fc)) { 572f1d2b4d3SLarry Finger if (mac->rdg_en) { 57334d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE, 574f1d2b4d3SLarry Finger "Enable RDG function\n"); 5753925ae06SLarry Finger set_tx_desc_rdg_enable(txdesc, 1); 5763925ae06SLarry Finger set_tx_desc_htc(txdesc, 1); 577f1d2b4d3SLarry Finger } 578f1d2b4d3SLarry Finger } 579f1d2b4d3SLarry Finger if (rtlpriv->dm.useramask) { 5803925ae06SLarry Finger set_tx_desc_rate_id(txdesc, tcb_desc->ratr_index); 5813925ae06SLarry Finger set_tx_desc_macid(txdesc, tcb_desc->mac_id); 582f1d2b4d3SLarry Finger } else { 5833925ae06SLarry Finger set_tx_desc_rate_id(txdesc, 0xC + tcb_desc->ratr_index); 5843925ae06SLarry Finger set_tx_desc_macid(txdesc, tcb_desc->ratr_index); 585f1d2b4d3SLarry Finger } 586f1d2b4d3SLarry Finger if ((!ieee80211_is_data_qos(fc)) && ppsc->leisure_ps && 587f1d2b4d3SLarry Finger ppsc->fwctrl_lps) { 5883925ae06SLarry Finger set_tx_desc_hwseq_en(txdesc, 1); 5893925ae06SLarry Finger set_tx_desc_pkt_id(txdesc, 8); 590f1d2b4d3SLarry Finger if (!defaultadapter) 5913925ae06SLarry Finger set_tx_desc_qos(txdesc, 1); 592f1d2b4d3SLarry Finger } 593f1d2b4d3SLarry Finger if (ieee80211_has_morefrags(fc)) 5943925ae06SLarry Finger set_tx_desc_more_frag(txdesc, 1); 595f1d2b4d3SLarry Finger if (is_multicast_ether_addr(ieee80211_get_DA(hdr)) || 596f1d2b4d3SLarry Finger is_broadcast_ether_addr(ieee80211_get_DA(hdr))) 5973925ae06SLarry Finger set_tx_desc_bmc(txdesc, 1); 598f1d2b4d3SLarry Finger _rtl_fill_usb_tx_desc(txdesc); 599f1d2b4d3SLarry Finger _rtl_tx_desc_checksum(txdesc); 60034d7f007SLarry Finger rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE, "==>\n"); 601f1d2b4d3SLarry Finger } 602f1d2b4d3SLarry Finger 603afd708f7SLarry Finger void rtl92cu_fill_fake_txdesc(struct ieee80211_hw *hw, u8 *pdesc8, 604ff970453SLarry Finger u32 buffer_len, bool is_pspoll) 605f1d2b4d3SLarry Finger { 606afd708f7SLarry Finger __le32 *pdesc = (__le32 *)pdesc8; 607afd708f7SLarry Finger 608f1d2b4d3SLarry Finger /* Clear all status */ 609ff970453SLarry Finger memset(pdesc, 0, RTL_TX_HEADER_SIZE); 6103925ae06SLarry Finger set_tx_desc_first_seg(pdesc, 1); /* bFirstSeg; */ 6113925ae06SLarry Finger set_tx_desc_last_seg(pdesc, 1); /* bLastSeg; */ 6123925ae06SLarry Finger set_tx_desc_offset(pdesc, RTL_TX_HEADER_SIZE); /* Offset = 32 */ 6133925ae06SLarry Finger set_tx_desc_pkt_size(pdesc, buffer_len); /* Buffer size + command hdr */ 6143925ae06SLarry Finger set_tx_desc_queue_sel(pdesc, QSLT_MGNT); /* Fixed queue of Mgnt queue */ 615f1d2b4d3SLarry Finger /* Set NAVUSEHDR to prevent Ps-poll AId filed to be changed to error 616f1d2b4d3SLarry Finger * vlaue by Hw. */ 617ff970453SLarry Finger if (is_pspoll) { 6183925ae06SLarry Finger set_tx_desc_nav_use_hdr(pdesc, 1); 619f1d2b4d3SLarry Finger } else { 6203925ae06SLarry Finger set_tx_desc_hwseq_en(pdesc, 1); /* Hw set sequence number */ 6213925ae06SLarry Finger set_tx_desc_pkt_id(pdesc, BIT(3)); /* set bit3 to 1. */ 622f1d2b4d3SLarry Finger } 6233925ae06SLarry Finger set_tx_desc_use_rate(pdesc, 1); /* use data rate which is set by Sw */ 6243925ae06SLarry Finger set_tx_desc_own(pdesc, 1); 6253925ae06SLarry Finger set_tx_desc_tx_rate(pdesc, DESC_RATE1M); 626ff970453SLarry Finger _rtl_tx_desc_checksum(pdesc); 627f1d2b4d3SLarry Finger } 628f1d2b4d3SLarry Finger 629f1d2b4d3SLarry Finger void rtl92cu_tx_fill_cmddesc(struct ieee80211_hw *hw, 630afd708f7SLarry Finger u8 *pdesc8, bool firstseg, 631f1d2b4d3SLarry Finger bool lastseg, struct sk_buff *skb) 632f1d2b4d3SLarry Finger { 633f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 634f1d2b4d3SLarry Finger u8 fw_queue = QSLT_BEACON; 635f1d2b4d3SLarry Finger struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data); 636f1d2b4d3SLarry Finger __le16 fc = hdr->frame_control; 637afd708f7SLarry Finger __le32 *pdesc = (__le32 *)pdesc8; 638f1d2b4d3SLarry Finger 639f1d2b4d3SLarry Finger memset((void *)pdesc, 0, RTL_TX_HEADER_SIZE); 640f1d2b4d3SLarry Finger if (firstseg) 6413925ae06SLarry Finger set_tx_desc_offset(pdesc, RTL_TX_HEADER_SIZE); 6423925ae06SLarry Finger set_tx_desc_tx_rate(pdesc, DESC_RATE1M); 6433925ae06SLarry Finger set_tx_desc_seq(pdesc, 0); 6443925ae06SLarry Finger set_tx_desc_linip(pdesc, 0); 6453925ae06SLarry Finger set_tx_desc_queue_sel(pdesc, fw_queue); 6463925ae06SLarry Finger set_tx_desc_first_seg(pdesc, 1); 6473925ae06SLarry Finger set_tx_desc_last_seg(pdesc, 1); 6483925ae06SLarry Finger set_tx_desc_rate_id(pdesc, 7); 6493925ae06SLarry Finger set_tx_desc_macid(pdesc, 0); 6503925ae06SLarry Finger set_tx_desc_own(pdesc, 1); 6513925ae06SLarry Finger set_tx_desc_pkt_size(pdesc, (u16)skb->len); 6523925ae06SLarry Finger set_tx_desc_first_seg(pdesc, 1); 6533925ae06SLarry Finger set_tx_desc_last_seg(pdesc, 1); 6543925ae06SLarry Finger set_tx_desc_offset(pdesc, 0x20); 6553925ae06SLarry Finger set_tx_desc_use_rate(pdesc, 1); 656f1d2b4d3SLarry Finger if (!ieee80211_is_data_qos(fc)) { 6573925ae06SLarry Finger set_tx_desc_hwseq_en(pdesc, 1); 6583925ae06SLarry Finger set_tx_desc_pkt_id(pdesc, 8); 659f1d2b4d3SLarry Finger } 660f1d2b4d3SLarry Finger RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD, "H2C Tx Cmd Content", 661f1d2b4d3SLarry Finger pdesc, RTL_TX_DESC_SIZE); 662f1d2b4d3SLarry Finger } 663