| /****************************************************************************** |
| * |
| * This file is provided under a dual license. When you use or |
| * distribute this software, you may choose to be licensed under |
| * version 2 of the GNU General Public License ("GPLv2 License") |
| * or BSD License. |
| * |
| * GPLv2 License |
| * |
| * Copyright(C) 2016 MediaTek Inc. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of version 2 of the GNU General Public License as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| * See http://www.gnu.org/licenses/gpl-2.0.html for more details. |
| * |
| * BSD LICENSE |
| * |
| * Copyright(C) 2016 MediaTek Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of the copyright holder nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| *****************************************************************************/ |
| /* |
| *************************************************************************** |
| * MediaTek Inc. |
| * |
| * All rights reserved. source code is an unpublished work and the |
| * use of a copyright notice does not imply otherwise. This source code |
| * contains confidential trade secret material of MediaTek. Any attemp |
| * or participation in deciphering, decoding, reverse engineering or in any |
| * way altering the source code is stricitly prohibited, unless the prior |
| * written consent of MediaTek, Inc. is obtained. |
| *************************************************************************** |
| |
| Module Name: |
| gl_ate_agent.c |
| */ |
| /******************************************************************************* |
| * C O M P I L E R F L A G S |
| ******************************************************************************** |
| */ |
| |
| /******************************************************************************* |
| * E X T E R N A L R E F E R E N C E S |
| ******************************************************************************** |
| */ |
| |
| #include "precomp.h" |
| #if CFG_SUPPORT_QA_TOOL |
| #include "gl_wext.h" |
| #include "gl_cfg80211.h" |
| #include "gl_ate_agent.h" |
| #include "gl_hook_api.h" |
| #include "gl_qa_agent.h" |
| #if KERNEL_VERSION(3, 8, 0) <= CFG80211_VERSION_CODE |
| #include <uapi/linux/nl80211.h> |
| #endif |
| |
| /******************************************************************************* |
| * C O N S T A N T S |
| ******************************************************************************** |
| */ |
| |
| #if CFG_SUPPORT_TX_BF |
| PFMU_PROFILE_TAG1 g_rPfmuTag1; |
| PFMU_PROFILE_TAG2 g_rPfmuTag2; |
| PFMU_DATA g_rPfmuData; |
| #endif |
| |
| typedef struct _ATE_PRIV_CMD { |
| UINT_8 *name; |
| int (*set_proc)(struct net_device *prNetDev, UINT_8 *prInBuf); |
| } ATE_PRIV_CMD, *P_ATE_PRIV_CMD; |
| |
| ATE_PRIV_CMD rAtePrivCmdTable[] = { |
| {"ResetCounter", Set_ResetStatCounter_Proc}, |
| {"ATE", SetATE}, |
| #if 0 |
| {"ADCDump", SetADCDump}, |
| {"ATEBSSID", SetATEBssid}, |
| #endif |
| {"ATEDA", SetATEDa}, |
| {"ATESA", SetATESa}, |
| {"ATECHANNEL", SetATEChannel}, |
| {"ATETXPOW0", SetATETxPower0}, |
| {"ATETXGI", SetATETxGi}, |
| {"ATETXBW", SetATETxBw}, |
| {"ATETXLEN", SetATETxLength}, |
| {"ATETXCNT", SetATETxCount}, |
| {"ATETXMCS", SetATETxMcs}, |
| {"ATETXMODE", SetATETxMode}, |
| {"ATEIPG", SetATEIpg}, |
| #if CFG_SUPPORT_TX_BF |
| {"TxBfProfileTagHelp", Set_TxBfProfileTag_Help}, |
| {"TxBfProfileTagInValid", Set_TxBfProfileTag_InValid}, |
| {"TxBfProfileTagPfmuIdx", Set_TxBfProfileTag_PfmuIdx}, |
| {"TxBfProfileTagBfType", Set_TxBfProfileTag_BfType}, |
| {"TxBfProfileTagBw", Set_TxBfProfileTag_DBW}, |
| {"TxBfProfileTagSuMu", Set_TxBfProfileTag_SuMu}, |
| {"TxBfProfileTagMemAlloc", Set_TxBfProfileTag_Mem}, |
| {"TxBfProfileTagMatrix", Set_TxBfProfileTag_Matrix}, |
| {"TxBfProfileTagSnr", Set_TxBfProfileTag_SNR}, |
| {"TxBfProfileTagSmtAnt", Set_TxBfProfileTag_SmartAnt}, |
| {"TxBfProfileTagSeIdx", Set_TxBfProfileTag_SeIdx}, |
| {"TxBfProfileTagRmsdThrd", Set_TxBfProfileTag_RmsdThrd}, |
| {"TxBfProfileTagMcsThrd", Set_TxBfProfileTag_McsThrd}, |
| {"TxBfProfileTagTimeOut", Set_TxBfProfileTag_TimeOut}, |
| {"TxBfProfileTagDesiredBw", Set_TxBfProfileTag_DesiredBW}, |
| {"TxBfProfileTagDesiredNc", Set_TxBfProfileTag_DesiredNc}, |
| {"TxBfProfileTagDesiredNr", Set_TxBfProfileTag_DesiredNr}, |
| {"TxBfProfileTagRead", Set_TxBfProfileTagRead}, |
| {"TxBfProfileTagWrite", Set_TxBfProfileTagWrite}, |
| {"TxBfProfileDataRead", Set_TxBfProfileDataRead}, |
| {"TxBfProfileDataWrite", Set_TxBfProfileDataWrite}, |
| {"TxBfProfilePnRead", Set_TxBfProfilePnRead}, |
| {"TxBfProfilePnWrite", Set_TxBfProfilePnWrite}, |
| {"TxBfSounding", Set_Trigger_Sounding_Proc}, |
| {"TxBfSoundingStop", Set_Stop_Sounding_Proc}, |
| {"TxBfTxApply", Set_TxBfTxApply}, |
| {"TxBfManualAssoc", Set_TxBfManualAssoc}, |
| {"TxBfPfmuMemAlloc", Set_TxBfPfmuMemAlloc}, |
| {"TxBfPfmuMemRelease", Set_TxBfPfmuMemRelease}, |
| {"StaRecCmmUpdate", Set_StaRecCmmUpdate}, |
| {"StaRecBfUpdate", Set_StaRecBfUpdate}, |
| {"DevInfoUpdate", Set_DevInfoUpdate}, |
| {"BssInfoUpdate", Set_BssInfoUpdate}, |
| #if CFG_SUPPORT_MU_MIMO |
| {"MUGetInitMCS", Set_MUGetInitMCS}, |
| {"MUCalInitMCS", Set_MUCalInitMCS}, |
| {"MUCalLQ", Set_MUCalLQ}, |
| {"MUGetLQ", Set_MUGetLQ}, |
| {"MUSetSNROffset", Set_MUSetSNROffset}, |
| {"MUSetZeroNss", Set_MUSetZeroNss}, |
| {"MUSetSpeedUpLQ", Set_MUSetSpeedUpLQ}, |
| {"MUSetMUTable", Set_MUSetMUTable}, |
| {"MUSetGroup", Set_MUSetGroup}, |
| {"MUGetQD", Set_MUGetQD}, |
| {"MUSetEnable", Set_MUSetEnable}, |
| {"MUSetGID_UP", Set_MUSetGID_UP}, |
| {"MUTriggerTx", Set_MUTriggerTx}, |
| #endif |
| #endif |
| |
| {"WriteEfuse", WriteEfuse}, |
| {"TxPower", SetTxTargetPower}, |
| #if (CFG_SUPPORT_DFS_MASTER == 1) |
| {"RDDReport", SetRddReport}, |
| {"ByPassCac", SetByPassCac}, |
| {"RadarDetectMode", SetRadarDetectMode}, |
| #endif |
| |
| {NULL,} |
| }; |
| |
| /******************************************************************************* |
| * F U N C T I O N D E C L A R A T I O N S |
| ******************************************************************************** |
| */ |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Reset RX Statistic Counters. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int Set_ResetStatCounter_Proc(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set_ResetStatCounter_Proc\n"); |
| |
| i4Status = MT_ATEResetTXRXCounter(prNetDev); |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set Start Test Mode / Stop Test Mode / Start TX / Stop TX / Start RX / Stop RX. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATE(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE\n"); |
| |
| if (!strcmp(prInBuf, "ATESTART")) { |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE - ATESTART\n"); |
| i4Status = MT_ATEStart(prNetDev, prInBuf); |
| } else if (!strcmp(prInBuf, "ICAPSTART")) { |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE - ICAPSTART\n"); |
| i4Status = MT_ICAPStart(prNetDev, prInBuf); |
| } else if (!strcmp(prInBuf, "ATESTOP")) { |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE - ATESTOP\n"); |
| i4Status = MT_ATEStop(prNetDev, prInBuf); |
| } else if (!strcmp(prInBuf, "TXFRAME")) { |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE - TXFRAME\n"); |
| i4Status = MT_ATEStartTX(prNetDev, prInBuf); |
| } else if (!strcmp(prInBuf, "TXSTOP")) { |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE - TXSTOP\n"); |
| i4Status = MT_ATEStopTX(prNetDev, prInBuf); |
| } else if (!strcmp(prInBuf, "RXFRAME")) { |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE - RXFRAME\n"); |
| i4Status = MT_ATEStartRX(prNetDev, prInBuf); |
| } else if (!strcmp(prInBuf, "RXSTOP")) { |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetATE - RXSTOP\n"); |
| i4Status = MT_ATEStopRX(prNetDev, prInBuf); |
| } else { |
| return -EINVAL; |
| } |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX Destination Address. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATEDa(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status = 0; |
| UINT_32 addr[MAC_ADDR_LEN]; |
| UINT_8 addr2[MAC_ADDR_LEN]; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 : ATE_AGENT iwpriv SetDa\n"); |
| /* xx:xx:xx:xx:xx:xx */ |
| rv = sscanf(prInBuf, "%x:%x:%x:%x:%x:%x", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]); |
| if (rv == 6) { |
| DBGLOG(RFTEST, ERROR, "MT6632 : ATE_AGENT iwpriv SetATEDa Sa:%02x:%02x:%02x:%02x:%02x:%02x\n", |
| addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); |
| |
| addr2[0] = (UINT_8) addr[0]; |
| addr2[1] = (UINT_8) addr[1]; |
| addr2[2] = (UINT_8) addr[2]; |
| addr2[3] = (UINT_8) addr[3]; |
| addr2[4] = (UINT_8) addr[4]; |
| addr2[5] = (UINT_8) addr[5]; |
| |
| i4Status = MT_ATESetMACAddress(prNetDev, RF_AT_FUNCID_SET_MAC_ADDRESS, addr2); |
| } else { |
| return -EINVAL; |
| } |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX Source Address. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATESa(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status = 0; |
| UINT_32 addr[MAC_ADDR_LEN]; |
| UINT_8 addr2[MAC_ADDR_LEN]; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 : ATE_AGENT iwpriv SetSa\n"); |
| /* xx:xx:xx:xx:xx:xx */ |
| rv = sscanf(prInBuf, "%x:%x:%x:%x:%x:%x", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]); |
| if (rv == 6) { |
| DBGLOG(RFTEST, ERROR, "MT6632 : ATE_AGENT iwpriv SetATESa Sa:%02x:%02x:%02x:%02x:%02x:%02x\n", |
| addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); |
| |
| addr2[0] = (UINT_8) addr[0]; |
| addr2[1] = (UINT_8) addr[1]; |
| addr2[2] = (UINT_8) addr[2]; |
| addr2[3] = (UINT_8) addr[3]; |
| addr2[4] = (UINT_8) addr[4]; |
| addr2[5] = (UINT_8) addr[5]; |
| |
| i4Status = MT_ATESetMACAddress(prNetDev, RF_AT_FUNCID_SET_TA, addr2); |
| } else { |
| return -EINVAL; |
| } |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set Channel Frequency. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATEChannel(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetFreq = 0; |
| INT_32 i4Status, i4SetChan = 0; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetChannel\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetChan); |
| if (rv == 0) { |
| i4SetFreq = nicChannelNum2Freq(i4SetChan); |
| i4Status = MT_ATESetChannel(prNetDev, 0, i4SetFreq); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX WF0 Power. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATETxPower0(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetTxPower0 = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetTxPower0\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetTxPower0); |
| if (rv == 0) |
| i4Status = MT_ATESetTxPower0(prNetDev, i4SetTxPower0); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX Guard Interval. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATETxGi(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetTxGi = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetTxGi\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetTxGi); |
| if (rv == 0) |
| i4Status = MT_ATESetTxGi(prNetDev, i4SetTxGi); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX System Bandwidth. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATETxBw(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetSystemBW = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetSystemBW\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetSystemBW); |
| if (rv == 0) |
| i4Status = MT_ATESetSystemBW(prNetDev, i4SetSystemBW); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX Mode (Preamble). |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATETxMode(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetTxMode = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetTxMode\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetTxMode); |
| if (rv == 0) |
| i4Status = MT_ATESetPreamble(prNetDev, i4SetTxMode); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX Length. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATETxLength(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetTxLength = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetTxLength\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetTxLength); |
| if (rv == 0) |
| i4Status = MT_ATESetTxLength(prNetDev, i4SetTxLength); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX Count. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATETxCount(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetTxCount = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| UCHAR addr[MAC_ADDR_LEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetTxCount\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetTxCount); |
| if (rv == 0) |
| i4Status = MT_ATESetTxCount(prNetDev, i4SetTxCount); |
| else |
| return -EINVAL; |
| |
| i4Status = MT_ATESetMACAddress(prNetDev, RF_AT_FUNCID_SET_MAC_ADDRESS, addr); |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set TX Rate. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATETxMcs(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetTxMcs = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetTxMcs\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetTxMcs); |
| if (rv == 0) |
| i4Status = MT_ATESetRate(prNetDev, i4SetTxMcs); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set Inter-Packet Guard Interval. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetATEIpg(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 i4SetTxIPG = 0; |
| INT_32 i4Status; |
| INT_32 rv; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv SetIpg\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &i4SetTxIPG); |
| if (rv == 0) |
| i4Status = MT_ATESetTxIPG(prNetDev, i4SetTxIPG); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| #if CFG_SUPPORT_TX_BF |
| int Set_TxBfProfileTag_Help(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| DBGLOG(RFTEST, ERROR, |
| "========================================================================================================================\n" |
| "TxBfProfile Tag1 setting example :\n" |
| "iwpriv ra0 set TxBfProfileTagPfmuIdx =xx\n" |
| "iwpriv ra0 set TxBfProfileTagBfType =xx (0: iBF; 1: eBF)\n" |
| "iwpriv ra0 set TxBfProfileTagBw =xx (0/1/2/3 : BW20/40/80/160NC)\n" |
| "iwpriv ra0 set TxBfProfileTagSuMu =xx (0:SU, 1:MU)\n" |
| "iwpriv ra0 set TxBfProfileTagInvalid =xx (0: valid, 1: invalid)\n" |
| "iwpriv ra0 set TxBfProfileTagMemAlloc =xx:xx:xx:xx:xx:xx:xx:xx (mem_row, mem_col), ..\n" |
| "iwpriv ra0 set TxBfProfileTagMatrix =nrow:nol:ng:LM\n" |
| "iwpriv ra0 set TxBfProfileTagSnr =SNR_STS0:SNR_STS1:SNR_STS2:SNR_STS3\n" |
| "\n\n" |
| "TxBfProfile Tag2 setting example :\n" |
| "iwpriv ra0 set TxBfProfileTagSmtAnt =xx (11:0)\n" |
| "iwpriv ra0 set TxBfProfileTagSeIdx =xx\n" |
| "iwpriv ra0 set TxBfProfileTagRmsdThrd =xx\n" |
| "iwpriv ra0 set TxBfProfileTagMcsThrd =xx:xx:xx:xx:xx:xx (MCS TH L1SS:S1SS:L2SS:....)\n" |
| "iwpriv ra0 set TxBfProfileTagTimeOut =xx\n" |
| "iwpriv ra0 set TxBfProfileTagDesiredBw=xx (0/1/2/3 : BW20/40/80/160NC)\n" |
| "iwpriv ra0 set TxBfProfileTagDesiredNc=xx\n" |
| "iwpriv ra0 set TxBfProfileTagDesiredNr=xx\n" |
| "\n\n" |
| "Read TxBf profile Tag :\n" |
| "iwpriv ra0 set TxBfProfileTagRead =xx (PFMU ID)\n" |
| "\n" |
| "Write TxBf profile Tag :\n" |
| "iwpriv ra0 set TxBfProfileTagWrite =xx (PFMU ID)\n" |
| "When you use one of relative CMD to update one of tag parameters, you should call TxBfProfileTagWrite to update Tag\n" |
| "\n\n" |
| "Read TxBf profile Data :\n" |
| "iwpriv ra0 set TxBfProfileDataRead =xx (PFMU ID)\n" |
| "\n" |
| "Write TxBf profile Data :\n" |
| "iwpriv ra0 set TxBfProfileDataWrite =BW :subcarrier:phi11:psi2l:Phi21:Psi31:Phi31:Psi41:Phi22:Psi32:Phi32:Psi42:Phi33:Psi43\n" |
| "iwpriv ra0 set TxBfProfileDataWriteAll=Profile ID : BW (BW : 0x00 (20M) , 0x01 (40M), 0x02 (80M), 0x3 (160M)\n" |
| "When you use CMD TxBfProfileDataWrite to update profile data per subcarrier, you should call TxBfProfileDataWriteAll to update all of\n" |
| "subcarrier's profile data.\n\n" |
| "Read TxBf profile PN :\n" |
| "iwpriv ra0 set TxBfProfilePnRead =xx (PFMU ID)\n" |
| "\n" |
| "Write TxBf profile PN :\n" |
| "iwpriv ra0 set TxBfProfilePnWrite =Profile ID:BW:1STS_Tx0:1STS_Tx1:1STS_Tx2:1STS_Tx3:2STS_Tx0:2STS_Tx1:2STS_Tx2:2STS_Tx3:3STS_Tx1:3STS_Tx2:3STS_Tx3\n" |
| "========================================================================================================================\n"); |
| return 0; |
| } |
| |
| int Set_TxBfProfileTag_InValid(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucInValid; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_InValid\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucInValid); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_InValid prInBuf = %s, ucInValid = %d\n", prInBuf, |
| ucInValid); |
| i4Status = TxBfProfileTag_InValid(prNetDev, &g_rPfmuTag1, ucInValid); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_PfmuIdx(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucProfileIdx; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_PfmuIdx\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucProfileIdx); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_PfmuIdx prInBuf = %s, ucProfileIdx = %d\n", prInBuf, |
| ucProfileIdx); |
| i4Status = TxBfProfileTag_PfmuIdx(prNetDev, &g_rPfmuTag1, ucProfileIdx); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_BfType(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucBFType; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_BfType\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucBFType); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_BfType prInBuf = %s, ucBFType = %d\n", |
| prInBuf, ucBFType); |
| i4Status = TxBfProfileTag_TxBfType(prNetDev, &g_rPfmuTag1, ucBFType); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_DBW(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucBW; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DBW\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucBW); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DBW prInBuf = %s, ucBW = %d\n", prInBuf, ucBW); |
| i4Status = TxBfProfileTag_DBW(prNetDev, &g_rPfmuTag1, ucBW); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_SuMu(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucSuMu; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_SuMu\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucSuMu); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_SuMu prInBuf = %s, ucSuMu = %d\n", prInBuf, ucSuMu); |
| i4Status = TxBfProfileTag_SuMu(prNetDev, &g_rPfmuTag1, ucSuMu); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_Mem(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 aucInput[8]; |
| INT_32 i4Status = 0; |
| UINT_8 aucMemAddrColIdx[4], aucMemAddrRowIdx[4]; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_Mem\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d:%d:%d:%d:%d:%d:%d", |
| &aucInput[0], &aucInput[1], &aucInput[2], &aucInput[3], &aucInput[4], &aucInput[5], &aucInput[6], |
| &aucInput[7]); |
| /* mem col0:row0:col1:row1:col2:row2:col3:row3 */ |
| if (rv == 8) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 : ATE_AGENT iwpriv Set_TxBfProfileTag_Mem aucInput:%d:%d:%d:%d:%d:%d:%d:%d\n", |
| aucInput[0], aucInput[1], aucInput[2], aucInput[3], aucInput[4], aucInput[5], aucInput[6], |
| aucInput[7]); |
| |
| aucMemAddrColIdx[0] = (UINT_8) aucInput[0]; |
| aucMemAddrRowIdx[0] = (UINT_8) aucInput[1]; |
| aucMemAddrColIdx[1] = (UINT_8) aucInput[2]; |
| aucMemAddrRowIdx[1] = (UINT_8) aucInput[3]; |
| aucMemAddrColIdx[2] = (UINT_8) aucInput[4]; |
| aucMemAddrRowIdx[2] = (UINT_8) aucInput[5]; |
| aucMemAddrColIdx[3] = (UINT_8) aucInput[6]; |
| aucMemAddrRowIdx[3] = (UINT_8) aucInput[7]; |
| |
| i4Status = TxBfProfileTag_Mem(prNetDev, &g_rPfmuTag1, aucMemAddrColIdx, aucMemAddrRowIdx); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_Matrix(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 aucInput[6]; |
| UINT_8 ucNrow, ucNcol, ucNgroup, ucLM, ucCodeBook, ucHtcExist; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_Matrix\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d:%d:%d:%d:%d", |
| &aucInput[0], &aucInput[1], &aucInput[2], &aucInput[3], &aucInput[4], &aucInput[5]); |
| /* nrow:nol:ng:LM:CodeBook:HtcExist */ |
| if (rv == 6) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 : ATE_AGENT iwpriv Set_TxBfProfileTag_Matrix aucInput:%d:%d:%d:%d:%d:%d\n", |
| aucInput[0], aucInput[1], aucInput[2], aucInput[3], aucInput[4], aucInput[5]); |
| ucNrow = (UINT_8) aucInput[0]; |
| ucNcol = (UINT_8) aucInput[1]; |
| ucNgroup = (UINT_8) aucInput[2]; |
| ucLM = (UINT_8) aucInput[3]; |
| ucCodeBook = (UINT_8) aucInput[4]; |
| ucHtcExist = (UINT_8) aucInput[5]; |
| |
| i4Status = TxBfProfileTag_Matrix(prNetDev, |
| &g_rPfmuTag1, ucNrow, ucNcol, ucNgroup, ucLM, ucCodeBook, ucHtcExist); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_SNR(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 aucInput[4]; |
| UINT_8 ucSNR_STS0, ucSNR_STS1, ucSNR_STS2, ucSNR_STS3; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_SNR\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d:%d:%d", &aucInput[0], &aucInput[1], &aucInput[2], &aucInput[3]); |
| if (rv == 4) { |
| DBGLOG(RFTEST, ERROR, "MT6632 : ATE_AGENT iwpriv Set_TxBfProfileTag_SNR aucInput:%d:%d:%d:%d\n", |
| aucInput[0], aucInput[1], aucInput[2], aucInput[3]); |
| |
| ucSNR_STS0 = (UINT_8) aucInput[0]; |
| ucSNR_STS1 = (UINT_8) aucInput[1]; |
| ucSNR_STS2 = (UINT_8) aucInput[2]; |
| ucSNR_STS3 = (UINT_8) aucInput[3]; |
| |
| i4Status = TxBfProfileTag_SNR(prNetDev, &g_rPfmuTag1, ucSNR_STS0, ucSNR_STS1, ucSNR_STS2, ucSNR_STS3); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_SmartAnt(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status = 0; |
| UINT_32 ucSmartAnt; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_SmartAnt\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucSmartAnt); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_SmartAnt prInBuf = %s, ucSmartAnt = %d\n", prInBuf, |
| ucSmartAnt); |
| i4Status = TxBfProfileTag_SmtAnt(prNetDev, &g_rPfmuTag2, ucSmartAnt); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_SeIdx(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status = 0; |
| UINT_32 ucSeIdx; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_SeIdx\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucSeIdx); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfProfileTag_SeIdx prInBuf = %s, ucSeIdx = %d\n", prInBuf, ucSeIdx); |
| i4Status = TxBfProfileTag_SeIdx(prNetDev, &g_rPfmuTag2, ucSeIdx); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_RmsdThrd(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status = 0; |
| UINT_32 ucRmsdThrd; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_RmsdThrd\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucRmsdThrd); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_RmsdThrd prInBuf = %s, ucRmsdThrd = %d\n", prInBuf, |
| ucRmsdThrd); |
| i4Status = TxBfProfileTag_RmsdThd(prNetDev, &g_rPfmuTag2, ucRmsdThrd); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_McsThrd(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 aucInput[6]; |
| UINT_8 ucMcsLss[3], ucMcsSss[3]; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_McsThrd\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d:%d:%d:%d:%d", |
| &aucInput[0], &aucInput[1], &aucInput[2], &aucInput[3], &aucInput[4], &aucInput[5]); |
| if (rv == 6) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 : ATE_AGENT iwpriv Set_TxBfProfileTag_McsThrd aucInput:%d:%d:%d:%d:%d:%d\n", |
| aucInput[0], aucInput[1], aucInput[2], aucInput[3], aucInput[4], aucInput[5]); |
| |
| ucMcsLss[0] = (UINT_8) aucInput[0]; |
| ucMcsSss[0] = (UINT_8) aucInput[1]; |
| ucMcsLss[1] = (UINT_8) aucInput[2]; |
| ucMcsSss[1] = (UINT_8) aucInput[3]; |
| ucMcsLss[2] = (UINT_8) aucInput[4]; |
| ucMcsSss[2] = (UINT_8) aucInput[5]; |
| |
| i4Status = TxBfProfileTag_McsThd(prNetDev, &g_rPfmuTag2, ucMcsLss, ucMcsSss); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_TimeOut(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucTimeOut; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_TimeOut\n"); |
| |
| rv = kstrtouint(prInBuf, 0, &ucTimeOut); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_TimeOut prInBuf = %s, ucTimeOut = %d\n", prInBuf, |
| ucTimeOut); |
| i4Status = TxBfProfileTag_TimeOut(prNetDev, &g_rPfmuTag2, ucTimeOut); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_DesiredBW(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucDesiredBW; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DesiredBW\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucDesiredBW); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DesiredBW prInBuf = %s, ucDesiredBW = %d\n", prInBuf, |
| ucDesiredBW); |
| i4Status = TxBfProfileTag_DesiredBW(prNetDev, &g_rPfmuTag2, ucDesiredBW); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_DesiredNc(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucDesiredNc; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DesiredNc\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucDesiredNc); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DesiredNc prInBuf = %s, ucDesiredNc = %d\n", prInBuf, |
| ucDesiredNc); |
| i4Status = TxBfProfileTag_DesiredNc(prNetDev, &g_rPfmuTag2, ucDesiredNc); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTag_DesiredNr(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucDesiredNr; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DesiredNr\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucDesiredNr); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTag_DesiredNr prInBuf = %s, ucDesiredNr = %d\n", prInBuf, |
| ucDesiredNr); |
| i4Status = TxBfProfileTag_DesiredNr(prNetDev, &g_rPfmuTag2, ucDesiredNr); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTagWrite(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 profileIdx; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTagWrite\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &profileIdx); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTagWrite prInBuf = %s, profileIdx = %d\n", prInBuf, |
| profileIdx); |
| i4Status = TxBfProfileTagWrite(prNetDev, &g_rPfmuTag1, &g_rPfmuTag2, profileIdx); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileTagRead(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 profileIdx, fgBFer; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileTagRead\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d", &profileIdx, &fgBFer); |
| if (rv == 2) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_TxBfProfileTagRead prInBuf = %s, profileIdx = %d, fgBFer = %d\n", |
| prInBuf, profileIdx, fgBFer); |
| i4Status = TxBfProfileTagRead(prNetDev, profileIdx, fgBFer); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileDataRead(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 profileIdx, fgBFer, subcarrierIdxMsb, subcarrierIdxLsb; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfileDataRead\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d:%x:%x", &profileIdx, &fgBFer, &subcarrierIdxMsb, &subcarrierIdxLsb); |
| if (rv == 4) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_TxBfProfileDataRead prInBuf = %s, profileIdx = %d, fgBFer = %d, subcarrierIdxMsb:%x, subcarrierIdxLsb:%x\n", |
| prInBuf, profileIdx, fgBFer, subcarrierIdxMsb, subcarrierIdxLsb); |
| i4Status = TxBfProfileDataRead(prNetDev, profileIdx, fgBFer, subcarrierIdxMsb, subcarrierIdxLsb); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfileDataWrite(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| |
| UINT_32 u4ProfileIdx; |
| UINT_32 u4SubcarrierIdx; |
| UINT_32 au4Phi[6]; |
| UINT_32 au4Psi[6]; |
| UINT_32 au4DSnr[4]; |
| UINT_16 au2Phi[6]; |
| UINT_8 aucPsi[6]; |
| UINT_8 aucDSnr[4]; |
| UINT_32 i; |
| INT_32 rv; |
| |
| INT_32 i4Status = 0; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfProfileDataWrite\n"); |
| |
| rv = sscanf(prInBuf, "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x", |
| &u4ProfileIdx, &u4SubcarrierIdx, &au4Phi[0], &au4Psi[0], &au4Phi[1], &au4Psi[1], |
| &au4Phi[2], &au4Psi[2], &au4Phi[3], &au4Psi[3], &au4Phi[4], &au4Psi[4], |
| &au4Phi[5], &au4Psi[5], |
| &au4DSnr[0], &au4DSnr[1], &au4DSnr[2], &au4DSnr[3]); |
| |
| if (rv == 18) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 TxBfProfileDataWrite prInBuf = %s, u4ProfileIdx = %x, u4SubcarrierIdx = %x, au4Phi[0]:%x, au4Phi[1]:%x, au4Phi[2]:%x, au4Phi[3]:%x, au4Phi[4]:%x, au4Phi[5]:%x, au4Psi[0]:%x, au4Psi[1]:%x, au4Psi[2]:%x, au4Psi[3]:%x, au4Psi[4]:%x, au4Psi[5]:%x,au4DSnr[0]:%x, au4DSnr[1]:%x, au4DSnr[2]:%x, au4DSnr[3]:%x\n", |
| prInBuf, u4ProfileIdx, u4SubcarrierIdx, |
| au4Phi[0], au4Phi[1], au4Phi[2], au4Phi[3], au4Phi[4], au4Phi[5], |
| au4Psi[0], au4Psi[1], au4Psi[2], au4Psi[3], au4Psi[4], au4Psi[5], |
| au4DSnr[0], au4DSnr[1], au4DSnr[2], au4DSnr[3]); |
| for (i = 0; i < 6; i++) { |
| au2Phi[i] = au4Phi[i]; |
| aucPsi[i] = au4Psi[i]; |
| } |
| for (i = 0; i < 4; i++) |
| aucDSnr[i] = au4DSnr[i]; |
| |
| i4Status = TxBfProfileDataWrite(prNetDev, u4ProfileIdx, u4SubcarrierIdx, au2Phi, aucPsi, aucDSnr); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfilePnRead(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 profileIdx; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfilePnRead\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &profileIdx); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_TxBfProfilePnRead prInBuf = %s, profileIdx = %d\n", |
| prInBuf, profileIdx); |
| i4Status = TxBfProfilePnRead(prNetDev, profileIdx); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfProfilePnWrite(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucProfileIdx; |
| UINT_16 u2bw; |
| UINT_16 au2XSTS[12]; |
| INT_32 rv; |
| |
| INT_32 i4Status = 0; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfProfilePnWrite\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", |
| &ucProfileIdx, &u2bw, &au2XSTS[0], &au2XSTS[1], &au2XSTS[2], &au2XSTS[3], |
| &au2XSTS[4], &au2XSTS[5], &au2XSTS[6], &au2XSTS[7], &au2XSTS[8], &au2XSTS[9], &au2XSTS[10], |
| &au2XSTS[11]); |
| if (rv == 14) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 TxBfProfilePnWrite prInBuf = %s, ucProfileIdx = %d, u2bw = %dau2XSTS[0]:%d, au2XSTS[1]:%d, au2XSTS[2]:%d, au2XSTS[3]:%d, au2XSTS[4]:%d, au2XSTS[5]:%d, au2XSTS[6]:%d, au2XSTS[7]:%d, au2XSTS[8]:%d, au2XSTS[9]:%d, au2XSTS[10]:%d, au2XSTS[11]:%d\n", |
| ucProfileIdx, u2bw, au2XSTS[0], au2XSTS[1], au2XSTS[2], au2XSTS[3], au2XSTS[4], au2XSTS[5], |
| au2XSTS[6], au2XSTS[7], au2XSTS[8], au2XSTS[9], au2XSTS[10], au2XSTS[11]); |
| i4Status = TxBfProfilePnWrite(prNetDev, ucProfileIdx, u2bw, au2XSTS); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /* Su_Mu:NumSta:SndInterval:WLan0:WLan1:WLan2:WLan3 */ |
| int Set_Trigger_Sounding_Proc(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucSuMu, ucNumSta, ucSndInterval, ucWLan0, ucWLan1, ucWLan2, ucWLan3; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_Trigger_Sounding_Proc\n"); |
| |
| rv = sscanf |
| (prInBuf, "%x:%x:%x:%x:%x:%x:%x", &ucSuMu, &ucNumSta, &ucSndInterval, &ucWLan0, &ucWLan1, &ucWLan2, |
| &ucWLan3); |
| if (rv == 7) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_Trigger_Sounding_Proc prInBuf = %s, ucSuMu = %d, ucNumSta = %d, ucSndInterval = %d, ucWLan0 = %d, ucWLan1 = %d, ucWLan2:%d, ucWLan3:%d\n", |
| ucSuMu, ucNumSta, ucSndInterval, ucWLan0, ucWLan1, ucWLan2, ucWLan3); |
| i4Status = TxBfSounding(prNetDev, ucSuMu, ucNumSta, ucSndInterval, ucWLan0, ucWLan1, ucWLan2, ucWLan3); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_Stop_Sounding_Proc(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status = 0; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_Stop_Sounding_Proc\n"); |
| |
| i4Status = TxBfSoundingStop(prNetDev); |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfTxApply(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 u4WlanId, u4ETxBf, u4ITxBf, u4MuTxBf; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfTxApply\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d:%d:%d", &u4WlanId, &u4ETxBf, &u4ITxBf, &u4MuTxBf); |
| if (rv == 4) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 TxBfTxApply prInBuf = %s, u4WlanId = %d, u4ETxBf = %d, u4ITxBf = %d, u4MuTxBf = %d\n", |
| prInBuf, u4WlanId, u4ETxBf, u4ITxBf, u4MuTxBf); |
| i4Status = TxBfTxApply(prNetDev, u4WlanId, u4ETxBf, u4ITxBf, u4MuTxBf); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfManualAssoc(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 au4Mac[MAC_ADDR_LEN]; |
| INT_32 u4Type, u4Wtbl, u4Ownmac, u4PhyMode, u4Bw, u4Nss, u4PfmuId, u4Mode, u4Marate, u4SpeIdx, ucaid, u4Rv; |
| INT_8 aucMac[MAC_ADDR_LEN]; |
| INT_32 i4Status = 0; |
| INT_32 i = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfManualAssoc\n"); |
| |
| rv = sscanf(prInBuf, "%x:%x:%x:%x:%x:%x:%x:%d:%x:%x:%x:%x:%d:%x:%x:%x:%d:%x", |
| &au4Mac[0], &au4Mac[1], &au4Mac[2], &au4Mac[3], &au4Mac[4], &au4Mac[5], |
| &u4Type, &u4Wtbl, &u4Ownmac, &u4PhyMode, &u4Bw, &u4Nss, &u4PfmuId, &u4Mode, &u4Marate, &u4SpeIdx, |
| &ucaid, &u4Rv); |
| if (rv == 18) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 TxBfManualAssoc au4Mac[0] = %x, au4Mac[1] = %x, au4Mac[2] = %xau4Mac[3] = %x, au4Mac[4] = %x, au4Mac[5] = %x, u4Type = %x, u4Wtbl = %d, u4Ownmac = %x, u4PhyMode = %x u4Bw = %x, u4Nss = %x, u4PfmuId = %d, u4Mode = %x, u4Marate = %x, u4SpeIdx = %d, ucaid = %d, u4Rv = %x", |
| au4Mac[0], au4Mac[1], au4Mac[2], au4Mac[3], au4Mac[4], au4Mac[5], u4Type, u4Wtbl, u4Ownmac, |
| u4PhyMode, u4Bw, u4Nss, u4PfmuId, u4Mode, u4Marate, u4SpeIdx, ucaid, u4Rv); |
| for (i = 0; i < MAC_ADDR_LEN; i++) |
| aucMac[i] = au4Mac[i]; |
| |
| i4Status = |
| TxBfManualAssoc(prNetDev, aucMac, u4Type, u4Wtbl, u4Ownmac, u4Mode, u4Bw, u4Nss, u4PfmuId, u4Marate, |
| u4SpeIdx, ucaid, u4Rv); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfPfmuMemAlloc(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucSuMuMode, ucWlanIdx; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfPfmuMemAlloc\n"); |
| |
| rv = sscanf(prInBuf, "%d:%d", &ucSuMuMode, &ucWlanIdx); |
| if (rv == 2) { |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfPfmuMemAlloc ucSuMuMode = %d, ucWlanIdx = %d", ucSuMuMode, ucWlanIdx); |
| i4Status = TxBfPfmuMemAlloc(prNetDev, ucSuMuMode, ucWlanIdx); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_TxBfPfmuMemRelease(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 ucWlanId; |
| INT_32 i4Status = 0; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfPfmuMemRelease\n"); |
| |
| rv = kstrtoint(prInBuf, 0, &ucWlanId); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 TxBfPfmuMemRelease ucWlanId = %d", ucWlanId); |
| i4Status = TxBfPfmuMemRelease(prNetDev, ucWlanId); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_DevInfoUpdate(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 u4OwnMacIdx, fgBand; |
| UINT_32 OwnMacAddr[MAC_ADDR_LEN]; |
| UINT_8 aucMacAddr[MAC_ADDR_LEN]; |
| INT_32 i4Status = 0; |
| UINT_32 i; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 DevInfoUpdate\n"); |
| |
| rv = sscanf |
| (prInBuf, "%d:%x:%x:%x:%x:%x:%x:%d", &u4OwnMacIdx, &OwnMacAddr[0], &OwnMacAddr[1], &OwnMacAddr[2], |
| &OwnMacAddr[3], &OwnMacAddr[4], &OwnMacAddr[5], &fgBand); |
| if (rv == 8) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 DevInfoUpdate prInBuf = %s, u4OwnMacIdx = %x, fgBand = %x,OwnMacAddr[0]:%x, OwnMacAddr[1]:%x, OwnMacAddr[2]:%x, OwnMacAddr[3]:%x, OwnMacAddr[4]:%x, OwnMacAddr[5]:%x,", |
| prInBuf, u4OwnMacIdx, fgBand, OwnMacAddr[0], OwnMacAddr[1], OwnMacAddr[2], OwnMacAddr[3], |
| OwnMacAddr[4], OwnMacAddr[5]); |
| for (i = 0; i < MAC_ADDR_LEN; i++) |
| aucMacAddr[i] = OwnMacAddr[i]; |
| |
| i4Status = DevInfoUpdate(prNetDev, u4OwnMacIdx, fgBand, aucMacAddr); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_BssInfoUpdate(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 u4OwnMacIdx, u4BssIdx; |
| UINT_32 au4BssId[MAC_ADDR_LEN]; |
| UINT_8 aucBssId[MAC_ADDR_LEN]; |
| INT_32 i4Status = 0; |
| UINT_32 i; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 BssInfoUpdate\n"); |
| |
| rv = sscanf |
| (prInBuf, "%d:%d:%x:%x:%x:%x:%x:%x", &u4OwnMacIdx, &u4BssIdx, &au4BssId[0], &au4BssId[1], &au4BssId[2], |
| &au4BssId[3], &au4BssId[4], &au4BssId[5]); |
| if (rv == 8) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 BssInfoUpdate prInBuf = %s, u4OwnMacIdx = %x, u4BssIdx = %x,au4BssId[0]:%x, au4BssId[1]:%x, au4BssId[2]:%x, au4BssId[3]:%x, au4BssId[4]:%x, au4BssId[5]:%x,", |
| prInBuf, u4OwnMacIdx, u4BssIdx, au4BssId[0], au4BssId[1], au4BssId[2], au4BssId[3], au4BssId[4], |
| au4BssId[5]); |
| for (i = 0; i < MAC_ADDR_LEN; i++) |
| aucBssId[i] = au4BssId[i]; |
| |
| i4Status = BssInfoUpdate(prNetDev, u4OwnMacIdx, u4BssIdx, aucBssId); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_StaRecCmmUpdate(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| UINT_32 u4WlanId, u4BssId, u4Aid; |
| UINT_32 au4MacAddr[MAC_ADDR_LEN]; |
| UINT_8 aucMacAddr[MAC_ADDR_LEN]; |
| INT_32 i4Status = 0; |
| UINT_32 i; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_StaRecCmmUpdate\n"); |
| |
| rv = sscanf |
| (prInBuf, "%x:%x:%x:%x:%x:%x:%x:%x:%x", &u4WlanId, &u4BssId, &u4Aid, &au4MacAddr[0], &au4MacAddr[1], |
| &au4MacAddr[2], &au4MacAddr[3], &au4MacAddr[4], &au4MacAddr[5]); |
| if (rv == 9) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_StaRecCmmUpdate prInBuf = %s, u4WlanId = %x, u4BssId = %x, u4Aid = %x,aucMacAddr[0]:%x, aucMacAddr[1]:%x, aucMacAddr[2]:%x, aucMacAddr[3]:%x, aucMacAddr[4]:%x, aucMacAddr[5]:%x,", |
| prInBuf, u4WlanId, u4BssId, u4Aid, au4MacAddr[0], au4MacAddr[1], au4MacAddr[2], au4MacAddr[3], |
| au4MacAddr[4], au4MacAddr[5]); |
| for (i = 0; i < MAC_ADDR_LEN; i++) |
| aucMacAddr[i] = au4MacAddr[i]; |
| |
| i4Status = StaRecCmmUpdate(prNetDev, u4WlanId, u4BssId, u4Aid, aucMacAddr); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_StaRecBfUpdate(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| STA_REC_BF_UPD_ARGUMENT rStaRecBfUpdArg; |
| UINT_8 aucMemRow[4], aucMemCol[4]; |
| INT_32 i4Status = 0; |
| UINT_32 i; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_StaRecBfUpdate\n"); |
| |
| rv = sscanf(prInBuf, "%x:%x:%x:%x:%x:%d:%d:%d:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x", |
| &rStaRecBfUpdArg.u4WlanId, &rStaRecBfUpdArg.u4BssId, &rStaRecBfUpdArg.u4PfmuId, |
| &rStaRecBfUpdArg.u4SuMu, &rStaRecBfUpdArg.u4eTxBfCap, &rStaRecBfUpdArg.u4NdpaRate, |
| &rStaRecBfUpdArg.u4NdpRate, &rStaRecBfUpdArg.u4ReptPollRate, &rStaRecBfUpdArg.u4TxMode, |
| &rStaRecBfUpdArg.u4Nc, &rStaRecBfUpdArg.u4Nr, &rStaRecBfUpdArg.u4Bw, &rStaRecBfUpdArg.u4SpeIdx, |
| &rStaRecBfUpdArg.u4TotalMemReq, &rStaRecBfUpdArg.u4MemReq20M, &rStaRecBfUpdArg.au4MemRow[0], |
| &rStaRecBfUpdArg.au4MemCol[0], &rStaRecBfUpdArg.au4MemRow[1], &rStaRecBfUpdArg.au4MemCol[1], |
| &rStaRecBfUpdArg.au4MemRow[2], &rStaRecBfUpdArg.au4MemCol[2], &rStaRecBfUpdArg.au4MemRow[3], |
| &rStaRecBfUpdArg.au4MemCol[3]); |
| if (rv == 23) { |
| /* |
| *DBGLOG(RFTEST, ERROR, |
| *"MT6632 Set_StaRecBfUpdate prInBuf = %s, u4WlanId = %x, u4BssId = %x, u4Aid = %x, |
| * aucMacAddr[0]:%x, aucMacAddr[1]:%x, aucMacAddr[2]:%x, aucMacAddr[3]:%x, aucMacAddr[4]:%x, |
| * aucMacAddr[5]:%x", |
| * prInBuf, u4OwnMacIdx, u4BssIdx, u4Aid, |
| * aucMacAddr[0], aucMacAddr[1], aucMacAddr[2], aucMacAddr[3], aucMacAddr[4], aucMacAddr[5]); |
| */ |
| for (i = 0; i < 4; i++) { |
| aucMemRow[i] = rStaRecBfUpdArg.au4MemRow[i]; |
| aucMemCol[i] = rStaRecBfUpdArg.au4MemCol[i]; |
| } |
| i4Status = StaRecBfUpdate(prNetDev, rStaRecBfUpdArg, aucMemRow, aucMemCol); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| #if CFG_SUPPORT_MU_MIMO |
| int Set_MUGetInitMCS(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4groupIdx; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUGetInitMCS\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| rv = kstrtouint(prInBuf, 0, &u4groupIdx); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Test\n"); |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUGetInitMCS prInBuf = %s, u4groupIdx = %x", prInBuf, u4groupIdx); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_GET_CALC_INIT_MCS; |
| rMuMimoActionInfo.unMuMimoParam.rMuGetCalcInitMcs.ucgroupIdx = u4groupIdx; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), TRUE, TRUE, TRUE, &u4BufLen); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_MUCalInitMCS(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4NumOfUser, u4Bandwidth, u4NssOfUser0, u4NssOfUser1, u4PfMuIdOfUser0, u4PfMuIdOfUser1, u4NumOfTxer, |
| u4SpeIndex, u4GroupIndex; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUCalInitMCS\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| rv = sscanf |
| (prInBuf, "%x:%x:%x:%x:%x:%x:%x:%x:%x", &u4NumOfUser, &u4Bandwidth, &u4NssOfUser0, &u4NssOfUser1, |
| &u4PfMuIdOfUser0, &u4PfMuIdOfUser1, &u4NumOfTxer, &u4SpeIndex, &u4GroupIndex); |
| if (rv == 9) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_MUCalInitMCS prInBuf = %s, u4NumOfUser = %x, u4Bandwidth = %x, u4NssOfUser0 = %x, u4NssOfUser1 = %x, u4PfMuIdOfUser0 = %x, u4PfMuIdOfUser1 = %x, u4NumOfTxer = %x, u4SpeIndex = %x, u4GroupIndex = %x", |
| prInBuf, u4NumOfUser, u4Bandwidth, u4NssOfUser0, u4NssOfUser1, u4PfMuIdOfUser0, u4PfMuIdOfUser1, |
| u4NumOfTxer, u4SpeIndex, u4GroupIndex); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_SET_CALC_INIT_MCS; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucNumOfUser = u4NumOfUser; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucBandwidth = u4Bandwidth; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucNssOfUser0 = u4NssOfUser0; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucNssOfUser1 = u4NssOfUser1; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucPfMuIdOfUser0 = u4PfMuIdOfUser0; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucPfMuIdOfUser1 = u4PfMuIdOfUser1; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucNumOfTxer = u4NumOfTxer; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.ucSpeIndex = u4SpeIndex; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetInitMcs.u4GroupIndex = u4GroupIndex; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_MUCalLQ(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4NumOfUser, u4Bandwidth, u4NssOfUser0, u4NssOfUser1, u4PfMuIdOfUser0, u4PfMuIdOfUser1, |
| u4NumOfTxer, u4SpeIndex, u4GroupIndex; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUCalLQ\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| rv = sscanf |
| (prInBuf, "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x", &u4NumOfUser, &u4Bandwidth, &u4NssOfUser0, &u4NssOfUser1, |
| &u4PfMuIdOfUser0, &u4PfMuIdOfUser1, &u4NumOfTxer, &u4SpeIndex, &u4GroupIndex); |
| if (rv == 9) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_MUCalLQ prInBuf = %s, u4NumOfUser = %x, u4Bandwidth = %x, u4NssOfUser0 = %x, u4NssOfUser1 = %x, u4PfMuIdOfUser0 = %x, u4PfMuIdOfUser1 = %x, u4NumOfTxer = %x, u4SpeIndex = %x, u4GroupIndex = %x", |
| prInBuf, u4NumOfUser, u4Bandwidth, u4NssOfUser0, u4NssOfUser1, u4PfMuIdOfUser0, u4PfMuIdOfUser1, |
| u4NumOfTxer, u4SpeIndex, u4GroupIndex); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_CALC_LQ; |
| /* rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucType = u4Type; */ |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucNumOfUser = u4NumOfUser; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucBandwidth = u4Bandwidth; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucNssOfUser0 = u4NssOfUser0; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucNssOfUser1 = u4NssOfUser1; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucPfMuIdOfUser0 = u4PfMuIdOfUser0; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucPfMuIdOfUser1 = u4PfMuIdOfUser1; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucNumOfTxer = u4NumOfTxer; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.ucSpeIndex = u4SpeIndex; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetCalcLq.u4GroupIndex = u4GroupIndex; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_MUGetLQ(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| /* UINT_32 u4Type; */ |
| UINT_32 u4BufLen = 0; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUGetLQ\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| /* if (sscanf(prInBuf, "%x", &u4Type) == 1) */ |
| /* { */ |
| /* DBGLOG(RFTEST, ERROR, "MT6632 Set_MUGetLQ prInBuf = %s, u4Type = %x", prInBuf, u4Type); */ |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_GET_CALC_LQ; |
| /* rMuMimoActionInfo.unMuMimoParam.rMuGetLq.ucType = u4Type; */ |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), TRUE, TRUE, TRUE, &u4BufLen); |
| /* } */ |
| /* else */ |
| /* { */ |
| /* return -EINVAL; */ |
| /* } */ |
| |
| return i4Status; |
| } |
| |
| int Set_MUSetSNROffset(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4Val; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetSNROffset\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| rv = kstrtoint(prInBuf, 0, &u4Val); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetSNROffset prInBuf = %s, u4Val = %x", prInBuf, u4Val); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_SNR_OFFSET; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetSnrOffset.ucVal = u4Val; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_MUSetZeroNss(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4Val; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetZeroNss\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| rv = kstrtouint(prInBuf, 0, &u4Val); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetZeroNss prInBuf = %s, u4Val = %x", prInBuf, u4Val); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_ZERO_NSS; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetZeroNss.ucVal = u4Val; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_MUSetSpeedUpLQ(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4Val; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetSpeedUpLQ\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| rv = kstrtouint(prInBuf, 0, &u4Val); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetSpeedUpLQ prInBuf = %s, u4Val = %x", prInBuf, u4Val); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_SPEED_UP_LQ; |
| rMuMimoActionInfo.unMuMimoParam.rMuSpeedUpLq.u4Val = u4Val; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_MUSetMUTable(struct net_device *prNetDev, UINT_8 *prTable) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| /*UINT_32 i; |
| *UINT_32 u4Type, u4Length; |
| */ |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetMUTable\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| /* if (sscanf(prInBuf, "%x:%x", &u4Type, &u4Length) == 2) */ |
| /* { */ |
| /* DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetMUTable prInBuf = %s, */ |
| /* u4Type = %x, u4Length = %x", prInBuf, u4Type, u4Length); */ |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_MU_TABLE; |
| /* rMuMimoActionInfo.unMuMimoParam.rMuSetMuTable.u2Type = u4Type; */ |
| /* rMuMimoActionInfo.unMuMimoParam.rMuSetMuTable.u4Length = u4Length; */ |
| |
| /* for ( i = 0 ; i < NUM_MUT_NR_NUM * NUM_MUT_FEC * NUM_MUT_MCS * NUM_MUT_INDEX ; i++) */ |
| /* { */ |
| memcpy(rMuMimoActionInfo.unMuMimoParam.rMuSetMuTable.aucMetricTable, prTable, |
| NUM_MUT_NR_NUM * NUM_MUT_FEC * NUM_MUT_MCS * NUM_MUT_INDEX); |
| /* } */ |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| /* } */ |
| /* else */ |
| /* { */ |
| /* return -EINVAL; */ |
| /* } */ |
| |
| return i4Status; |
| } |
| |
| int Set_MUSetGroup(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| UINT_32 i = 0; |
| |
| UINT_32 aucUser0MacAddr[PARAM_MAC_ADDR_LEN], aucUser1MacAddr[PARAM_MAC_ADDR_LEN]; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetGroup\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| if (sscanf(prInBuf, "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x", |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4GroupIndex, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4NumOfUser, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0Ldpc, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1Ldpc, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4ShortGI, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4Bw, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0Nss, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1Nss, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4GroupId, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0UP, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1UP, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0MuPfId, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1MuPfId, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0InitMCS, |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1InitMCS, &aucUser0MacAddr[0], |
| &aucUser0MacAddr[1], &aucUser0MacAddr[2], &aucUser0MacAddr[3], &aucUser0MacAddr[4], |
| &aucUser0MacAddr[5], &aucUser1MacAddr[0], &aucUser1MacAddr[1], &aucUser1MacAddr[2], |
| &aucUser1MacAddr[3], &aucUser1MacAddr[4], &aucUser1MacAddr[5]) == 27) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_MUSetGroup prInBuf = %s,u4GroupIndex = %d, u4NumOfUser = %d, u4User0Ldpc = %d, u4User1Ldpc = %d, u4ShortGI = %d, u4Bw = %d, u4User0Nss = %d, u4User1Nss = %d, u4GroupId = %d, u4User0UP = %d, u4User1UP = %d, u4User0MuPfId = %d, u4User1MuPfId = %d, u4User0InitMCS = %d, u4User1InitMCS = %d,aucUser0MacAddr[0] = %x, aucUser0MacAddr[1] = %x, aucUser0MacAddr[2] = %x, aucUser0MacAddr[3] = %x, aucUser0MacAddr[4] = %x, aucUser0MacAddr[5] = %x,aucUser1MacAddr[0] = %x, aucUser1MacAddr[1] = %x, aucUser1MacAddr[2] = %x, aucUser1MacAddr[3] = %x, aucUser1MacAddr[4] = %x, aucUser1MacAddr[5] = %x,", |
| prInBuf, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4GroupIndex, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4NumOfUser, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0Ldpc, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1Ldpc, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4ShortGI, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4Bw, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0Nss, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1Nss, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4GroupId, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0UP, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1UP, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0MuPfId, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1MuPfId, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User0InitMCS, |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.u4User1InitMCS, aucUser0MacAddr[0], |
| aucUser0MacAddr[1], aucUser0MacAddr[2], aucUser0MacAddr[3], aucUser0MacAddr[4], |
| aucUser0MacAddr[5], aucUser1MacAddr[0], aucUser1MacAddr[1], aucUser1MacAddr[2], |
| aucUser1MacAddr[3], aucUser1MacAddr[4], aucUser1MacAddr[5] |
| ); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_GROUP; |
| for (i = 0; i < PARAM_MAC_ADDR_LEN; i++) { |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.aucUser0MacAddr[i] = aucUser0MacAddr[i]; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGroup.aucUser1MacAddr[i] = aucUser1MacAddr[i]; |
| } |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else { |
| return -EINVAL; |
| } |
| |
| return i4Status; |
| } |
| |
| int Set_MUGetQD(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4SubcarrierIndex, u4Length; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUGetQD\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| if (sscanf(prInBuf, "%x:%x", &u4SubcarrierIndex, &u4Length) == 2) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUGetQD prInBuf = %s, u4SubcarrierIndex = %x, u4Length = %x", prInBuf, |
| u4SubcarrierIndex, u4Length); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_GET_QD; |
| rMuMimoActionInfo.unMuMimoParam.rMuGetQd.ucSubcarrierIndex = u4SubcarrierIndex; |
| /* rMuMimoActionInfo.unMuMimoParam.rMuGetQd.u4Length = u4Length; */ |
| /* rMuMimoActionInfo.unMuMimoParam.rMuGetQd.ucgroupIdx = ucgroupIdx; */ |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), TRUE, TRUE, TRUE, &u4BufLen); |
| } else { |
| return -EINVAL; |
| } |
| |
| return i4Status; |
| } |
| |
| int Set_MUSetEnable(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| UINT_32 u4Val; |
| INT_32 rv; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetEnable\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| rv = kstrtouint(prInBuf, 0, &u4Val); |
| if (rv == 0) { |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetEnable prInBuf = %s, u4Val = %x", prInBuf, u4Val); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_ENABLE; |
| rMuMimoActionInfo.unMuMimoParam.rMuSetEnable.ucVal = u4Val; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| int Set_MUSetGID_UP(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUSetGID_UP\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| if (sscanf(prInBuf, "%x:%x:%x:%x:%x:%x", |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Gid[0], |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Gid[1], |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[0], |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[1], |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[2], |
| &rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[3]) == 6) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_MUSetGID_UP prInBuf = %s, au4Gid[0] = %x, au4Gid[1] = %x, au4Up[0] = %x, au4Up[1] = %x, au4Up[2] = %x, au4Up[3] = %x", |
| prInBuf, rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Gid[0], |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Gid[1], |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[0], |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[1], |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[2], |
| rMuMimoActionInfo.unMuMimoParam.rMuSetGidUp.au4Up[3]); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_HQA_SET_STA_PARAM; |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else { |
| return -EINVAL; |
| } |
| |
| return i4Status; |
| } |
| |
| int Set_MUTriggerTx(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| P_GLUE_INFO_T prGlueInfo = NULL; |
| PARAM_CUSTOM_MUMIMO_ACTION_STRUCT_T rMuMimoActionInfo; |
| INT_32 i4Status = 0; |
| UINT_32 u4BufLen = 0; |
| UINT_32 i, j; |
| |
| UINT_32 u4IsRandomPattern, u4MsduPayloadLength0, u4MsduPayloadLength1, u4MuPacketCount, u4NumOfSTAs; |
| UINT_32 au4MacAddrs[2][6]; |
| |
| DBGLOG(RFTEST, ERROR, "MT6632 Set_MUTriggerTx\n"); |
| |
| kalMemZero(&rMuMimoActionInfo, sizeof(rMuMimoActionInfo)); |
| |
| ASSERT(prNetDev); |
| prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev)); |
| |
| if (sscanf(prInBuf, "%d:%x:%x:%x:%d:%d:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x", |
| &u4IsRandomPattern, &u4MsduPayloadLength0, &u4MsduPayloadLength1, &u4MuPacketCount, &u4NumOfSTAs, |
| &au4MacAddrs[0][0], &au4MacAddrs[0][1], &au4MacAddrs[0][2], &au4MacAddrs[0][3], &au4MacAddrs[0][4], |
| &au4MacAddrs[0][5], &au4MacAddrs[1][0], &au4MacAddrs[1][1], &au4MacAddrs[1][2], &au4MacAddrs[1][3], |
| &au4MacAddrs[1][4], &au4MacAddrs[1][5]) == 17) { |
| DBGLOG(RFTEST, ERROR, |
| "MT6632 Set_MUTriggerTx prInBuf = %s, u4IsRandomPattern = %x, u4MsduPayloadLength0 = %x, u4MsduPayloadLength1 = %x, u4MuPacketCount = %x, u4NumOfSTAs = %x, au4MacAddrs[0][0] = %x, au4MacAddrs[0][1] = %x, au4MacAddrs[0][2] = %x, au4MacAddrs[0][3] = %x, au4MacAddrs[0][4] = %x, au4MacAddrs[0][5] = %x,au4MacAddrs[1][0] = %x, au4MacAddrs[1][1] = %x, au4MacAddrs[1][2] = %x, au4MacAddrs[1][3] = %x, au4MacAddrs[1][4] = %x, au4MacAddrs[1][5] = %x", |
| prInBuf, u4IsRandomPattern, u4MsduPayloadLength0, u4MsduPayloadLength1, u4MuPacketCount, |
| u4NumOfSTAs, au4MacAddrs[0][0], au4MacAddrs[0][1], au4MacAddrs[0][2], au4MacAddrs[0][3], |
| au4MacAddrs[0][4], au4MacAddrs[0][5], au4MacAddrs[1][0], au4MacAddrs[1][1], au4MacAddrs[1][2], |
| au4MacAddrs[1][3], au4MacAddrs[1][4], au4MacAddrs[1][5]); |
| |
| rMuMimoActionInfo.ucMuMimoCategory = MU_SET_TRIGGER_MU_TX; |
| rMuMimoActionInfo.unMuMimoParam.rMuTriggerMuTx.fgIsRandomPattern = u4IsRandomPattern; |
| rMuMimoActionInfo.unMuMimoParam.rMuTriggerMuTx.u4MsduPayloadLength0 = u4MsduPayloadLength0; |
| rMuMimoActionInfo.unMuMimoParam.rMuTriggerMuTx.u4MsduPayloadLength1 = u4MsduPayloadLength1; |
| rMuMimoActionInfo.unMuMimoParam.rMuTriggerMuTx.u4MuPacketCount = u4MuPacketCount; |
| rMuMimoActionInfo.unMuMimoParam.rMuTriggerMuTx.u4NumOfSTAs = u4NumOfSTAs; |
| |
| for (i = 0 ; i < 2 ; i++) { |
| for (j = 0 ; j < PARAM_MAC_ADDR_LEN ; j++) |
| rMuMimoActionInfo.unMuMimoParam.rMuTriggerMuTx.aucMacAddrs[i][j] = au4MacAddrs[i][j]; |
| } |
| |
| i4Status = kalIoctl(prGlueInfo, |
| wlanoidMuMimoAction, |
| &rMuMimoActionInfo, sizeof(rMuMimoActionInfo), FALSE, FALSE, TRUE, &u4BufLen); |
| } else { |
| return -EINVAL; |
| } |
| |
| return i4Status; |
| } |
| #endif |
| #endif |
| |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Write Efuse. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int WriteEfuse(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status; |
| INT_32 rv; |
| UINT_32 addr[2]; |
| UINT_16 addr2[2]; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv WriteEfuse, buf: %s\n", prInBuf); |
| |
| rv = sscanf(prInBuf, "%x:%x", &addr[0], &addr[1]); |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv WriteEfuse, prInBuf: %s\n", prInBuf); |
| DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv WriteEfuse :%02x:%02x\n", addr[0], addr[1]); |
| |
| addr2[0] = (UINT_16) addr[0]; |
| addr2[1] = (UINT_16) addr[1]; |
| |
| if (rv == 2) |
| i4Status = MT_ATEWriteEfuse(prNetDev, addr2[0], addr2[1]); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set Tx Power. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetTxTargetPower(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status; |
| INT_32 rv; |
| int addr; |
| UINT_8 addr2; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set Tx Target Power, buf: %s\n", prInBuf); |
| |
| /* rv = sscanf(prInBuf, "%u", &addr);*/ |
| rv = kstrtoint(prInBuf, 0, &addr); |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set Tx Target Power, prInBuf: %s\n", prInBuf); |
| DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv Set Tx Target Power :%02x\n", addr); |
| |
| addr2 = (UINT_8) addr; |
| |
| if (rv == 0) |
| i4Status = MT_ATESetTxTargetPower(prNetDev, addr2); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| #if (CFG_SUPPORT_DFS_MASTER == 1) |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set RDD Report |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetRddReport(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status; |
| INT_32 rv; |
| int dbdcIdx; |
| UINT_8 ucDbdcIdx; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set RDD Report, buf: %s\n", prInBuf); |
| |
| /* rv = sscanf(prInBuf, "%u", &addr);*/ |
| rv = kstrtoint(prInBuf, 0, &dbdcIdx); |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set RDD Report, prInBuf: %s\n", prInBuf); |
| DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv Set RDD Report : Band %d\n", dbdcIdx); |
| |
| if (p2pFuncGetDfsState() == DFS_STATE_INACTIVE || p2pFuncGetDfsState() == DFS_STATE_DETECTED) { |
| DBGLOG(REQ, ERROR, "RDD Report is not supported in this DFS state (inactive or deteted)\n"); |
| return WLAN_STATUS_NOT_SUPPORTED; |
| } |
| |
| if (dbdcIdx != 0 && dbdcIdx != 1) { |
| DBGLOG(REQ, ERROR, "RDD index is not \"0\" or \"1\", Invalid data\n"); |
| return WLAN_STATUS_INVALID_DATA; |
| } |
| |
| ucDbdcIdx = (UINT_8) dbdcIdx; |
| |
| if (rv == 0) |
| i4Status = MT_ATESetRddReport(prNetDev, ucDbdcIdx); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set By Pass CAC. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetByPassCac(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status; |
| INT_32 rv; |
| INT_32 i4ByPassCacTime; |
| UINT_32 u4ByPassCacTime; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set By Pass Cac, buf: %s\n", prInBuf); |
| |
| rv = kstrtoint(prInBuf, 0, &i4ByPassCacTime); |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set By Pass Cac, prInBuf: %s\n", prInBuf); |
| DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv Set By Pass Cac : %dsec\n", i4ByPassCacTime); |
| |
| if (i4ByPassCacTime < 0) { |
| DBGLOG(REQ, ERROR, "Cac time < 0, Invalid data\n"); |
| return WLAN_STATUS_INVALID_DATA; |
| } |
| |
| u4ByPassCacTime = (UINT_32) i4ByPassCacTime; |
| |
| p2pFuncEnableManualCac(); |
| |
| if (rv == 0) |
| i4Status = p2pFuncSetDriverCacTime(u4ByPassCacTime); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to Set Radar Detect Mode. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int SetRadarDetectMode(struct net_device *prNetDev, UINT_8 *prInBuf) |
| { |
| INT_32 i4Status; |
| INT_32 rv; |
| int radarDetectMode; |
| UINT_8 ucRadarDetectMode; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set Radar Detect Mode, buf: %s\n", prInBuf); |
| |
| rv = kstrtoint(prInBuf, 0, &radarDetectMode); |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set Radar Detect Mode, prInBuf: %s\n", prInBuf); |
| DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv Set Radar Detect Mode : %d\n", radarDetectMode); |
| |
| if (p2pFuncGetDfsState() == DFS_STATE_INACTIVE || p2pFuncGetDfsState() == DFS_STATE_DETECTED) { |
| DBGLOG(REQ, ERROR, "RDD Report is not supported in this DFS state (inactive or deteted)\n"); |
| return WLAN_STATUS_NOT_SUPPORTED; |
| } |
| |
| if (radarDetectMode != 0 && radarDetectMode != 1) { |
| DBGLOG(REQ, ERROR, "Radar Detect Mode is not \"0\" or \"1\", Invalid data\n"); |
| return WLAN_STATUS_INVALID_DATA; |
| } |
| |
| ucRadarDetectMode = (UINT_8) radarDetectMode; |
| |
| p2pFuncSetRadarDetectMode(ucRadarDetectMode); |
| |
| if (rv == 0) |
| i4Status = MT_ATESetRadarDetectMode(prNetDev, ucRadarDetectMode); |
| else |
| return -EINVAL; |
| |
| return i4Status; |
| } |
| |
| #endif |
| |
| /*----------------------------------------------------------------------------*/ |
| /*! |
| * \brief This routine is called to search the corresponding ATE agent function. |
| * |
| * \param[in] prNetDev Pointer to the Net Device |
| * \param[in] prInBuf A pointer to the command string buffer |
| * \param[in] u4InBufLen The length of the buffer |
| * \param[out] None |
| * |
| * \retval 0 On success. |
| * \retval -EINVAL If invalid argument. |
| */ |
| /*----------------------------------------------------------------------------*/ |
| int AteCmdSetHandle(struct net_device *prNetDev, UINT_8 *prInBuf, UINT_32 u4InBufLen) |
| { |
| UINT_8 *this_char, *value; |
| P_ATE_PRIV_CMD prAtePrivCmd; |
| INT_32 i4Status = 0; |
| |
| while ((this_char = strsep((char **)&prInBuf, ",")) != NULL) { |
| if (!*this_char) |
| continue; |
| DBGLOG(RFTEST, ERROR, "MT6632 : ATE_AGENT iwpriv this_char = %s\n", this_char); |
| DBGLOG(RFTEST, INFO, "MT6632 : ATE_AGENT iwpriv this_char = %s\n", this_char); |
| |
| value = strchr(this_char, '='); |
| if (value != NULL) |
| *value++ = 0; |
| |
| DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv cmd = %s, value = %s\n", this_char, value); |
| |
| for (prAtePrivCmd = rAtePrivCmdTable; prAtePrivCmd->name; prAtePrivCmd++) { |
| if (!strcmp(this_char, prAtePrivCmd->name)) { |
| /*FALSE:Set private failed then return Invalid argument */ |
| if (prAtePrivCmd->set_proc(prNetDev, value) != 0) |
| i4Status = -EINVAL; |
| break; /*Exit for loop. */ |
| } |
| } |
| |
| if (prAtePrivCmd->name == NULL) { /*Not found argument */ |
| i4Status = -EINVAL; |
| break; |
| } |
| } |
| return i4Status; |
| } |
| #endif /*CFG_SUPPORT_QA_TOOL */ |
