1f1d2b4d3SLarry Finger /****************************************************************************** 2f1d2b4d3SLarry Finger * 3f1d2b4d3SLarry Finger * Copyright(c) 2009-2012 Realtek Corporation. All rights reserved. 4f1d2b4d3SLarry Finger * 5f1d2b4d3SLarry Finger * This program is free software; you can redistribute it and/or modify it 6f1d2b4d3SLarry Finger * under the terms of version 2 of the GNU General Public License as 7f1d2b4d3SLarry Finger * published by the Free Software Foundation. 8f1d2b4d3SLarry Finger * 9f1d2b4d3SLarry Finger * This program is distributed in the hope that it will be useful, but WITHOUT 10f1d2b4d3SLarry Finger * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11f1d2b4d3SLarry Finger * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12f1d2b4d3SLarry Finger * more details. 13f1d2b4d3SLarry Finger * 14f1d2b4d3SLarry Finger * You should have received a copy of the GNU General Public License along with 15f1d2b4d3SLarry Finger * this program; if not, write to the Free Software Foundation, Inc., 16f1d2b4d3SLarry Finger * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 17f1d2b4d3SLarry Finger * 18f1d2b4d3SLarry Finger * The full GNU General Public License is included in this distribution in the 19f1d2b4d3SLarry Finger * file called LICENSE. 20f1d2b4d3SLarry Finger * 21f1d2b4d3SLarry Finger * Contact Information: 22f1d2b4d3SLarry Finger * wlanfae <wlanfae@realtek.com> 23f1d2b4d3SLarry Finger * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park, 24f1d2b4d3SLarry Finger * Hsinchu 300, Taiwan. 25f1d2b4d3SLarry Finger * 26f1d2b4d3SLarry Finger * Larry Finger <Larry.Finger@lwfinger.net> 27f1d2b4d3SLarry Finger * 28f1d2b4d3SLarry Finger *****************************************************************************/ 29f1d2b4d3SLarry Finger 30f1d2b4d3SLarry Finger #include "../wifi.h" 31f1d2b4d3SLarry Finger #include "../usb.h" 32f1d2b4d3SLarry Finger #include "../ps.h" 33f1d2b4d3SLarry Finger #include "../base.h" 34f1d2b4d3SLarry Finger #include "reg.h" 35f1d2b4d3SLarry Finger #include "def.h" 36f1d2b4d3SLarry Finger #include "phy.h" 37f1d2b4d3SLarry Finger #include "rf.h" 38f1d2b4d3SLarry Finger #include "dm.h" 39f1d2b4d3SLarry Finger #include "mac.h" 40f1d2b4d3SLarry Finger #include "trx.h" 41f1d2b4d3SLarry Finger #include "../rtl8192c/fw_common.h" 42f1d2b4d3SLarry Finger 43f1d2b4d3SLarry Finger static int _ConfigVerTOutEP(struct ieee80211_hw *hw) 44f1d2b4d3SLarry Finger { 45f1d2b4d3SLarry Finger u8 ep_cfg, txqsele; 46f1d2b4d3SLarry Finger u8 ep_nums = 0; 47f1d2b4d3SLarry Finger 48f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 49f1d2b4d3SLarry Finger struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw); 50f1d2b4d3SLarry Finger struct rtl_usb *rtlusb = rtl_usbdev(usb_priv); 51f1d2b4d3SLarry Finger 52f1d2b4d3SLarry Finger rtlusb->out_queue_sel = 0; 53f1d2b4d3SLarry Finger ep_cfg = rtl_read_byte(rtlpriv, REG_TEST_SIE_OPTIONAL); 54f1d2b4d3SLarry Finger ep_cfg = (ep_cfg & USB_TEST_EP_MASK) >> USB_TEST_EP_SHIFT; 55f1d2b4d3SLarry Finger switch (ep_cfg) { 56f1d2b4d3SLarry Finger case 0: /* 2 bulk OUT, 1 bulk IN */ 57f1d2b4d3SLarry Finger case 3: 58f1d2b4d3SLarry Finger rtlusb->out_queue_sel = TX_SELE_HQ | TX_SELE_LQ; 59f1d2b4d3SLarry Finger ep_nums = 2; 60f1d2b4d3SLarry Finger break; 61f1d2b4d3SLarry Finger case 1: /* 1 bulk IN/OUT => map all endpoint to Low queue */ 62f1d2b4d3SLarry Finger case 2: /* 1 bulk IN, 1 bulk OUT => map all endpoint to High queue */ 63f1d2b4d3SLarry Finger txqsele = rtl_read_byte(rtlpriv, REG_TEST_USB_TXQS); 64f1d2b4d3SLarry Finger if (txqsele & 0x0F) /* /map all endpoint to High queue */ 65f1d2b4d3SLarry Finger rtlusb->out_queue_sel = TX_SELE_HQ; 66f1d2b4d3SLarry Finger else if (txqsele&0xF0) /* map all endpoint to Low queue */ 67f1d2b4d3SLarry Finger rtlusb->out_queue_sel = TX_SELE_LQ; 68f1d2b4d3SLarry Finger ep_nums = 1; 69f1d2b4d3SLarry Finger break; 70f1d2b4d3SLarry Finger default: 71f1d2b4d3SLarry Finger break; 72f1d2b4d3SLarry Finger } 73f1d2b4d3SLarry Finger return (rtlusb->out_ep_nums == ep_nums) ? 0 : -EINVAL; 74f1d2b4d3SLarry Finger } 75f1d2b4d3SLarry Finger 76f1d2b4d3SLarry Finger static int _ConfigVerNOutEP(struct ieee80211_hw *hw) 77f1d2b4d3SLarry Finger { 78f1d2b4d3SLarry Finger u8 ep_cfg; 79f1d2b4d3SLarry Finger u8 ep_nums = 0; 80f1d2b4d3SLarry Finger 81f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 82f1d2b4d3SLarry Finger struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw); 83f1d2b4d3SLarry Finger struct rtl_usb *rtlusb = rtl_usbdev(usb_priv); 84f1d2b4d3SLarry Finger 85f1d2b4d3SLarry Finger rtlusb->out_queue_sel = 0; 86f1d2b4d3SLarry Finger /* Normal and High queue */ 87f1d2b4d3SLarry Finger ep_cfg = rtl_read_byte(rtlpriv, (REG_NORMAL_SIE_EP + 1)); 88f1d2b4d3SLarry Finger if (ep_cfg & USB_NORMAL_SIE_EP_MASK) { 89f1d2b4d3SLarry Finger rtlusb->out_queue_sel |= TX_SELE_HQ; 90f1d2b4d3SLarry Finger ep_nums++; 91f1d2b4d3SLarry Finger } 92f1d2b4d3SLarry Finger if ((ep_cfg >> USB_NORMAL_SIE_EP_SHIFT) & USB_NORMAL_SIE_EP_MASK) { 93f1d2b4d3SLarry Finger rtlusb->out_queue_sel |= TX_SELE_NQ; 94f1d2b4d3SLarry Finger ep_nums++; 95f1d2b4d3SLarry Finger } 96f1d2b4d3SLarry Finger /* Low queue */ 97f1d2b4d3SLarry Finger ep_cfg = rtl_read_byte(rtlpriv, (REG_NORMAL_SIE_EP + 2)); 98f1d2b4d3SLarry Finger if (ep_cfg & USB_NORMAL_SIE_EP_MASK) { 99f1d2b4d3SLarry Finger rtlusb->out_queue_sel |= TX_SELE_LQ; 100f1d2b4d3SLarry Finger ep_nums++; 101f1d2b4d3SLarry Finger } 102f1d2b4d3SLarry Finger return (rtlusb->out_ep_nums == ep_nums) ? 0 : -EINVAL; 103f1d2b4d3SLarry Finger } 104f1d2b4d3SLarry Finger 105f1d2b4d3SLarry Finger static void _TwoOutEpMapping(struct ieee80211_hw *hw, bool bIsChipB, 106f1d2b4d3SLarry Finger bool bwificfg, struct rtl_ep_map *ep_map) 107f1d2b4d3SLarry Finger { 108f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 109f1d2b4d3SLarry Finger 110f1d2b4d3SLarry Finger if (bwificfg) { /* for WMM */ 111f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 112f1d2b4d3SLarry Finger "USB Chip-B & WMM Setting.....\n"); 113f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 2; 114f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 3; 115f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 3; 116f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 117f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 118f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 119f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 120f1d2b4d3SLarry Finger } else { /* typical setting */ 121f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 122f1d2b4d3SLarry Finger "USB typical Setting.....\n"); 123f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 3; 124f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 3; 125f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 2; 126f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 127f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 128f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 129f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 130f1d2b4d3SLarry Finger } 131f1d2b4d3SLarry Finger } 132f1d2b4d3SLarry Finger 133f1d2b4d3SLarry Finger static void _ThreeOutEpMapping(struct ieee80211_hw *hw, bool bwificfg, 134f1d2b4d3SLarry Finger struct rtl_ep_map *ep_map) 135f1d2b4d3SLarry Finger { 136f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 137f1d2b4d3SLarry Finger if (bwificfg) { /* for WMM */ 138f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 139f1d2b4d3SLarry Finger "USB 3EP Setting for WMM.....\n"); 140f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 5; 141f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 3; 142f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 3; 143f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 144f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 145f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 146f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 147f1d2b4d3SLarry Finger } else { /* typical setting */ 148f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 149f1d2b4d3SLarry Finger "USB 3EP Setting for typical.....\n"); 150f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 5; 151f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 5; 152f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 3; 153f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 154f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 155f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 156f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 157f1d2b4d3SLarry Finger } 158f1d2b4d3SLarry Finger } 159f1d2b4d3SLarry Finger 160f1d2b4d3SLarry Finger static void _OneOutEpMapping(struct ieee80211_hw *hw, struct rtl_ep_map *ep_map) 161f1d2b4d3SLarry Finger { 162f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BE] = 2; 163f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BK] = 2; 164f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VI] = 2; 165f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_VO] = 2; 166f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_MGT] = 2; 167f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_BCN] = 2; 168f1d2b4d3SLarry Finger ep_map->ep_mapping[RTL_TXQ_HI] = 2; 169f1d2b4d3SLarry Finger } 170f1d2b4d3SLarry Finger static int _out_ep_mapping(struct ieee80211_hw *hw) 171f1d2b4d3SLarry Finger { 172f1d2b4d3SLarry Finger int err = 0; 173f1d2b4d3SLarry Finger bool bIsChipN, bwificfg = false; 174f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 175f1d2b4d3SLarry Finger struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw); 176f1d2b4d3SLarry Finger struct rtl_usb *rtlusb = rtl_usbdev(usb_priv); 177f1d2b4d3SLarry Finger struct rtl_ep_map *ep_map = &(rtlusb->ep_map); 178f1d2b4d3SLarry Finger 179f1d2b4d3SLarry Finger bIsChipN = IS_NORMAL_CHIP(rtlhal->version); 180f1d2b4d3SLarry Finger switch (rtlusb->out_ep_nums) { 181f1d2b4d3SLarry Finger case 2: 182f1d2b4d3SLarry Finger _TwoOutEpMapping(hw, bIsChipN, bwificfg, ep_map); 183f1d2b4d3SLarry Finger break; 184f1d2b4d3SLarry Finger case 3: 185f1d2b4d3SLarry Finger /* Test chip doesn't support three out EPs. */ 186f1d2b4d3SLarry Finger if (!bIsChipN) { 187f1d2b4d3SLarry Finger err = -EINVAL; 188f1d2b4d3SLarry Finger goto err_out; 189f1d2b4d3SLarry Finger } 190f1d2b4d3SLarry Finger _ThreeOutEpMapping(hw, bIsChipN, ep_map); 191f1d2b4d3SLarry Finger break; 192f1d2b4d3SLarry Finger case 1: 193f1d2b4d3SLarry Finger _OneOutEpMapping(hw, ep_map); 194f1d2b4d3SLarry Finger break; 195f1d2b4d3SLarry Finger default: 196f1d2b4d3SLarry Finger err = -EINVAL; 197f1d2b4d3SLarry Finger break; 198f1d2b4d3SLarry Finger } 199f1d2b4d3SLarry Finger err_out: 200f1d2b4d3SLarry Finger return err; 201f1d2b4d3SLarry Finger 202f1d2b4d3SLarry Finger } 203f1d2b4d3SLarry Finger /* endpoint mapping */ 204f1d2b4d3SLarry Finger int rtl8192cu_endpoint_mapping(struct ieee80211_hw *hw) 205f1d2b4d3SLarry Finger { 206f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 207f1d2b4d3SLarry Finger int error = 0; 208f1d2b4d3SLarry Finger if (likely(IS_NORMAL_CHIP(rtlhal->version))) 209f1d2b4d3SLarry Finger error = _ConfigVerNOutEP(hw); 210f1d2b4d3SLarry Finger else 211f1d2b4d3SLarry Finger error = _ConfigVerTOutEP(hw); 212f1d2b4d3SLarry Finger if (error) 213f1d2b4d3SLarry Finger goto err_out; 214f1d2b4d3SLarry Finger error = _out_ep_mapping(hw); 215f1d2b4d3SLarry Finger if (error) 216f1d2b4d3SLarry Finger goto err_out; 217f1d2b4d3SLarry Finger err_out: 218f1d2b4d3SLarry Finger return error; 219f1d2b4d3SLarry Finger } 220f1d2b4d3SLarry Finger 221f1d2b4d3SLarry Finger u16 rtl8192cu_mq_to_hwq(__le16 fc, u16 mac80211_queue_index) 222f1d2b4d3SLarry Finger { 223f1d2b4d3SLarry Finger u16 hw_queue_index; 224f1d2b4d3SLarry Finger 225f1d2b4d3SLarry Finger if (unlikely(ieee80211_is_beacon(fc))) { 226f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BCN; 227f1d2b4d3SLarry Finger goto out; 228f1d2b4d3SLarry Finger } 229f1d2b4d3SLarry Finger if (ieee80211_is_mgmt(fc)) { 230f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_MGT; 231f1d2b4d3SLarry Finger goto out; 232f1d2b4d3SLarry Finger } 233f1d2b4d3SLarry Finger switch (mac80211_queue_index) { 234f1d2b4d3SLarry Finger case 0: 235f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_VO; 236f1d2b4d3SLarry Finger break; 237f1d2b4d3SLarry Finger case 1: 238f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_VI; 239f1d2b4d3SLarry Finger break; 240f1d2b4d3SLarry Finger case 2: 241f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BE; 242f1d2b4d3SLarry Finger break; 243f1d2b4d3SLarry Finger case 3: 244f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BK; 245f1d2b4d3SLarry Finger break; 246f1d2b4d3SLarry Finger default: 247f1d2b4d3SLarry Finger hw_queue_index = RTL_TXQ_BE; 248f1d2b4d3SLarry Finger RT_ASSERT(false, "QSLT_BE queue, skb_queue:%d\n", 249f1d2b4d3SLarry Finger mac80211_queue_index); 250f1d2b4d3SLarry Finger break; 251f1d2b4d3SLarry Finger } 252f1d2b4d3SLarry Finger out: 253f1d2b4d3SLarry Finger return hw_queue_index; 254f1d2b4d3SLarry Finger } 255f1d2b4d3SLarry Finger 256f1d2b4d3SLarry Finger static enum rtl_desc_qsel _rtl8192cu_mq_to_descq(struct ieee80211_hw *hw, 257f1d2b4d3SLarry Finger __le16 fc, u16 mac80211_queue_index) 258f1d2b4d3SLarry Finger { 259f1d2b4d3SLarry Finger enum rtl_desc_qsel qsel; 260f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 261f1d2b4d3SLarry Finger 262f1d2b4d3SLarry Finger if (unlikely(ieee80211_is_beacon(fc))) { 263f1d2b4d3SLarry Finger qsel = QSLT_BEACON; 264f1d2b4d3SLarry Finger goto out; 265f1d2b4d3SLarry Finger } 266f1d2b4d3SLarry Finger if (ieee80211_is_mgmt(fc)) { 267f1d2b4d3SLarry Finger qsel = QSLT_MGNT; 268f1d2b4d3SLarry Finger goto out; 269f1d2b4d3SLarry Finger } 270f1d2b4d3SLarry Finger switch (mac80211_queue_index) { 271f1d2b4d3SLarry Finger case 0: /* VO */ 272f1d2b4d3SLarry Finger qsel = QSLT_VO; 273f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_USB, DBG_DMESG, 274f1d2b4d3SLarry Finger "VO queue, set qsel = 0x%x\n", QSLT_VO); 275f1d2b4d3SLarry Finger break; 276f1d2b4d3SLarry Finger case 1: /* VI */ 277f1d2b4d3SLarry Finger qsel = QSLT_VI; 278f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_USB, DBG_DMESG, 279f1d2b4d3SLarry Finger "VI queue, set qsel = 0x%x\n", QSLT_VI); 280f1d2b4d3SLarry Finger break; 281f1d2b4d3SLarry Finger case 3: /* BK */ 282f1d2b4d3SLarry Finger qsel = QSLT_BK; 283f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_USB, DBG_DMESG, 284f1d2b4d3SLarry Finger "BK queue, set qsel = 0x%x\n", QSLT_BK); 285f1d2b4d3SLarry Finger break; 286f1d2b4d3SLarry Finger case 2: /* BE */ 287f1d2b4d3SLarry Finger default: 288f1d2b4d3SLarry Finger qsel = QSLT_BE; 289f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_USB, DBG_DMESG, 290f1d2b4d3SLarry Finger "BE queue, set qsel = 0x%x\n", QSLT_BE); 291f1d2b4d3SLarry Finger break; 292f1d2b4d3SLarry Finger } 293f1d2b4d3SLarry Finger out: 294f1d2b4d3SLarry Finger return qsel; 295f1d2b4d3SLarry Finger } 296f1d2b4d3SLarry Finger 297f1d2b4d3SLarry Finger /* =============================================================== */ 298f1d2b4d3SLarry Finger 299f1d2b4d3SLarry Finger /*---------------------------------------------------------------------- 300f1d2b4d3SLarry Finger * 301f1d2b4d3SLarry Finger * Rx handler 302f1d2b4d3SLarry Finger * 303f1d2b4d3SLarry Finger *---------------------------------------------------------------------- */ 304f1d2b4d3SLarry Finger bool rtl92cu_rx_query_desc(struct ieee80211_hw *hw, 305f1d2b4d3SLarry Finger struct rtl_stats *stats, 306f1d2b4d3SLarry Finger struct ieee80211_rx_status *rx_status, 307f1d2b4d3SLarry Finger u8 *pdesc, struct sk_buff *skb) 308f1d2b4d3SLarry Finger { 309f1d2b4d3SLarry Finger struct rx_fwinfo_92c *p_drvinfo; 310f1d2b4d3SLarry Finger struct rx_desc_92c *p_desc = (struct rx_desc_92c *)pdesc; 311f1d2b4d3SLarry Finger u32 phystatus = GET_RX_DESC_PHY_STATUS(pdesc); 312f1d2b4d3SLarry Finger 313f1d2b4d3SLarry Finger stats->length = (u16) GET_RX_DESC_PKT_LEN(pdesc); 314f1d2b4d3SLarry Finger stats->rx_drvinfo_size = (u8)GET_RX_DESC_DRVINFO_SIZE(pdesc) * 315f1d2b4d3SLarry Finger RX_DRV_INFO_SIZE_UNIT; 316f1d2b4d3SLarry Finger stats->rx_bufshift = (u8) (GET_RX_DESC_SHIFT(pdesc) & 0x03); 317f1d2b4d3SLarry Finger stats->icv = (u16) GET_RX_DESC_ICV(pdesc); 318f1d2b4d3SLarry Finger stats->crc = (u16) GET_RX_DESC_CRC32(pdesc); 319f1d2b4d3SLarry Finger stats->hwerror = (stats->crc | stats->icv); 320f1d2b4d3SLarry Finger stats->decrypted = !GET_RX_DESC_SWDEC(pdesc); 321f1d2b4d3SLarry Finger stats->rate = (u8) GET_RX_DESC_RX_MCS(pdesc); 322f1d2b4d3SLarry Finger stats->shortpreamble = (u16) GET_RX_DESC_SPLCP(pdesc); 323f1d2b4d3SLarry Finger stats->isampdu = (bool) (GET_RX_DESC_PAGGR(pdesc) == 1); 324f1d2b4d3SLarry Finger stats->isfirst_ampdu = (bool)((GET_RX_DESC_PAGGR(pdesc) == 1) 325f1d2b4d3SLarry Finger && (GET_RX_DESC_FAGGR(pdesc) == 1)); 326f1d2b4d3SLarry Finger stats->timestamp_low = GET_RX_DESC_TSFL(pdesc); 327f1d2b4d3SLarry Finger stats->rx_is40Mhzpacket = (bool) GET_RX_DESC_BW(pdesc); 328f1d2b4d3SLarry Finger stats->is_ht = (bool)GET_RX_DESC_RX_HT(pdesc); 329f1d2b4d3SLarry Finger rx_status->freq = hw->conf.chandef.chan->center_freq; 330f1d2b4d3SLarry Finger rx_status->band = hw->conf.chandef.chan->band; 331f1d2b4d3SLarry Finger if (GET_RX_DESC_CRC32(pdesc)) 332f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_FAILED_FCS_CRC; 333f1d2b4d3SLarry Finger if (!GET_RX_DESC_SWDEC(pdesc)) 334f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_DECRYPTED; 335f1d2b4d3SLarry Finger if (GET_RX_DESC_BW(pdesc)) 336f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_40MHZ; 337f1d2b4d3SLarry Finger if (GET_RX_DESC_RX_HT(pdesc)) 338f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_HT; 339f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_MACTIME_START; 340f1d2b4d3SLarry Finger if (stats->decrypted) 341f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_DECRYPTED; 342f1d2b4d3SLarry Finger rx_status->rate_idx = rtlwifi_rate_mapping(hw, stats->is_ht, 343f1d2b4d3SLarry Finger false, stats->rate); 344f1d2b4d3SLarry Finger rx_status->mactime = GET_RX_DESC_TSFL(pdesc); 345f1d2b4d3SLarry Finger if (phystatus) { 346f1d2b4d3SLarry Finger p_drvinfo = (struct rx_fwinfo_92c *)(skb->data + 347f1d2b4d3SLarry Finger stats->rx_bufshift); 348f1d2b4d3SLarry Finger rtl92c_translate_rx_signal_stuff(hw, skb, stats, p_desc, 349f1d2b4d3SLarry Finger p_drvinfo); 350f1d2b4d3SLarry Finger } 351f1d2b4d3SLarry Finger /*rx_status->qual = stats->signal; */ 352f1d2b4d3SLarry Finger rx_status->signal = stats->recvsignalpower + 10; 353f1d2b4d3SLarry Finger return true; 354f1d2b4d3SLarry Finger } 355f1d2b4d3SLarry Finger 356f1d2b4d3SLarry Finger #define RTL_RX_DRV_INFO_UNIT 8 357f1d2b4d3SLarry Finger 358f1d2b4d3SLarry Finger static void _rtl_rx_process(struct ieee80211_hw *hw, struct sk_buff *skb) 359f1d2b4d3SLarry Finger { 360f1d2b4d3SLarry Finger struct ieee80211_rx_status *rx_status = 361f1d2b4d3SLarry Finger (struct ieee80211_rx_status *)IEEE80211_SKB_RXCB(skb); 362f1d2b4d3SLarry Finger u32 skb_len, pkt_len, drvinfo_len; 363f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 364f1d2b4d3SLarry Finger u8 *rxdesc; 365f1d2b4d3SLarry Finger struct rtl_stats stats = { 366f1d2b4d3SLarry Finger .signal = 0, 367f1d2b4d3SLarry Finger .rate = 0, 368f1d2b4d3SLarry Finger }; 369f1d2b4d3SLarry Finger struct rx_fwinfo_92c *p_drvinfo; 370f1d2b4d3SLarry Finger bool bv; 371f1d2b4d3SLarry Finger __le16 fc; 372f1d2b4d3SLarry Finger struct ieee80211_hdr *hdr; 373f1d2b4d3SLarry Finger 374f1d2b4d3SLarry Finger memset(rx_status, 0, sizeof(*rx_status)); 375f1d2b4d3SLarry Finger rxdesc = skb->data; 376f1d2b4d3SLarry Finger skb_len = skb->len; 377f1d2b4d3SLarry Finger drvinfo_len = (GET_RX_DESC_DRVINFO_SIZE(rxdesc) * RTL_RX_DRV_INFO_UNIT); 378f1d2b4d3SLarry Finger pkt_len = GET_RX_DESC_PKT_LEN(rxdesc); 379f1d2b4d3SLarry Finger /* TODO: Error recovery. drop this skb or something. */ 380f1d2b4d3SLarry Finger WARN_ON(skb_len < (pkt_len + RTL_RX_DESC_SIZE + drvinfo_len)); 381f1d2b4d3SLarry Finger stats.length = (u16) GET_RX_DESC_PKT_LEN(rxdesc); 382f1d2b4d3SLarry Finger stats.rx_drvinfo_size = (u8)GET_RX_DESC_DRVINFO_SIZE(rxdesc) * 383f1d2b4d3SLarry Finger RX_DRV_INFO_SIZE_UNIT; 384f1d2b4d3SLarry Finger stats.rx_bufshift = (u8) (GET_RX_DESC_SHIFT(rxdesc) & 0x03); 385f1d2b4d3SLarry Finger stats.icv = (u16) GET_RX_DESC_ICV(rxdesc); 386f1d2b4d3SLarry Finger stats.crc = (u16) GET_RX_DESC_CRC32(rxdesc); 387f1d2b4d3SLarry Finger stats.hwerror = (stats.crc | stats.icv); 388f1d2b4d3SLarry Finger stats.decrypted = !GET_RX_DESC_SWDEC(rxdesc); 389f1d2b4d3SLarry Finger stats.rate = (u8) GET_RX_DESC_RX_MCS(rxdesc); 390f1d2b4d3SLarry Finger stats.shortpreamble = (u16) GET_RX_DESC_SPLCP(rxdesc); 391f1d2b4d3SLarry Finger stats.isampdu = (bool) ((GET_RX_DESC_PAGGR(rxdesc) == 1) 392f1d2b4d3SLarry Finger && (GET_RX_DESC_FAGGR(rxdesc) == 1)); 393f1d2b4d3SLarry Finger stats.timestamp_low = GET_RX_DESC_TSFL(rxdesc); 394f1d2b4d3SLarry Finger stats.rx_is40Mhzpacket = (bool) GET_RX_DESC_BW(rxdesc); 395f1d2b4d3SLarry Finger stats.is_ht = (bool)GET_RX_DESC_RX_HT(rxdesc); 396f1d2b4d3SLarry Finger /* TODO: is center_freq changed when doing scan? */ 397f1d2b4d3SLarry Finger /* TODO: Shall we add protection or just skip those two step? */ 398f1d2b4d3SLarry Finger rx_status->freq = hw->conf.chandef.chan->center_freq; 399f1d2b4d3SLarry Finger rx_status->band = hw->conf.chandef.chan->band; 400f1d2b4d3SLarry Finger if (GET_RX_DESC_CRC32(rxdesc)) 401f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_FAILED_FCS_CRC; 402f1d2b4d3SLarry Finger if (!GET_RX_DESC_SWDEC(rxdesc)) 403f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_DECRYPTED; 404f1d2b4d3SLarry Finger if (GET_RX_DESC_BW(rxdesc)) 405f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_40MHZ; 406f1d2b4d3SLarry Finger if (GET_RX_DESC_RX_HT(rxdesc)) 407f1d2b4d3SLarry Finger rx_status->flag |= RX_FLAG_HT; 408f1d2b4d3SLarry Finger /* Data rate */ 409f1d2b4d3SLarry Finger rx_status->rate_idx = rtlwifi_rate_mapping(hw, stats.is_ht, 410f1d2b4d3SLarry Finger false, stats.rate); 411f1d2b4d3SLarry Finger /* There is a phy status after this rx descriptor. */ 412f1d2b4d3SLarry Finger if (GET_RX_DESC_PHY_STATUS(rxdesc)) { 413f1d2b4d3SLarry Finger p_drvinfo = (struct rx_fwinfo_92c *)(rxdesc + RTL_RX_DESC_SIZE); 414f1d2b4d3SLarry Finger rtl92c_translate_rx_signal_stuff(hw, skb, &stats, 415f1d2b4d3SLarry Finger (struct rx_desc_92c *)rxdesc, p_drvinfo); 416f1d2b4d3SLarry Finger } 417f1d2b4d3SLarry Finger skb_pull(skb, (drvinfo_len + RTL_RX_DESC_SIZE)); 418f1d2b4d3SLarry Finger hdr = (struct ieee80211_hdr *)(skb->data); 419f1d2b4d3SLarry Finger fc = hdr->frame_control; 420f1d2b4d3SLarry Finger bv = ieee80211_is_probe_resp(fc); 421f1d2b4d3SLarry Finger if (bv) 422f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 423f1d2b4d3SLarry Finger "Got probe response frame\n"); 424f1d2b4d3SLarry Finger if (ieee80211_is_beacon(fc)) 425f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Got beacon frame\n"); 426f1d2b4d3SLarry Finger if (ieee80211_is_data(fc)) 427f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Got data frame\n"); 428f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 429f1d2b4d3SLarry Finger "Fram: fc = 0x%X addr1 = 0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X\n", 430f1d2b4d3SLarry Finger fc, 431f1d2b4d3SLarry Finger (u32)hdr->addr1[0], (u32)hdr->addr1[1], 432f1d2b4d3SLarry Finger (u32)hdr->addr1[2], (u32)hdr->addr1[3], 433f1d2b4d3SLarry Finger (u32)hdr->addr1[4], (u32)hdr->addr1[5]); 434f1d2b4d3SLarry Finger memcpy(IEEE80211_SKB_RXCB(skb), rx_status, sizeof(*rx_status)); 435f1d2b4d3SLarry Finger ieee80211_rx(hw, skb); 436f1d2b4d3SLarry Finger } 437f1d2b4d3SLarry Finger 438f1d2b4d3SLarry Finger void rtl8192cu_rx_hdl(struct ieee80211_hw *hw, struct sk_buff * skb) 439f1d2b4d3SLarry Finger { 440f1d2b4d3SLarry Finger _rtl_rx_process(hw, skb); 441f1d2b4d3SLarry Finger } 442f1d2b4d3SLarry Finger 443f1d2b4d3SLarry Finger void rtl8192c_rx_segregate_hdl( 444f1d2b4d3SLarry Finger struct ieee80211_hw *hw, 445f1d2b4d3SLarry Finger struct sk_buff *skb, 446f1d2b4d3SLarry Finger struct sk_buff_head *skb_list) 447f1d2b4d3SLarry Finger { 448f1d2b4d3SLarry Finger } 449f1d2b4d3SLarry Finger 450f1d2b4d3SLarry Finger /*---------------------------------------------------------------------- 451f1d2b4d3SLarry Finger * 452f1d2b4d3SLarry Finger * Tx handler 453f1d2b4d3SLarry Finger * 454f1d2b4d3SLarry Finger *---------------------------------------------------------------------- */ 455f1d2b4d3SLarry Finger void rtl8192c_tx_cleanup(struct ieee80211_hw *hw, struct sk_buff *skb) 456f1d2b4d3SLarry Finger { 457f1d2b4d3SLarry Finger } 458f1d2b4d3SLarry Finger 459f1d2b4d3SLarry Finger int rtl8192c_tx_post_hdl(struct ieee80211_hw *hw, struct urb *urb, 460f1d2b4d3SLarry Finger struct sk_buff *skb) 461f1d2b4d3SLarry Finger { 462f1d2b4d3SLarry Finger return 0; 463f1d2b4d3SLarry Finger } 464f1d2b4d3SLarry Finger 465f1d2b4d3SLarry Finger struct sk_buff *rtl8192c_tx_aggregate_hdl(struct ieee80211_hw *hw, 466f1d2b4d3SLarry Finger struct sk_buff_head *list) 467f1d2b4d3SLarry Finger { 468f1d2b4d3SLarry Finger return skb_dequeue(list); 469f1d2b4d3SLarry Finger } 470f1d2b4d3SLarry Finger 471f1d2b4d3SLarry Finger /*======================================== trx ===============================*/ 472f1d2b4d3SLarry Finger 473f1d2b4d3SLarry Finger static void _rtl_fill_usb_tx_desc(u8 *txdesc) 474f1d2b4d3SLarry Finger { 475f1d2b4d3SLarry Finger SET_TX_DESC_OWN(txdesc, 1); 476f1d2b4d3SLarry Finger SET_TX_DESC_LAST_SEG(txdesc, 1); 477f1d2b4d3SLarry Finger SET_TX_DESC_FIRST_SEG(txdesc, 1); 478f1d2b4d3SLarry Finger } 479f1d2b4d3SLarry Finger /** 480f1d2b4d3SLarry Finger * For HW recovery information 481f1d2b4d3SLarry Finger */ 482f1d2b4d3SLarry Finger static void _rtl_tx_desc_checksum(u8 *txdesc) 483f1d2b4d3SLarry Finger { 484f1d2b4d3SLarry Finger u16 *ptr = (u16 *)txdesc; 485f1d2b4d3SLarry Finger u16 checksum = 0; 486f1d2b4d3SLarry Finger u32 index; 487f1d2b4d3SLarry Finger 488f1d2b4d3SLarry Finger /* Clear first */ 489f1d2b4d3SLarry Finger SET_TX_DESC_TX_DESC_CHECKSUM(txdesc, 0); 490f1d2b4d3SLarry Finger for (index = 0; index < 16; index++) 491f1d2b4d3SLarry Finger checksum = checksum ^ (*(ptr + index)); 492f1d2b4d3SLarry Finger SET_TX_DESC_TX_DESC_CHECKSUM(txdesc, checksum); 493f1d2b4d3SLarry Finger } 494f1d2b4d3SLarry Finger 495f1d2b4d3SLarry Finger void rtl92cu_tx_fill_desc(struct ieee80211_hw *hw, 496f1d2b4d3SLarry Finger struct ieee80211_hdr *hdr, u8 *pdesc_tx, 497f1d2b4d3SLarry Finger u8 *pbd_desc_tx, struct ieee80211_tx_info *info, 498f1d2b4d3SLarry Finger struct ieee80211_sta *sta, 499f1d2b4d3SLarry Finger struct sk_buff *skb, 500f1d2b4d3SLarry Finger u8 queue_index, 501f1d2b4d3SLarry Finger struct rtl_tcb_desc *tcb_desc) 502f1d2b4d3SLarry Finger { 503f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 504f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 505f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 506f1d2b4d3SLarry Finger bool defaultadapter = true; 507f1d2b4d3SLarry Finger u8 *qc = ieee80211_get_qos_ctl(hdr); 508f1d2b4d3SLarry Finger u8 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK; 509f1d2b4d3SLarry Finger u16 seq_number; 510f1d2b4d3SLarry Finger __le16 fc = hdr->frame_control; 511f1d2b4d3SLarry Finger u8 rate_flag = info->control.rates[0].flags; 512f1d2b4d3SLarry Finger u16 pktlen = skb->len; 513f1d2b4d3SLarry Finger enum rtl_desc_qsel fw_qsel = _rtl8192cu_mq_to_descq(hw, fc, 514f1d2b4d3SLarry Finger skb_get_queue_mapping(skb)); 515f1d2b4d3SLarry Finger u8 *txdesc; 516f1d2b4d3SLarry Finger 517f1d2b4d3SLarry Finger seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4; 518f1d2b4d3SLarry Finger rtl_get_tcb_desc(hw, info, sta, skb, tcb_desc); 519f1d2b4d3SLarry Finger txdesc = (u8 *)skb_push(skb, RTL_TX_HEADER_SIZE); 520f1d2b4d3SLarry Finger memset(txdesc, 0, RTL_TX_HEADER_SIZE); 521f1d2b4d3SLarry Finger SET_TX_DESC_PKT_SIZE(txdesc, pktlen); 522f1d2b4d3SLarry Finger SET_TX_DESC_LINIP(txdesc, 0); 523f1d2b4d3SLarry Finger SET_TX_DESC_PKT_OFFSET(txdesc, RTL_DUMMY_OFFSET); 524f1d2b4d3SLarry Finger SET_TX_DESC_OFFSET(txdesc, RTL_TX_HEADER_SIZE); 525f1d2b4d3SLarry Finger SET_TX_DESC_TX_RATE(txdesc, tcb_desc->hw_rate); 526f1d2b4d3SLarry Finger if (tcb_desc->use_shortgi || tcb_desc->use_shortpreamble) 527f1d2b4d3SLarry Finger SET_TX_DESC_DATA_SHORTGI(txdesc, 1); 528f1d2b4d3SLarry Finger if (mac->tids[tid].agg.agg_state == RTL_AGG_ON && 529f1d2b4d3SLarry Finger info->flags & IEEE80211_TX_CTL_AMPDU) { 530f1d2b4d3SLarry Finger SET_TX_DESC_AGG_ENABLE(txdesc, 1); 531f1d2b4d3SLarry Finger SET_TX_DESC_MAX_AGG_NUM(txdesc, 0x14); 532f1d2b4d3SLarry Finger } else { 533f1d2b4d3SLarry Finger SET_TX_DESC_AGG_BREAK(txdesc, 1); 534f1d2b4d3SLarry Finger } 535f1d2b4d3SLarry Finger SET_TX_DESC_SEQ(txdesc, seq_number); 536f1d2b4d3SLarry Finger SET_TX_DESC_RTS_ENABLE(txdesc, ((tcb_desc->rts_enable && 537f1d2b4d3SLarry Finger !tcb_desc->cts_enable) ? 1 : 0)); 538f1d2b4d3SLarry Finger SET_TX_DESC_HW_RTS_ENABLE(txdesc, ((tcb_desc->rts_enable || 539f1d2b4d3SLarry Finger tcb_desc->cts_enable) ? 1 : 0)); 540f1d2b4d3SLarry Finger SET_TX_DESC_CTS2SELF(txdesc, ((tcb_desc->cts_enable) ? 1 : 0)); 541f1d2b4d3SLarry Finger SET_TX_DESC_RTS_STBC(txdesc, ((tcb_desc->rts_stbc) ? 1 : 0)); 542f1d2b4d3SLarry Finger SET_TX_DESC_RTS_RATE(txdesc, tcb_desc->rts_rate); 543f1d2b4d3SLarry Finger SET_TX_DESC_RTS_BW(txdesc, 0); 544f1d2b4d3SLarry Finger SET_TX_DESC_RTS_SC(txdesc, tcb_desc->rts_sc); 545f1d2b4d3SLarry Finger SET_TX_DESC_RTS_SHORT(txdesc, 546f1d2b4d3SLarry Finger ((tcb_desc->rts_rate <= DESC_RATE54M) ? 547f1d2b4d3SLarry Finger (tcb_desc->rts_use_shortpreamble ? 1 : 0) 548f1d2b4d3SLarry Finger : (tcb_desc->rts_use_shortgi ? 1 : 0))); 549f1d2b4d3SLarry Finger if (mac->bw_40) { 550f1d2b4d3SLarry Finger if (rate_flag & IEEE80211_TX_RC_DUP_DATA) { 551f1d2b4d3SLarry Finger SET_TX_DESC_DATA_BW(txdesc, 1); 552f1d2b4d3SLarry Finger SET_TX_DESC_DATA_SC(txdesc, 3); 553f1d2b4d3SLarry Finger } else if(rate_flag & IEEE80211_TX_RC_40_MHZ_WIDTH){ 554f1d2b4d3SLarry Finger SET_TX_DESC_DATA_BW(txdesc, 1); 555f1d2b4d3SLarry Finger SET_TX_DESC_DATA_SC(txdesc, mac->cur_40_prime_sc); 556f1d2b4d3SLarry Finger } else { 557f1d2b4d3SLarry Finger SET_TX_DESC_DATA_BW(txdesc, 0); 558f1d2b4d3SLarry Finger SET_TX_DESC_DATA_SC(txdesc, 0); 559f1d2b4d3SLarry Finger } 560f1d2b4d3SLarry Finger } else { 561f1d2b4d3SLarry Finger SET_TX_DESC_DATA_BW(txdesc, 0); 562f1d2b4d3SLarry Finger SET_TX_DESC_DATA_SC(txdesc, 0); 563f1d2b4d3SLarry Finger } 564f1d2b4d3SLarry Finger rcu_read_lock(); 565f1d2b4d3SLarry Finger sta = ieee80211_find_sta(mac->vif, mac->bssid); 566f1d2b4d3SLarry Finger if (sta) { 567f1d2b4d3SLarry Finger u8 ampdu_density = sta->ht_cap.ampdu_density; 568f1d2b4d3SLarry Finger SET_TX_DESC_AMPDU_DENSITY(txdesc, ampdu_density); 569f1d2b4d3SLarry Finger } 570f1d2b4d3SLarry Finger rcu_read_unlock(); 571f1d2b4d3SLarry Finger if (info->control.hw_key) { 572f1d2b4d3SLarry Finger struct ieee80211_key_conf *keyconf = info->control.hw_key; 573f1d2b4d3SLarry Finger switch (keyconf->cipher) { 574f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_WEP40: 575f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_WEP104: 576f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_TKIP: 577f1d2b4d3SLarry Finger SET_TX_DESC_SEC_TYPE(txdesc, 0x1); 578f1d2b4d3SLarry Finger break; 579f1d2b4d3SLarry Finger case WLAN_CIPHER_SUITE_CCMP: 580f1d2b4d3SLarry Finger SET_TX_DESC_SEC_TYPE(txdesc, 0x3); 581f1d2b4d3SLarry Finger break; 582f1d2b4d3SLarry Finger default: 583f1d2b4d3SLarry Finger SET_TX_DESC_SEC_TYPE(txdesc, 0x0); 584f1d2b4d3SLarry Finger break; 585f1d2b4d3SLarry Finger } 586f1d2b4d3SLarry Finger } 587f1d2b4d3SLarry Finger SET_TX_DESC_PKT_ID(txdesc, 0); 588f1d2b4d3SLarry Finger SET_TX_DESC_QUEUE_SEL(txdesc, fw_qsel); 589f1d2b4d3SLarry Finger SET_TX_DESC_DATA_RATE_FB_LIMIT(txdesc, 0x1F); 590f1d2b4d3SLarry Finger SET_TX_DESC_RTS_RATE_FB_LIMIT(txdesc, 0xF); 591f1d2b4d3SLarry Finger SET_TX_DESC_DISABLE_FB(txdesc, 0); 592f1d2b4d3SLarry Finger SET_TX_DESC_USE_RATE(txdesc, tcb_desc->use_driver_rate ? 1 : 0); 593f1d2b4d3SLarry Finger if (ieee80211_is_data_qos(fc)) { 594f1d2b4d3SLarry Finger if (mac->rdg_en) { 595f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE, 596f1d2b4d3SLarry Finger "Enable RDG function\n"); 597f1d2b4d3SLarry Finger SET_TX_DESC_RDG_ENABLE(txdesc, 1); 598f1d2b4d3SLarry Finger SET_TX_DESC_HTC(txdesc, 1); 599f1d2b4d3SLarry Finger } 600f1d2b4d3SLarry Finger } 601f1d2b4d3SLarry Finger if (rtlpriv->dm.useramask) { 602f1d2b4d3SLarry Finger SET_TX_DESC_RATE_ID(txdesc, tcb_desc->ratr_index); 603f1d2b4d3SLarry Finger SET_TX_DESC_MACID(txdesc, tcb_desc->mac_id); 604f1d2b4d3SLarry Finger } else { 605f1d2b4d3SLarry Finger SET_TX_DESC_RATE_ID(txdesc, 0xC + tcb_desc->ratr_index); 606f1d2b4d3SLarry Finger SET_TX_DESC_MACID(txdesc, tcb_desc->ratr_index); 607f1d2b4d3SLarry Finger } 608f1d2b4d3SLarry Finger if ((!ieee80211_is_data_qos(fc)) && ppsc->leisure_ps && 609f1d2b4d3SLarry Finger ppsc->fwctrl_lps) { 610f1d2b4d3SLarry Finger SET_TX_DESC_HWSEQ_EN(txdesc, 1); 611f1d2b4d3SLarry Finger SET_TX_DESC_PKT_ID(txdesc, 8); 612f1d2b4d3SLarry Finger if (!defaultadapter) 613f1d2b4d3SLarry Finger SET_TX_DESC_QOS(txdesc, 1); 614f1d2b4d3SLarry Finger } 615f1d2b4d3SLarry Finger if (ieee80211_has_morefrags(fc)) 616f1d2b4d3SLarry Finger SET_TX_DESC_MORE_FRAG(txdesc, 1); 617f1d2b4d3SLarry Finger if (is_multicast_ether_addr(ieee80211_get_DA(hdr)) || 618f1d2b4d3SLarry Finger is_broadcast_ether_addr(ieee80211_get_DA(hdr))) 619f1d2b4d3SLarry Finger SET_TX_DESC_BMC(txdesc, 1); 620f1d2b4d3SLarry Finger _rtl_fill_usb_tx_desc(txdesc); 621f1d2b4d3SLarry Finger _rtl_tx_desc_checksum(txdesc); 622f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE, "==>\n"); 623f1d2b4d3SLarry Finger } 624f1d2b4d3SLarry Finger 625f1d2b4d3SLarry Finger void rtl92cu_fill_fake_txdesc(struct ieee80211_hw *hw, u8 * pDesc, 626f1d2b4d3SLarry Finger u32 buffer_len, bool bIsPsPoll) 627f1d2b4d3SLarry Finger { 628f1d2b4d3SLarry Finger /* Clear all status */ 629f1d2b4d3SLarry Finger memset(pDesc, 0, RTL_TX_HEADER_SIZE); 630f1d2b4d3SLarry Finger SET_TX_DESC_FIRST_SEG(pDesc, 1); /* bFirstSeg; */ 631f1d2b4d3SLarry Finger SET_TX_DESC_LAST_SEG(pDesc, 1); /* bLastSeg; */ 632f1d2b4d3SLarry Finger SET_TX_DESC_OFFSET(pDesc, RTL_TX_HEADER_SIZE); /* Offset = 32 */ 633f1d2b4d3SLarry Finger SET_TX_DESC_PKT_SIZE(pDesc, buffer_len); /* Buffer size + command hdr */ 634f1d2b4d3SLarry Finger SET_TX_DESC_QUEUE_SEL(pDesc, QSLT_MGNT); /* Fixed queue of Mgnt queue */ 635f1d2b4d3SLarry Finger /* Set NAVUSEHDR to prevent Ps-poll AId filed to be changed to error 636f1d2b4d3SLarry Finger * vlaue by Hw. */ 637f1d2b4d3SLarry Finger if (bIsPsPoll) { 638f1d2b4d3SLarry Finger SET_TX_DESC_NAV_USE_HDR(pDesc, 1); 639f1d2b4d3SLarry Finger } else { 640f1d2b4d3SLarry Finger SET_TX_DESC_HWSEQ_EN(pDesc, 1); /* Hw set sequence number */ 641f1d2b4d3SLarry Finger SET_TX_DESC_PKT_ID(pDesc, 0x100); /* set bit3 to 1. */ 642f1d2b4d3SLarry Finger } 643f1d2b4d3SLarry Finger SET_TX_DESC_USE_RATE(pDesc, 1); /* use data rate which is set by Sw */ 644f1d2b4d3SLarry Finger SET_TX_DESC_OWN(pDesc, 1); 645f1d2b4d3SLarry Finger SET_TX_DESC_TX_RATE(pDesc, DESC_RATE1M); 646f1d2b4d3SLarry Finger _rtl_tx_desc_checksum(pDesc); 647f1d2b4d3SLarry Finger } 648f1d2b4d3SLarry Finger 649f1d2b4d3SLarry Finger void rtl92cu_tx_fill_cmddesc(struct ieee80211_hw *hw, 650f1d2b4d3SLarry Finger u8 *pdesc, bool firstseg, 651f1d2b4d3SLarry Finger bool lastseg, struct sk_buff *skb) 652f1d2b4d3SLarry Finger { 653f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 654f1d2b4d3SLarry Finger u8 fw_queue = QSLT_BEACON; 655f1d2b4d3SLarry Finger struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data); 656f1d2b4d3SLarry Finger __le16 fc = hdr->frame_control; 657f1d2b4d3SLarry Finger 658f1d2b4d3SLarry Finger memset((void *)pdesc, 0, RTL_TX_HEADER_SIZE); 659f1d2b4d3SLarry Finger if (firstseg) 660f1d2b4d3SLarry Finger SET_TX_DESC_OFFSET(pdesc, RTL_TX_HEADER_SIZE); 661f1d2b4d3SLarry Finger SET_TX_DESC_TX_RATE(pdesc, DESC_RATE1M); 662f1d2b4d3SLarry Finger SET_TX_DESC_SEQ(pdesc, 0); 663f1d2b4d3SLarry Finger SET_TX_DESC_LINIP(pdesc, 0); 664f1d2b4d3SLarry Finger SET_TX_DESC_QUEUE_SEL(pdesc, fw_queue); 665f1d2b4d3SLarry Finger SET_TX_DESC_FIRST_SEG(pdesc, 1); 666f1d2b4d3SLarry Finger SET_TX_DESC_LAST_SEG(pdesc, 1); 667f1d2b4d3SLarry Finger SET_TX_DESC_RATE_ID(pdesc, 7); 668f1d2b4d3SLarry Finger SET_TX_DESC_MACID(pdesc, 0); 669f1d2b4d3SLarry Finger SET_TX_DESC_OWN(pdesc, 1); 670f1d2b4d3SLarry Finger SET_TX_DESC_PKT_SIZE(pdesc, (u16)skb->len); 671f1d2b4d3SLarry Finger SET_TX_DESC_FIRST_SEG(pdesc, 1); 672f1d2b4d3SLarry Finger SET_TX_DESC_LAST_SEG(pdesc, 1); 673f1d2b4d3SLarry Finger SET_TX_DESC_OFFSET(pdesc, 0x20); 674f1d2b4d3SLarry Finger SET_TX_DESC_USE_RATE(pdesc, 1); 675f1d2b4d3SLarry Finger if (!ieee80211_is_data_qos(fc)) { 676f1d2b4d3SLarry Finger SET_TX_DESC_HWSEQ_EN(pdesc, 1); 677f1d2b4d3SLarry Finger SET_TX_DESC_PKT_ID(pdesc, 8); 678f1d2b4d3SLarry Finger } 679f1d2b4d3SLarry Finger RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD, "H2C Tx Cmd Content", 680f1d2b4d3SLarry Finger pdesc, RTL_TX_DESC_SIZE); 681f1d2b4d3SLarry Finger } 682f1d2b4d3SLarry Finger 683f1d2b4d3SLarry Finger bool rtl92cu_cmd_send_packet(struct ieee80211_hw *hw, struct sk_buff *skb) 684f1d2b4d3SLarry Finger { 685f1d2b4d3SLarry Finger return true; 686f1d2b4d3SLarry Finger } 687