summaryrefslogtreecommitdiff
path: root/cleopatre/devkit/mt7601udrv/ate/common/rt_qa.c
diff options
context:
space:
mode:
Diffstat (limited to 'cleopatre/devkit/mt7601udrv/ate/common/rt_qa.c')
-rw-r--r--cleopatre/devkit/mt7601udrv/ate/common/rt_qa.c2497
1 files changed, 2497 insertions, 0 deletions
diff --git a/cleopatre/devkit/mt7601udrv/ate/common/rt_qa.c b/cleopatre/devkit/mt7601udrv/ate/common/rt_qa.c
new file mode 100644
index 0000000000..0f5dde5e9c
--- /dev/null
+++ b/cleopatre/devkit/mt7601udrv/ate/common/rt_qa.c
@@ -0,0 +1,2497 @@
+/*
+ ***************************************************************************
+ * Ralink Tech Inc.
+ * 4F, No. 2 Technology 5th Rd.
+ * Science-based Industrial Park
+ * Hsin-chu, Taiwan, R.O.C.
+ *
+ * (c) Copyright 2002-2010, Ralink Technology, Inc.
+ *
+ * All rights reserved. Ralink's 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 Ralink Tech. 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 Ralink Technology, Inc. is obtained.
+ ***************************************************************************
+
+ Module Name:
+ rt_qa.c
+
+ Abstract:
+
+ Revision History:
+ Who When What
+ -------- ---------- ----------------------------------------------
+ Name Date Modification logs
+*/
+#include "rt_config.h"
+
+#ifdef RALINK_QA
+NDIS_STATUS TXSTOP(
+ IN PRTMP_ADAPTER pAd)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ UINT32 MacData=0, atemode=0;
+ NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
+ UCHAR BbpData = 0;
+
+ DBGPRINT(RT_DEBUG_TRACE, ("ATE : ===> %s\n", __FUNCTION__));
+
+ atemode = pATEInfo->Mode;
+ pATEInfo->Mode &= ATE_TXSTOP;
+ pATEInfo->bQATxStart = FALSE;
+
+ if (atemode == ATE_TXCARR)
+ {
+ if (pATEInfo->TxMethod == TX_METHOD_0)
+ {
+ /* No Carrier Test set BBP R22 bit7=0, bit6=0, bit[5~0]=0x0 */
+ ATE_BBP_RESET_TX_MODE(pAd, BBP_R22, &BbpData);
+ }
+ }
+ else if (atemode == ATE_TXCARRSUPP)
+ {
+ if (pATEInfo->TxMethod == TX_METHOD_0)
+ {
+ /* No Cont. TX set BBP R22 bit7=0 */
+ /* QA will do this in new TXCARRSUPP proposal */
+ ATE_BBP_STOP_CTS_TX_MODE(pAd, BBP_R22, &BbpData);
+
+ /* No Carrier Suppression set BBP R24 bit0=0 */
+ ATE_BBP_CTS_TX_SIN_WAVE_DISABLE(pAd, BBP_R24, &BbpData);
+ }
+ }
+
+ /*
+ We should free some resource which was allocated
+ when ATE_TXFRAME, ATE_STOP, and ATE_TXCONT.
+ */
+ else if ((atemode & ATE_TXFRAME) || (atemode == ATE_STOP))
+ {
+ if (atemode == ATE_TXCONT)
+ {
+ if (pATEInfo->TxMethod == TX_METHOD_0)
+ {
+ /* No Cont. TX set BBP R22 bit7=0 */
+ /* QA will do this in new TXCONT proposal */
+ ATE_BBP_STOP_CTS_TX_MODE(pAd, BBP_R22, &BbpData);
+ }
+ }
+
+
+#ifdef RTMP_MAC_USB
+ RTUSBRejectPendingPackets(pAd);
+ RTUSBCleanUpDataBulkOutQueue(pAd);
+ RTUSBCleanUpMLMEBulkOutQueue(pAd);
+
+ /* Abort Tx, RX DMA. */
+ RtmpDmaEnable(pAd, 0);
+ while (pAd->PendingRx > 0)
+ {
+ ATE_RTUSBCancelPendingBulkInIRP(pAd);
+ RtmpOsMsDelay(500);
+ }
+
+ while (((pAd->BulkOutPending[0] == TRUE) ||
+ (pAd->BulkOutPending[1] == TRUE) ||
+ (pAd->BulkOutPending[2] == TRUE) ||
+ (pAd->BulkOutPending[3] == TRUE)) && (pAd->BulkFlags != 0))
+ /* pAd->BulkFlags != 0 : wait bulk out finish */
+ {
+ do
+ {
+ RTUSBCancelPendingBulkOutIRP(pAd);
+ } while (FALSE);
+
+ RtmpOsMsDelay(500);
+ }
+
+ ASSERT(pAd->PendingRx == 0);
+
+ /* Enable Tx, Rx DMA. */
+ RtmpDmaEnable(pAd, 1);
+#endif /* RTMP_MAC_USB */
+ }
+
+ /* task Tx status : 0 --> task is idle, 1 --> task is running */
+ pATEInfo->TxStatus = 0;
+
+ if (pATEInfo->TxMethod == TX_METHOD_0)
+ {
+ BbpSoftReset(pAd);/* Soft reset BBP. */
+ }
+
+ /* Disable Tx */
+ ATE_MAC_TX_DISABLE(pAd, MAC_SYS_CTRL, &MacData);
+
+#ifdef RTMP_MAC_USB
+ /* Clear ATE bulk in/out counter and continue setup */
+ InterlockedExchange(&pAd->BulkOutRemained, 0);
+ pAd->ContinBulkOut = FALSE;
+#endif /* RTMP_MAC_USB */
+
+ DBGPRINT(RT_DEBUG_TRACE, ("ATE : <=== %s\n", __FUNCTION__));
+ return Status;
+}
+
+
+NDIS_STATUS RXSTOP(
+ IN PRTMP_ADAPTER pAd)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ UINT32 MacData=0;
+ NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
+
+ DBGPRINT(RT_DEBUG_TRACE, ("ATE : ===> %s\n", __FUNCTION__));
+
+ /* Disable Rx */
+ ATE_MAC_RX_DISABLE(pAd, MAC_SYS_CTRL, &MacData);
+
+ pATEInfo->Mode &= ATE_RXSTOP;
+ pATEInfo->bQARxStart = FALSE;
+
+#ifdef RTMP_MAC_USB
+ RTUSBRejectPendingPackets(pAd);
+ RTUSBCleanUpDataBulkOutQueue(pAd);
+
+ RTUSBCleanUpMLMEBulkOutQueue(pAd);
+
+ /* Abort Tx, RX DMA. */
+ RtmpDmaEnable(pAd, 0);
+
+ while (pAd->PendingRx > 0)
+ {
+ ATE_RTUSBCancelPendingBulkInIRP(pAd);
+ RtmpOsMsDelay(500);
+ }
+
+ while (((pAd->BulkOutPending[0] == TRUE) ||
+ (pAd->BulkOutPending[1] == TRUE) ||
+ (pAd->BulkOutPending[2] == TRUE) ||
+ (pAd->BulkOutPending[3] == TRUE)) && (pAd->BulkFlags != 0))
+ /* pAd->BulkFlags != 0 : wait bulk out finish */
+ {
+ do
+ {
+ RTUSBCancelPendingBulkOutIRP(pAd);
+ } while (FALSE);
+
+ RtmpOsMsDelay(500);
+ }
+
+ ASSERT(pAd->PendingRx == 0);
+ pAd->ContinBulkIn = FALSE;
+#endif /* RTMP_MAC_USB */
+
+ if ((!IS_RT3883(pAd)) && (!IS_RT3352(pAd)) && (!IS_RT5350(pAd)))
+ BbpSoftReset(pAd);/* Soft reset BBP. */
+
+ DBGPRINT(RT_DEBUG_TRACE, ("ATE : <=== %s\n", __FUNCTION__));
+ return Status;
+}
+
+
+static VOID memcpy_exl(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, ULONG len)
+{
+ UINT32 i, Value = 0;
+ UCHAR *pDst = NULL, *pSrc = NULL;
+
+ for (i = 0 ; i < (len >> 2); i++)
+ {
+ pDst = (dst + i*4);
+ pSrc = (src + i*4);
+ /* For alignment issue, we need a variable "Value". */
+ memmove(&Value, pSrc, 4);
+ Value = OS_HTONL(Value);
+ memmove(pDst, &Value, 4);
+ pDst += 4;
+ pSrc += 4;
+ }
+
+ if ((len % 4) != 0)
+ {
+ /* wish that it will never reach here */
+ memmove(&Value, pSrc, (len % 4));
+ Value = OS_HTONL(Value);
+ memmove(pDst, &Value, (len % 4));
+ }
+}
+
+
+static VOID memcpy_exs(PRTMP_ADAPTER pAd, UCHAR *dst, UCHAR *src, ULONG len)
+{
+ ULONG i;
+ {
+ USHORT *pDst, *pSrc;
+
+ pDst = (USHORT *) dst;
+ pSrc = (USHORT *) src;
+
+ for (i =0; i < (len >> 1); i++)
+ {
+ *pDst = OS_NTOHS(*pSrc);
+ pDst++;
+ pSrc++;
+ }
+
+ if ((len % 2) != 0)
+ {
+ memcpy(pDst, pSrc, (len % 2));
+ *pDst = OS_NTOHS(*pDst);
+ }
+ }
+ return;
+}
+
+
+static VOID RTMP_IO_READ_BULK(PRTMP_ADAPTER pAd, UCHAR *dst, UINT32 offset, UINT32 len)
+{
+ UINT32 i, Value = 0;
+ UCHAR *pDst;
+
+ for (i = 0 ; i < (len >> 2); i++)
+ {
+ pDst = (dst + (i << 2));
+ RTMP_IO_READ32(pAd, offset, &Value);
+ Value = OS_HTONL(Value);
+ memmove(pDst, &Value, 4);
+ offset += 4;
+ }
+ return;
+}
+
+
+VOID BubbleSort(INT32 size, INT32 array[])
+{
+ INT32 outer, inner, temp;
+
+ for (outer = size-1; outer>0; outer--)
+ {
+ for (inner = 0; inner<outer; inner++)
+ {
+ if (array[inner] > array[inner+1])
+ {
+ temp = array[inner];
+ array[inner]=array[inner+1];
+ array[inner+1]=temp;
+ }
+ }
+ }
+ return;
+}
+
+
+VOID CalNoiseLevel(PRTMP_ADAPTER pAd, UCHAR channel, INT32 RSSI[3][10])
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ INT32 RSSI0, RSSI1, RSSI2;
+ CHAR Rssi0Offset, Rssi1Offset, Rssi2Offset;
+ UCHAR BbpR50Rssi0 = 0, BbpR51Rssi1 = 0, BbpR52Rssi2 = 0;
+ UCHAR Org_BBP66value = 0, Org_BBP69value = 0, Org_BBP70value = 0, data = 0;
+ USHORT LNA_Gain = 0;
+ INT32 column = 0;
+ UCHAR Org_Channel = pATEInfo->Channel;
+ USHORT GainValue = 0, OffsetValue = 0;
+
+ ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R66, &Org_BBP66value);
+ ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R69, &Org_BBP69value);
+ ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R70, &Org_BBP70value);
+
+ /************************************************************************/
+ /* Read the value of LNA gain and RSSI offset */
+ /************************************************************************/
+ RT28xx_EEPROM_READ16(pAd, EEPROM_LNA_OFFSET, GainValue);
+
+ /* for Noise Level */
+ if (channel <= 14)
+ {
+ LNA_Gain = GainValue & 0x00FF;
+
+ RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_BG_OFFSET, OffsetValue);
+ Rssi0Offset = OffsetValue & 0x00FF;
+ Rssi1Offset = (OffsetValue & 0xFF00) >> 8;
+
+ RT28xx_EEPROM_READ16(pAd, (EEPROM_RSSI_BG_OFFSET + 2)/* 0x48 */, OffsetValue);
+ Rssi2Offset = OffsetValue & 0x00FF;
+ }
+ else
+ {
+ LNA_Gain = (GainValue & 0xFF00) >> 8;
+
+ RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_A_OFFSET, OffsetValue);
+ Rssi0Offset = OffsetValue & 0x00FF;
+ Rssi1Offset = (OffsetValue & 0xFF00) >> 8;
+
+ RT28xx_EEPROM_READ16(pAd, (EEPROM_RSSI_A_OFFSET + 2)/* 0x4C */, OffsetValue);
+ Rssi2Offset = OffsetValue & 0x00FF;
+ }
+ /***********************************************************************/
+ {
+ pATEInfo->Channel = channel;
+ ATEAsicSwitchChannel(pAd);
+ RtmpOsMsDelay(5);
+
+ data = 0x10;
+ ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, data);
+ data = 0x40;
+ ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, data);
+ data = 0x40;
+ ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, data);
+ RtmpOsMsDelay(5);
+
+ /* start Rx */
+ pATEInfo->bQARxStart = TRUE;
+ Set_ATE_Proc(pAd, "RXFRAME");
+
+ RtmpOsMsDelay(5);
+
+ for (column = 0; column < 10; column++)
+ {
+ ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R50, &BbpR50Rssi0);
+ ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R51, &BbpR51Rssi1);
+ ATE_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R52, &BbpR52Rssi2);
+
+ RtmpOsMsDelay(10);
+
+ /* calculate RSSI 0 */
+ if (BbpR50Rssi0 == 0)
+ {
+ RSSI0 = -100;
+ }
+ else
+ {
+ RSSI0 = (INT32)(-12 - BbpR50Rssi0 - LNA_Gain - Rssi0Offset);
+ }
+ RSSI[0][column] = RSSI0;
+
+ if ( pAd->Antenna.field.RxPath >= 2 ) /* 2R */
+ {
+ /* calculate RSSI 1 */
+ if (BbpR51Rssi1 == 0)
+ {
+ RSSI1 = -100;
+ }
+ else
+ {
+ RSSI1 = (INT32)(-12 - BbpR51Rssi1 - LNA_Gain - Rssi1Offset);
+ }
+ RSSI[1][column] = RSSI1;
+ }
+
+ if ( pAd->Antenna.field.RxPath >= 3 ) /* 3R */
+ {
+ /* calculate RSSI 2 */
+ if (BbpR52Rssi2 == 0)
+ RSSI2 = -100;
+ else
+ RSSI2 = (INT32)(-12 - BbpR52Rssi2 - LNA_Gain - Rssi2Offset);
+
+ RSSI[2][column] = RSSI2;
+ }
+ }
+
+ /* stop Rx */
+ Set_ATE_Proc(pAd, "RXSTOP");
+
+ RtmpOsMsDelay(5);
+
+ BubbleSort(10, RSSI[0]); /* 1R */
+
+ if ( pAd->Antenna.field.RxPath >= 2 ) /* 2R */
+ {
+ BubbleSort(10, RSSI[1]);
+ }
+
+ if ( pAd->Antenna.field.RxPath >= 3 ) /* 3R */
+ {
+ BubbleSort(10, RSSI[2]);
+ }
+ }
+
+ pATEInfo->Channel = Org_Channel;
+ ATEAsicSwitchChannel(pAd);
+
+ /* restore original value */
+
+ ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, Org_BBP69value);
+ ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, Org_BBP70value);
+
+ return;
+}
+
+
+static VOID ATE_BBPRead(
+ IN PRTMP_ADAPTER pAd,
+ IN UCHAR offset,
+ IN UCHAR *pValue)
+{
+ if (ATE_ON(pAd))
+ {
+ ATE_BBP_IO_READ8_BY_REG_ID(pAd, offset, pValue);
+ }
+ else
+ {
+ RTMP_BBP_IO_READ8_BY_REG_ID(pAd, offset, pValue);
+ }
+}
+
+
+static VOID ATE_BBPWrite(
+ IN PRTMP_ADAPTER pAd,
+ IN UCHAR offset,
+ IN UCHAR value)
+{
+ if (ATE_ON(pAd))
+ {
+ ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, offset, value);
+ }
+ else
+ {
+ RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, offset, value);
+ }
+}
+
+
+BOOLEAN SyncTxRxConfig(PRTMP_ADAPTER pAd, USHORT offset, UCHAR value)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ UCHAR tmp = 0, bbp_data = 0;
+
+ ATE_BBPRead(pAd, offset, &bbp_data);
+
+ /* confirm again */
+ ASSERT(bbp_data == value);
+
+ switch (offset)
+ {
+ case BBP_R1:
+ /* Need to synchronize tx configuration with legacy ATE. */
+ tmp = (bbp_data & ((1 << 4) | (1 << 3))/* 0x18 */) >> 3;
+ switch (tmp)
+ {
+ /* The BBP R1 bit[4:3] = 2 :: Both DACs will be used by QA. */
+ case 2:
+ /* All */
+ pATEInfo->TxAntennaSel = 0;
+ break;
+ /* The BBP R1 bit[4:3] = 0 :: DAC 0 will be used by QA. */
+ case 0:
+ /* Antenna one */
+ pATEInfo->TxAntennaSel = 1;
+ break;
+ /* The BBP R1 bit[4:3] = 1 :: DAC 1 will be used by QA. */
+ case 1:
+ /* Antenna two */
+ pATEInfo->TxAntennaSel = 2;
+ break;
+ default:
+ DBGPRINT_ERR(("%s -- Sth. wrong! : return FALSE; \n", __FUNCTION__));
+ return FALSE;
+ }
+ break;/* case BBP_R1 */
+
+ case BBP_R3:
+ /* Need to synchronize rx configuration with legacy ATE. */
+ tmp = (bbp_data & ((1 << 1) | (1 << 0))/* 0x03 */);
+ switch(tmp)
+ {
+ /* The BBP R3 bit[1:0] = 3 :: All ADCs will be used by QA. */
+ case 3:
+ /* All */
+ pATEInfo->RxAntennaSel = 0;
+ break;
+ /*
+ The BBP R3 bit[1:0] = 0 :: ADC 0 will be used by QA,
+ unless the BBP R3 bit[4:3] = 2
+ */
+ case 0:
+ /* Antenna one */
+ pATEInfo->RxAntennaSel = 1;
+ tmp = ((bbp_data & ((1 << 4) | (1 << 3))/* 0x03 */) >> 3);
+ if (tmp == 2) /* 3R */
+ {
+ /* Default : All ADCs will be used by QA */
+ pATEInfo->RxAntennaSel = 0;
+ }
+ break;
+ /* The BBP R3 bit[1:0] = 1 :: ADC 1 will be used by QA. */
+ case 1:
+ /* Antenna two */
+ pATEInfo->RxAntennaSel = 2;
+ break;
+ /* The BBP R3 bit[1:0] = 2 :: ADC 2 will be used by QA. */
+ case 2:
+ /* Antenna three */
+ pATEInfo->RxAntennaSel = 3;
+ break;
+ default:
+ DBGPRINT_ERR(("%s -- Impossible! : return FALSE; \n", __FUNCTION__));
+ return FALSE;
+ }
+ break;/* case BBP_R3 */
+
+ default:
+ DBGPRINT_ERR(("%s -- Sth. wrong! : return FALSE; \n", __FUNCTION__));
+ return FALSE;
+
+ }
+ return TRUE;
+}
+
+
+static INT ResponseToGUI(
+ IN struct ate_racfghdr *pRaCfg,
+ IN RTMP_IOCTL_INPUT_STRUCT *pwrq,
+ IN INT Length,
+ IN INT Status)
+{
+ (pRaCfg)->length = OS_HTONS((Length));
+ (pRaCfg)->status = OS_HTONS((Status));
+ (pwrq)->u.data.length = sizeof((pRaCfg)->magic_no) + sizeof((pRaCfg)->command_type)
+ + sizeof((pRaCfg)->command_id) + sizeof((pRaCfg)->length)
+ + sizeof((pRaCfg)->sequence) + OS_NTOHS((pRaCfg)->length);
+ DBGPRINT(RT_DEBUG_TRACE, ("wrq->u.data.length = %d\n", (pwrq)->u.data.length));
+
+ if (copy_to_user((pwrq)->u.data.pointer, (UCHAR *)(pRaCfg), (pwrq)->u.data.length))
+ {
+
+ DBGPRINT_ERR(("copy_to_user() fail in %s\n", __FUNCTION__));
+ return (-EFAULT);
+ }
+ else
+ {
+ DBGPRINT(RT_DEBUG_TRACE, ("RACFG command(0x%04x)[magic number(0x%08x)] is done\n",
+ OS_NTOHS(pRaCfg->command_id), OS_NTOHL(pRaCfg->magic_no)));
+ }
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_START(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START\n"));
+
+ pATEInfo->bQAEnabled = TRUE;
+ DBGPRINT(RT_DEBUG_TRACE,("pATEInfo->bQAEnabled = %s\n", (pATEInfo->bQAEnabled)? "TRUE":"FALSE"));
+
+ /* Prepare feedback as soon as we can to avoid QA timeout. */
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+#ifdef CONFIG_RT2880_ATE_CMD_NEW
+ Set_ATE_Proc(pAd, "ATESTART");
+#else
+ Set_ATE_Proc(pAd, "APSTOP");
+#endif /* CONFIG_RT2880_ATE_CMD_NEW */
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_STOP(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ INT32 ret;
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_STOP\n"));
+
+ pATEInfo->bQAEnabled = FALSE;
+ DBGPRINT(RT_DEBUG_TRACE,("pATEInfo->bQAEnabled = %s\n", (pATEInfo->bQAEnabled)? "TRUE":"FALSE"));
+
+ /*
+ Distinguish this command came from QA(via ate agent)
+ or ate agent according to the existence of pid in payload.
+
+ No need to prepare feedback if this cmd came directly from ate agent,
+ not from QA.
+ */
+ pRaCfg->length = OS_NTOHS(pRaCfg->length);
+
+ if (pRaCfg->length == sizeof(pATEInfo->AtePid))
+ {
+ /*
+ This command came from QA.
+ Get the pid of ATE agent.
+ */
+ memcpy((UCHAR *)&pATEInfo->AtePid,
+ (&pRaCfg->data[0]) - 2/* == sizeof(pRaCfg->status) */,
+ sizeof(pATEInfo->AtePid));
+
+ /* Prepare feedback as soon as we can to avoid QA timeout. */
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+ /* Kill ATE agent when leaving ATE mode. */
+#ifdef LINUX
+ ret = RTMP_THREAD_PID_KILL(pATEInfo->AtePid);
+ if (ret)
+ DBGPRINT_ERR(("%s : unable to kill ate thread\n", RTMP_OS_NETDEV_GET_DEVNAME(pAd->net_dev)));
+#endif /* LINUX */
+ }
+
+
+ /* AP/STA may be already in ATE_STOP mode due to cmd from QA. */
+ if (ATE_ON(pAd))
+ {
+ /* Someone has killed ate agent while QA GUI is still open. */
+
+#ifdef CONFIG_RT2880_ATE_CMD_NEW
+ Set_ATE_Proc(pAd, "ATESTOP");
+#else
+ Set_ATE_Proc(pAd, "APSTART");
+#endif
+ DBGPRINT(RT_DEBUG_TRACE, ("RACFG_CMD_AP_START is done !\n"));
+ }
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_RF_WRITE_ALL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ UINT32 R1, R2, R3, R4;
+ USHORT channel;
+
+ memcpy(&R1, pRaCfg->data-2, 4);
+ memcpy(&R2, pRaCfg->data+2, 4);
+ memcpy(&R3, pRaCfg->data+6, 4);
+ memcpy(&R4, pRaCfg->data+10, 4);
+ memcpy(&channel, pRaCfg->data+14, 2);
+
+ pAd->LatchRfRegs.R1 = OS_NTOHL(R1);
+ pAd->LatchRfRegs.R2 = OS_NTOHL(R2);
+ pAd->LatchRfRegs.R3 = OS_NTOHL(R3);
+ pAd->LatchRfRegs.R4 = OS_NTOHL(R4);
+ pAd->LatchRfRegs.Channel = OS_NTOHS(channel);
+
+ RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R1);
+ RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R2);
+ RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R3);
+ RTMP_RF_IO_WRITE32(pAd, pAd->LatchRfRegs.R4);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_E2PROM_READ16(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ UINT16 offset=0, value=0;
+ USHORT tmp=0;
+
+ offset = OS_NTOHS(pRaCfg->status);
+ RT28xx_EEPROM_READ16(pAd, offset, tmp);
+ value = tmp;
+ value = OS_HTONS(value);
+
+ DBGPRINT(RT_DEBUG_TRACE,("EEPROM Read offset = 0x%04x, value = 0x%04x\n", offset, value));
+ memcpy(pRaCfg->data, &value, 2);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+2, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_E2PROM_WRITE16(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT offset, value;
+
+ offset = OS_NTOHS(pRaCfg->status);
+ memcpy(&value, pRaCfg->data, 2);
+ value = OS_NTOHS(value);
+ RT28xx_EEPROM_WRITE16(pAd, offset, value);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_E2PROM_READ_ALL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT buffer[EEPROM_SIZE >> 1];
+
+ rt_ee_read_all(pAd,(USHORT *)buffer);
+ memcpy_exs(pAd, pRaCfg->data, (UCHAR *)buffer, EEPROM_SIZE);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+EEPROM_SIZE, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_E2PROM_WRITE_ALL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT buffer[EEPROM_SIZE >> 1];
+
+ NdisZeroMemory((UCHAR *)buffer, EEPROM_SIZE);
+ memcpy_exs(pAd, (UCHAR *)buffer, (UCHAR *)&pRaCfg->status, EEPROM_SIZE);
+ rt_ee_write_all(pAd,(USHORT *)buffer);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_IO_READ(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ UINT32 offset;
+ UINT32 value;
+
+ memcpy(&offset, &pRaCfg->status, 4);
+ offset = OS_NTOHL(offset);
+
+ {
+ /*
+ We do not need the base address.
+ So just extract the offset out.
+ */
+ offset &= 0x0000FFFF;
+ RTMP_IO_READ32(pAd, offset, &value);
+ }
+ value = OS_HTONL(value);
+ memcpy(pRaCfg->data, &value, 4);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+4, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_IO_WRITE(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ UINT32 offset, value;
+
+ memcpy(&offset, pRaCfg->data-2, 4);
+ memcpy(&value, pRaCfg->data+2, 4);
+
+ offset = OS_NTOHL(offset);
+
+ /*
+ We do not need the base address.
+ So just extract the offset out.
+ */
+ offset &= 0x0000FFFF;
+ value = OS_NTOHL(value);
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_IO_WRITE: offset = %x, value = %x\n", offset, value));
+ RTMP_IO_WRITE32(pAd, offset, value);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_IO_READ_BULK(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ UINT32 offset;
+ USHORT len;
+
+ memcpy(&offset, &pRaCfg->status, 4);
+ offset = OS_NTOHL(offset);
+
+ offset &= 0x0000FFFF;
+ memcpy(&len, pRaCfg->data+2, 2);
+ len = OS_NTOHS(len);
+
+ if (len > 371)
+ {
+ DBGPRINT_ERR(("%s : length requested is too large, make it smaller\n", __FUNCTION__));
+ pRaCfg->length = OS_HTONS(2);
+ pRaCfg->status = OS_HTONS(1);
+
+ return -EFAULT;
+ }
+
+ RTMP_IO_READ_BULK(pAd, pRaCfg->data, offset, (len << 2));/* unit in four bytes*/
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+(len << 2), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_BBP_READ8(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT offset;
+ UCHAR value;
+
+ value = 0;
+ offset = OS_NTOHS(pRaCfg->status);
+
+ ATE_BBPRead(pAd, offset, &value);
+
+ pRaCfg->data[0] = value;
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+1, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_BBP_WRITE8(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT offset;
+ UCHAR value;
+
+ offset = OS_NTOHS(pRaCfg->status);
+ memcpy(&value, pRaCfg->data, 1);
+ ATE_BBPWrite(pAd, offset, value);
+
+ if ((offset == BBP_R1) || (offset == BBP_R3))
+ {
+ SyncTxRxConfig(pAd, offset, value);
+ }
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_BBP_READ_ALL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT bbp_reg_index;
+
+ for (bbp_reg_index = 0; bbp_reg_index < pAd->chipCap.MaxNumOfBbpId+1; bbp_reg_index++)
+ {
+ pRaCfg->data[bbp_reg_index] = 0;
+ ATE_BBPRead(pAd, bbp_reg_index, &pRaCfg->data[bbp_reg_index]);
+ }
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+ pAd->chipCap.MaxNumOfBbpId+1, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_GET_NOISE_LEVEL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ UCHAR channel;
+ INT32 buffer[3][10];/* 3 : RxPath ; 10 : no. of per rssi samples */
+
+ channel = (OS_NTOHS(pRaCfg->status) & 0x00FF);
+ CalNoiseLevel(pAd, channel, buffer);
+ memcpy_exl(pAd, (UCHAR *)pRaCfg->data, (UCHAR *)&(buffer[0][0]), (sizeof(INT32)*3*10));
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+(sizeof(INT32)*3*10), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+
+
+static INT DO_RACFG_CMD_GET_COUNTER(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ memcpy_exl(pAd, &pRaCfg->data[0], (UCHAR *)&pATEInfo->U2M, 4);
+ memcpy_exl(pAd, &pRaCfg->data[4], (UCHAR *)&pATEInfo->OtherData, 4);
+ memcpy_exl(pAd, &pRaCfg->data[8], (UCHAR *)&pATEInfo->Beacon, 4);
+ memcpy_exl(pAd, &pRaCfg->data[12], (UCHAR *)&pATEInfo->OtherCount, 4);
+ memcpy_exl(pAd, &pRaCfg->data[16], (UCHAR *)&pATEInfo->TxAc0, 4);
+ memcpy_exl(pAd, &pRaCfg->data[20], (UCHAR *)&pATEInfo->TxAc1, 4);
+ memcpy_exl(pAd, &pRaCfg->data[24], (UCHAR *)&pATEInfo->TxAc2, 4);
+ memcpy_exl(pAd, &pRaCfg->data[28], (UCHAR *)&pATEInfo->TxAc3, 4);
+ memcpy_exl(pAd, &pRaCfg->data[32], (UCHAR *)&pATEInfo->TxHCCA, 4);
+ memcpy_exl(pAd, &pRaCfg->data[36], (UCHAR *)&pATEInfo->TxMgmt, 4);
+ memcpy_exl(pAd, &pRaCfg->data[40], (UCHAR *)&pATEInfo->RSSI0, 4);
+ memcpy_exl(pAd, &pRaCfg->data[44], (UCHAR *)&pATEInfo->RSSI1, 4);
+ memcpy_exl(pAd, &pRaCfg->data[48], (UCHAR *)&pATEInfo->RSSI2, 4);
+ memcpy_exl(pAd, &pRaCfg->data[52], (UCHAR *)&pATEInfo->SNR0, 4);
+ memcpy_exl(pAd, &pRaCfg->data[56], (UCHAR *)&pATEInfo->SNR1, 4);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+60, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_CLEAR_COUNTER(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ pATEInfo->U2M = 0;
+ pATEInfo->OtherData = 0;
+ pATEInfo->Beacon = 0;
+ pATEInfo->OtherCount = 0;
+ pATEInfo->TxAc0 = 0;
+ pATEInfo->TxAc1 = 0;
+ pATEInfo->TxAc2 = 0;
+ pATEInfo->TxAc3 = 0;
+ pATEInfo->TxHCCA = 0;
+ pATEInfo->TxMgmt = 0;
+ pATEInfo->TxDoneCount = 0;
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_TX_START(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ USHORT *p;
+ USHORT err = 1;
+ UINT8 TXWISize = pAd->chipCap.TXWISize;
+ UINT8 TxInfoSize = 4;
+
+ if ((pATEInfo->TxStatus != 0) && (pATEInfo->Mode & ATE_TXFRAME))
+ {
+ DBGPRINT_ERR(("%s : Ate Tx is already running,"
+ "to run next Tx, you must stop it first\n", __FUNCTION__));
+ err = 2;
+ goto tx_start_error;
+ }
+ else if ((pATEInfo->TxStatus != 0) && !(pATEInfo->Mode & ATE_TXFRAME))
+ {
+ int slot = 0;
+
+ while ((slot++ < 10) && (pATEInfo->TxStatus != 0))
+ {
+ RtmpOsMsDelay(5);
+ }
+
+ /* force it to stop */
+ pATEInfo->TxStatus = 0;
+ pATEInfo->TxDoneCount = 0;
+ pATEInfo->bQATxStart = FALSE;
+ }
+
+ /*
+ Reset ATE mode and set Tx/Rx idle
+ for new proposed TXCONT/TXCARR/TXCARRSUPP solution.
+ */
+ if ((pATEInfo->Mode & ATE_TXFRAME) && (pATEInfo->TxMethod == TX_METHOD_1))
+ {
+ TXSTOP(pAd);
+ }
+
+ /*
+ If pRaCfg->length == 0, this "RACFG_CMD_TX_START"
+ is for Carrier test or Carrier Suppression test.
+ */
+ if (OS_NTOHS(pRaCfg->length) != 0)
+ {
+ /* get frame info */
+#ifdef RTMP_MAC_USB
+ NdisMoveMemory(&pATEInfo->TxInfo, pRaCfg->data - 2, TxInfoSize);
+#ifdef RT_BIG_ENDIAN
+ RTMPDescriptorEndianChange((PUCHAR) &pATEInfo->TxInfo, TYPE_TXINFO);
+#endif /* RT_BIG_ENDIAN */
+#endif /* RTMP_MAC_USB */
+
+ NdisMoveMemory(&pATEInfo->TxWI, pRaCfg->data + 2, TXWISize);
+#ifdef RT_BIG_ENDIAN
+ RTMPWIEndianChange(pAd, (PUCHAR)&pATEInfo->TxWI, TYPE_TXWI);
+#endif /* RT_BIG_ENDIAN */
+
+ NdisMoveMemory(&pATEInfo->TxCount, pRaCfg->data + TXWISize + 2, 4);
+ pATEInfo->TxCount = OS_NTOHL(pATEInfo->TxCount);
+
+/* p = (USHORT *)(&pRaCfg->data[TXWISize + TxInfoSize + 2]); */
+
+ /* always use QID_AC_BE */
+ pATEInfo->QID = 0;
+
+ p = (USHORT *)(&pRaCfg->data[TXWISize + TxInfoSize + 2*2]);
+ pATEInfo->HLen = OS_NTOHS(*p);
+
+ if (pATEInfo->HLen > 32)
+ {
+ DBGPRINT_ERR(("%s : pATEInfo->HLen > 32\n", __FUNCTION__));
+ DBGPRINT_ERR(("pATEInfo->HLen = %d\n", pATEInfo->HLen));
+ err = 3;
+ goto tx_start_error;
+ }
+
+ NdisMoveMemory(&pATEInfo->Header, pRaCfg->data + (TXWISize + TxInfoSize + 2*3), pATEInfo->HLen);
+
+ pATEInfo->PLen = OS_NTOHS(pRaCfg->length) - (pATEInfo->HLen + (TXWISize + TxInfoSize + 2*4));
+
+ if (pATEInfo->PLen > 32)
+ {
+ DBGPRINT_ERR(("%s : pATEInfo->PLen > 32\n", __FUNCTION__));
+ err = 4;
+ goto tx_start_error;
+ }
+
+ NdisMoveMemory(&pATEInfo->Pattern, pRaCfg->data + (TXWISize + TxInfoSize + 2*3) + pATEInfo->HLen, pATEInfo->PLen);
+ pATEInfo->DLen = pATEInfo->TxWI.TxWIMPDUByteCnt - pATEInfo->HLen;
+
+
+ }
+
+ ReadQATxTypeFromBBP(pAd);
+
+ if (pATEInfo->bQATxStart == TRUE)
+ {
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+ return NDIS_STATUS_SUCCESS;
+ }
+
+tx_start_error:
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), err);
+
+ return err;
+}
+
+
+static INT DO_RACFG_CMD_GET_TX_STATUS(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ UINT32 count=0;
+
+ count = OS_HTONL(pATEInfo->TxDoneCount);
+ NdisMoveMemory(pRaCfg->data, &count, 4);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+4, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_TX_STOP(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_TX_STOP\n"));
+
+ Set_ATE_Proc(pAd, "TXSTOP");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_RX_START(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_START\n"));
+
+ pATEInfo->bQARxStart = TRUE;
+ Set_ATE_Proc(pAd, "RXFRAME");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_RX_STOP(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_STOP\n"));
+
+ Set_ATE_Proc(pAd, "RXSTOP");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_START_TX_CARRIER(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_CARRIER\n"));
+
+ Set_ATE_Proc(pAd, "TXCARR");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_START_TX_CONT(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_CONT\n"));
+
+ Set_ATE_Proc(pAd, "TXCONT");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_START_TX_FRAME(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_START_TX_FRAME\n"));
+
+ Set_ATE_Proc(pAd, "TXFRAME");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_BW(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_BW\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+
+ Set_ATE_TX_BW_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_TX_POWER0(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_POWER0\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_POWER0_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_TX_POWER1(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_POWER1\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_POWER1_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+#ifdef DOT11N_SS3_SUPPORT
+static INT DO_RACFG_CMD_ATE_SET_TX_POWER2(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_POWER2\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_POWER2_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+#endif /* DOT11N_SS3_SUPPORT */
+
+
+static INT DO_RACFG_CMD_ATE_SET_FREQ_OFFSET(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_FREQ_OFFSET\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_FREQ_OFFSET_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_GET_STATISTICS(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_GET_STATISTICS\n"));
+
+ memcpy_exl(pAd, &pRaCfg->data[0], (UCHAR *)&pATEInfo->TxDoneCount, 4);
+ memcpy_exl(pAd, &pRaCfg->data[4], (UCHAR *)&pAd->WlanCounters.RetryCount.u.LowPart, 4);
+ memcpy_exl(pAd, &pRaCfg->data[8], (UCHAR *)&pAd->WlanCounters.FailedCount.u.LowPart, 4);
+ memcpy_exl(pAd, &pRaCfg->data[12], (UCHAR *)&pAd->WlanCounters.RTSSuccessCount.u.LowPart, 4);
+ memcpy_exl(pAd, &pRaCfg->data[16], (UCHAR *)&pAd->WlanCounters.RTSFailureCount.u.LowPart, 4);
+ memcpy_exl(pAd, &pRaCfg->data[20], (UCHAR *)&pAd->WlanCounters.ReceivedFragmentCount.QuadPart, 4);
+ memcpy_exl(pAd, &pRaCfg->data[24], (UCHAR *)&pAd->WlanCounters.FCSErrorCount.u.LowPart, 4);
+ memcpy_exl(pAd, &pRaCfg->data[28], (UCHAR *)&pAd->Counters8023.RxNoBuffer, 4);
+ memcpy_exl(pAd, &pRaCfg->data[32], (UCHAR *)&pAd->WlanCounters.FrameDuplicateCount.u.LowPart, 4);
+ memcpy_exl(pAd, &pRaCfg->data[36], (UCHAR *)&pAd->RalinkCounters.OneSecFalseCCACnt, 4);
+
+ if (pATEInfo->RxAntennaSel == 0)
+ {
+ INT32 RSSI0 = 0;
+ INT32 RSSI1 = 0;
+ INT32 RSSI2 = 0;
+
+ RSSI0 = (INT32)(pATEInfo->LastRssi0 - pAd->BbpRssiToDbmDelta);
+ RSSI1 = (INT32)(pATEInfo->LastRssi1 - pAd->BbpRssiToDbmDelta);
+ RSSI2 = (INT32)(pATEInfo->LastRssi2 - pAd->BbpRssiToDbmDelta);
+ memcpy_exl(pAd, &pRaCfg->data[40], (UCHAR *)&RSSI0, 4);
+ memcpy_exl(pAd, &pRaCfg->data[44], (UCHAR *)&RSSI1, 4);
+ memcpy_exl(pAd, &pRaCfg->data[48], (UCHAR *)&RSSI2, 4);
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+52, NDIS_STATUS_SUCCESS);
+ }
+ else
+ {
+ INT32 RSSI0 = 0;
+
+ RSSI0 = (INT32)(pATEInfo->LastRssi0 - pAd->BbpRssiToDbmDelta);
+ memcpy_exl(pAd, &pRaCfg->data[40], (UCHAR *)&RSSI0, 4);
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+44, NDIS_STATUS_SUCCESS);
+ }
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_RESET_COUNTER(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ SHORT value = 1;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_RESET_COUNTER\n"));
+
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ResetStatCounter_Proc(pAd, str);
+
+ pATEInfo->TxDoneCount = 0;
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SEL_TX_ANTENNA(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SEL_TX_ANTENNA\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_Antenna_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SEL_RX_ANTENNA(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SEL_RX_ANTENNA\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_RX_Antenna_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_PREAMBLE(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_PREAMBLE\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_MODE_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_CHANNEL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_CHANNEL\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_CHANNEL_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_ADDR1(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR1\n"));
+ memcpy(pATEInfo->Addr1, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_ADDR2(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR2\n"));
+ memcpy(pATEInfo->Addr2, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_ADDR3(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_ADDR3\n"));
+ memcpy(pATEInfo->Addr3, (PUCHAR)(pRaCfg->data - 2), MAC_ADDR_LEN);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_RATE(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_RATE\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_MCS_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_TX_FRAME_LEN(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_FRAME_LEN\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_LENGTH_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_SET_TX_FRAME_COUNT(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_ATE_SET_TX_FRAME_COUNT\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+
+ {
+ snprintf((char *)str, sizeof(str), "%d", value);
+ Set_ATE_TX_COUNT_Proc(pAd, str);
+ }
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_START_RX_FRAME(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("RACFG_CMD_RX_START\n"));
+
+ Set_ATE_Proc(pAd, "RXFRAME");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_E2PROM_READ_BULK(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT offset;
+ USHORT len;
+ USHORT buffer[EEPROM_SIZE >> 1];
+
+ offset = OS_NTOHS(pRaCfg->status);
+ memcpy(&len, pRaCfg->data, 2);
+ len = OS_NTOHS(len);
+
+ rt_ee_read_all(pAd, (USHORT *)buffer);
+
+ if (offset + len <= EEPROM_SIZE)
+ memcpy_exs(pAd, pRaCfg->data, (UCHAR *)buffer+offset, len);
+ else
+ DBGPRINT_ERR(("%s : exceed EEPROM size\n", __FUNCTION__));
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+len, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_E2PROM_WRITE_BULK(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT offset;
+ USHORT len;
+ USHORT buffer[EEPROM_SIZE >> 1];
+
+ offset = OS_NTOHS(pRaCfg->status);
+ memcpy(&len, pRaCfg->data, 2);
+ len = OS_NTOHS(len);
+
+ memcpy_exs(pAd, (UCHAR *)buffer + offset, (UCHAR *)pRaCfg->data + 2, len);
+
+ if ((offset + len) <= EEPROM_SIZE)
+ {
+ rt_ee_write_bulk(pAd,(USHORT *)(((UCHAR *)buffer) + offset), offset, len);
+ }
+ else
+ {
+ DBGPRINT_ERR(("%s : exceed EEPROM size(%d)\n", __FUNCTION__, EEPROM_SIZE));
+ DBGPRINT_ERR(("offset=%d\n", offset));
+ DBGPRINT_ERR(("length=%d\n", len));
+ DBGPRINT_ERR(("offset+length=%d\n", (offset+len)));
+ }
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_IO_WRITE_BULK(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ UINT32 offset, pos, value;
+ USHORT len;
+
+ memcpy(&offset, &pRaCfg->status, 4);
+ offset = OS_NTOHL(offset);
+ memcpy(&len, pRaCfg->data+2, 2);
+ len = OS_NTOHS(len);
+
+ for (pos = 0; pos < len; pos += 4)
+ {
+ memcpy_exl(pAd, (UCHAR *)&value, pRaCfg->data+4+pos, 4);
+ DBGPRINT(RT_DEBUG_TRACE,("Write %x %x\n", offset + pos, value));
+ RTMP_IO_WRITE32(pAd, ((offset+pos) & (0xffff)), value);
+ }
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_BBP_READ_BULK(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT offset;
+ USHORT len;
+ USHORT pos;
+
+ offset = OS_NTOHS(pRaCfg->status);
+ memcpy(&len, pRaCfg->data, 2);
+ len = OS_NTOHS(len);
+
+ for (pos = offset; pos < (offset+len); pos++)
+ {
+ pRaCfg->data[pos - offset] = 0;
+
+ ATE_BBPRead(pAd, pos, &pRaCfg->data[pos - offset]);
+ }
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status)+len, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_BBP_WRITE_BULK(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT offset;
+ USHORT len;
+ USHORT pos;
+ UCHAR *value;
+
+ offset = OS_NTOHS(pRaCfg->status);
+ memcpy(&len, pRaCfg->data, 2);
+ len = OS_NTOHS(len);
+
+ for (pos = offset; pos < (offset+len); pos++)
+ {
+ value = pRaCfg->data + 2 + (pos - offset);
+ ATE_BBPWrite(pAd, pos, *value);
+ }
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+
+
+
+
+
+
+#ifdef TXBF_SUPPORT
+static INT DO_RACFG_CMD_ATE_TXBF_DUT_INIT(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("DO_RACFG_CMD_ATE_TXBF_DUT_INIT\n"));
+
+ Set_ATE_TXBF_INIT_Proc(pAd, "1");
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_TXBF_LNA_CAL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT band;
+ CHAR bandStr[32] = {0};
+
+ DBGPRINT(RT_DEBUG_TRACE,("DO_RACFG_CMD_ATE_TXBF_LNA_CAL\n"));
+
+ band = OS_NTOHS(pRaCfg->status);
+ DBGPRINT(RT_DEBUG_TRACE, ("%s : band=0x%x(0x%x)\n",
+ __FUNCTION__, band, pRaCfg->status));
+ snprintf(bandStr, sizeof(bandStr), "%d\n", band);
+ Set_ATE_TXBF_LNACAL_Proc(pAd, &bandStr[0]);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_TXBF_DIV_CAL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ USHORT band;
+ CHAR bandStr[32] = {0};
+
+ DBGPRINT(RT_DEBUG_TRACE,("DO_RACFG_CMD_ATE_TXBF_DIV_CAL\n"));
+
+ band = OS_NTOHS(pRaCfg->status);
+ DBGPRINT(RT_DEBUG_TRACE, ("%s : band=0x%x(0x%x)\n",
+ __FUNCTION__, band, pRaCfg->status));
+ snprintf(bandStr, sizeof(bandStr), "%d\n", band);
+ Set_ATE_TXBF_DIVCAL_Proc(pAd, &bandStr[0]);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_TXBF_PHASE_CAL(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+ BOOLEAN result = FALSE;
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("DO_RACFG_CMD_ATE_TXBF_PHASE_CAL\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+
+ result = (BOOLEAN)Set_ATE_TXBF_CAL_Proc(pAd, str);
+ pRaCfg->data[0] = result;
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status) + 1, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_TXBF_GOLDEN_INIT(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+
+ NdisZeroMemory(str, LEN_OF_ARG);
+
+ DBGPRINT(RT_DEBUG_TRACE,("DO_RACFG_CMD_ATE_TXBF_GOLDEN_INIT\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+
+ Set_ATE_TXBF_GOLDEN_Proc(pAd, str);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_TXBF_VERIFY(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+ BOOLEAN result;
+
+ DBGPRINT(RT_DEBUG_TRACE,("DO_RACFG_CMD_ATE_TXBF_VERIFY\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+
+ result = (BOOLEAN)Set_ATE_TXBF_VERIFY_Proc(pAd, str);
+
+ pRaCfg->data[0] = result;
+ pRaCfg->data[1] = pATEInfo->calParams[0];
+ pRaCfg->data[2] = pATEInfo->calParams[1];
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status) + 3, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+
+static INT DO_RACFG_CMD_ATE_TXBF_VERIFY_NOCOMP(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ SHORT value = 0;
+ STRING str[LEN_OF_ARG];
+ BOOLEAN result;
+
+ DBGPRINT(RT_DEBUG_TRACE,("DO_RACFG_CMD_ATE_TXBF_VERIFY_NOCOMP\n"));
+
+ memcpy((PUCHAR)&value, (PUCHAR)&(pRaCfg->status), 2);
+ value = OS_NTOHS(value);
+ snprintf((char *)str, sizeof(str), "%d", value);
+
+ result = (BOOLEAN)Set_ATE_TXBF_VERIFY_NoComp_Proc(pAd, str);
+
+ pRaCfg->data[0] = result;
+ pRaCfg->data[1] = pATEInfo->calParams[0];
+ pRaCfg->data[2] = pATEInfo->calParams[1];
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status) + 3, NDIS_STATUS_SUCCESS);
+
+ return NDIS_STATUS_SUCCESS;
+}
+#endif /* TXBF_SUPPORT */
+
+
+static INT32 DO_RACFG_CMD_ATE_SHOW_PARAM(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ INT32 Status = NDIS_STATUS_SUCCESS;
+ UINT32 Len;
+ ATE_EX_PARAM ATEExParam;
+
+ ATEExParam.mode = pATEInfo->Mode;
+ ATEExParam.TxPower0 = pATEInfo->TxPower0;
+ ATEExParam.TxPower1 = pATEInfo->TxPower1;
+
+#ifdef DOT11N_SS3_SUPPORT
+ ATEExParam.TxPower2 = pATEInfo->TxPower2;
+#endif /* DOT11N_SS3_SUPPORT */
+
+ ATEExParam.TxAntennaSel = pATEInfo->TxAntennaSel;
+ ATEExParam.RxAntennaSel = pATEInfo->RxAntennaSel;
+
+#ifdef CONFIG_AP_SUPPORT
+ NdisMoveMemory(ATEExParam.DA, pATEInfo->Addr1, MAC_ADDR_LEN);
+ NdisMoveMemory(ATEExParam.SA, pATEInfo->Addr3, MAC_ADDR_LEN);
+ NdisMoveMemory(ATEExParam.BSSID, pATEInfo->Addr2, MAC_ADDR_LEN);
+#endif /* CONFIG_AP_SUPPORT */
+
+
+ ATEExParam.MCS = pATEInfo->TxWI.TxWIMCS;
+ ATEExParam.PhyMode = pATEInfo->TxWI.TxWIPHYMODE;
+ ATEExParam.ShortGI = pATEInfo->TxWI.TxWIShortGI;
+ ATEExParam.BW = pATEInfo->TxWI.TxWIBW;
+ ATEExParam.Channel = OS_HTONL(pATEInfo->Channel);
+ ATEExParam.TxLength = OS_HTONL(pATEInfo->TxLength);
+ ATEExParam.TxCount = OS_HTONL(pATEInfo->TxCount);
+ ATEExParam.RFFreqOffset = OS_HTONL(pATEInfo->RFFreqOffset);
+ ATEExParam.IPG = OS_HTONL(pATEInfo->IPG);
+ ATEExParam.RxTotalCnt = OS_HTONL(pATEInfo->RxTotalCnt);
+ ATEExParam.RxCntPerSec = OS_HTONL(pATEInfo->RxCntPerSec);
+ ATEExParam.LastSNR0 = pATEInfo->LastSNR0;
+ ATEExParam.LastSNR1 = pATEInfo->LastSNR1;
+#ifdef DOT11N_SS3_SUPPORT
+ ATEExParam.LastSNR2 = pATEInfo->LastSNR2;
+#endif /* DOT11N_SS3_SUPPORT */
+ ATEExParam.LastRssi0 = pATEInfo->LastRssi0;
+ ATEExParam.LastRssi1 = pATEInfo->LastRssi1;
+ ATEExParam.LastRssi2 = pATEInfo->LastRssi2;
+ ATEExParam.AvgRssi0 = pATEInfo->AvgRssi0;
+ ATEExParam.AvgRssi1 = pATEInfo->AvgRssi1;
+ ATEExParam.AvgRssi2 = pATEInfo->AvgRssi2;
+ ATEExParam.AvgRssi0X8 = OS_HTONS(pATEInfo->AvgRssi0X8);
+ ATEExParam.AvgRssi1X8 = OS_HTONS(pATEInfo->AvgRssi1X8);
+ ATEExParam.AvgRssi2X8 = OS_HTONS(pATEInfo->AvgRssi2X8);
+
+ Len = sizeof(ATEExParam);
+ NdisMoveMemory(pRaCfg->data, &ATEExParam, Len);
+
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status) + Len, NDIS_STATUS_SUCCESS);
+
+ return Status;
+}
+
+
+typedef INT (*RACFG_CMD_HANDLER)(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN struct ate_racfghdr *pRaCfg);
+
+
+static RACFG_CMD_HANDLER RACFG_CMD_SET1[] =
+{
+ /* cmd id start from 0x0 */
+ DO_RACFG_CMD_RF_WRITE_ALL,/* 0x0000 */
+ DO_RACFG_CMD_E2PROM_READ16,/* 0x0001 */
+ DO_RACFG_CMD_E2PROM_WRITE16,/* 0x0002 */
+ DO_RACFG_CMD_E2PROM_READ_ALL,/* 0x0003 */
+ DO_RACFG_CMD_E2PROM_WRITE_ALL,/* 0x0004 */
+ DO_RACFG_CMD_IO_READ,/* 0x0005 */
+ DO_RACFG_CMD_IO_WRITE,/* 0x0006 */
+ DO_RACFG_CMD_IO_READ_BULK,/* 0x0007 */
+ DO_RACFG_CMD_BBP_READ8,/* 0x0008 */
+ DO_RACFG_CMD_BBP_WRITE8,/* 0x0009 */
+ DO_RACFG_CMD_BBP_READ_ALL,/* 0x000a */
+ DO_RACFG_CMD_GET_COUNTER,/* 0x000b */
+ DO_RACFG_CMD_CLEAR_COUNTER,/* 0x000c */
+ NULL /* RACFG_CMD_RSV1 */,/* 0x000d */
+ NULL /* RACFG_CMD_RSV2 */,/* 0x000e */
+ NULL /* RACFG_CMD_RSV3 */,/* 0x000f */
+ DO_RACFG_CMD_TX_START,/* 0x0010 */
+ DO_RACFG_CMD_GET_TX_STATUS,/* 0x0011 */
+ DO_RACFG_CMD_TX_STOP,/* 0x0012 */
+ DO_RACFG_CMD_RX_START,/* 0x0013 */
+ DO_RACFG_CMD_RX_STOP,/* 0x0014 */
+ DO_RACFG_CMD_GET_NOISE_LEVEL,/* 0x0015 */
+ NULL
+ /* cmd id end with 0x20 */
+};
+
+
+static RACFG_CMD_HANDLER RACFG_CMD_SET2[] =
+{
+ /* cmd id start from 0x80 */
+ DO_RACFG_CMD_ATE_START,/* 0x0080 */
+ DO_RACFG_CMD_ATE_STOP/* 0x0081 */
+ /* cmd id end with 0x81 */
+};
+
+
+static RACFG_CMD_HANDLER RACFG_CMD_SET3[] =
+{
+ /* cmd id start from 0x100 */
+ DO_RACFG_CMD_ATE_START_TX_CARRIER,/* 0x0100 */
+ DO_RACFG_CMD_ATE_START_TX_CONT,/* 0x0101 */
+ DO_RACFG_CMD_ATE_START_TX_FRAME,/* 0x0102 */
+ DO_RACFG_CMD_ATE_SET_BW,/* 0x0103 */
+ DO_RACFG_CMD_ATE_SET_TX_POWER0,/* 0x0104 */
+ DO_RACFG_CMD_ATE_SET_TX_POWER1,/* 0x0105 */
+ DO_RACFG_CMD_ATE_SET_FREQ_OFFSET,/* 0x0106 */
+ DO_RACFG_CMD_ATE_GET_STATISTICS,/* 0x0107 */
+ DO_RACFG_CMD_ATE_RESET_COUNTER,/* 0x0108 */
+ DO_RACFG_CMD_ATE_SEL_TX_ANTENNA,/* 0x0109 */
+ DO_RACFG_CMD_ATE_SEL_RX_ANTENNA,/* 0x010a */
+ DO_RACFG_CMD_ATE_SET_PREAMBLE,/* 0x010b */
+ DO_RACFG_CMD_ATE_SET_CHANNEL,/* 0x010c */
+ DO_RACFG_CMD_ATE_SET_ADDR1,/* 0x010d */
+ DO_RACFG_CMD_ATE_SET_ADDR2,/* 0x010e */
+ DO_RACFG_CMD_ATE_SET_ADDR3,/* 0x010f */
+ DO_RACFG_CMD_ATE_SET_RATE,/* 0x0110 */
+ DO_RACFG_CMD_ATE_SET_TX_FRAME_LEN,/* 0x0111 */
+ DO_RACFG_CMD_ATE_SET_TX_FRAME_COUNT,/* 0x0112 */
+ DO_RACFG_CMD_ATE_START_RX_FRAME,/* 0x0113 */
+ DO_RACFG_CMD_ATE_E2PROM_READ_BULK,/* 0x0114 */
+ DO_RACFG_CMD_ATE_E2PROM_WRITE_BULK,/* 0x0115 */
+ DO_RACFG_CMD_ATE_IO_WRITE_BULK,/* 0x0116 */
+ DO_RACFG_CMD_ATE_BBP_READ_BULK,/* 0x0117 */
+ DO_RACFG_CMD_ATE_BBP_WRITE_BULK,/* 0x0118 */
+ NULL,/* 0x0119 */
+ NULL,/* 0x011a */
+#ifdef DOT11N_SS3_SUPPORT
+ DO_RACFG_CMD_ATE_SET_TX_POWER2,/* 0x011b */
+#else
+ NULL,/* 0x011b */
+#endif /* DOT11N_SS3_SUPPORT */
+#ifdef TXBF_SUPPORT
+ DO_RACFG_CMD_ATE_TXBF_DUT_INIT,/* 0x011c */
+ DO_RACFG_CMD_ATE_TXBF_LNA_CAL,/* 0x011d */
+ DO_RACFG_CMD_ATE_TXBF_DIV_CAL,/* 0x011e */
+ DO_RACFG_CMD_ATE_TXBF_PHASE_CAL,/* 0x011f */
+ DO_RACFG_CMD_ATE_TXBF_GOLDEN_INIT,/* 0x0120 */
+ DO_RACFG_CMD_ATE_TXBF_VERIFY,/* 0x0121 */
+ DO_RACFG_CMD_ATE_TXBF_VERIFY_NOCOMP/* 0x0122 */
+#else
+ NULL,/* 0x011c */
+ NULL,/* 0x011d */
+ NULL,/* 0x011e */
+ NULL,/* 0x011f */
+ NULL,/* 0x0120 */
+ NULL,/* 0x0121 */
+ NULL/* 0x0122 */
+#endif /* TXBF_SUPPORT */
+ /* cmd id end with 0x122 */
+};
+
+
+static RACFG_CMD_HANDLER RACFG_CMD_SET4[] =
+{
+ /* cmd id start from 0x200 */
+ NULL,/* 0x0200 */
+ NULL,/* 0x0201 */
+ NULL/* 0x0202 */
+ /* cmd id end with 0x202 */
+};
+
+
+static RACFG_CMD_HANDLER RACFG_CMD_SET5[] =
+{
+ DO_RACFG_CMD_ATE_SHOW_PARAM
+};
+
+
+typedef struct RACFG_CMD_TABLE_{
+ RACFG_CMD_HANDLER *cmdSet;
+ int cmdSetSize;
+ int cmdOffset;
+}RACFG_CMD_TABLE;
+
+
+RACFG_CMD_TABLE RACFG_CMD_TABLES[]={
+ {
+ RACFG_CMD_SET1,
+ sizeof(RACFG_CMD_SET1) / sizeof(RACFG_CMD_HANDLER),
+ 0x0,
+ },
+ {
+ RACFG_CMD_SET2,
+ sizeof(RACFG_CMD_SET2) / sizeof(RACFG_CMD_HANDLER),
+ 0x80,
+ },
+ {
+ RACFG_CMD_SET3,
+ sizeof(RACFG_CMD_SET3) / sizeof(RACFG_CMD_HANDLER),
+ 0x100,
+ },
+ {
+ RACFG_CMD_SET4,
+ sizeof(RACFG_CMD_SET4) / sizeof(RACFG_CMD_HANDLER),
+ 0x200,
+ },
+ {
+ RACFG_CMD_SET5,
+ sizeof(RACFG_CMD_SET5) / sizeof(RACFG_CMD_HANDLER),
+ 0xff00,
+ }
+
+};
+
+
+static INT32 RACfgCMDHandler(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN pRACFGHDR pRaCfg)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+ INT32 Status = NDIS_STATUS_SUCCESS;
+ USHORT Command_Id;
+ UINT32 TableIndex = 0;
+
+ Command_Id = OS_NTOHS(pRaCfg->command_id);
+ DBGPRINT(RT_DEBUG_TRACE,("\n%s: Command_Id = 0x%04x !\n", __FUNCTION__, Command_Id));
+
+ while (TableIndex < (sizeof(RACFG_CMD_TABLES) / sizeof(RACFG_CMD_TABLE)))
+ {
+ int cmd_index = 0;
+ cmd_index = Command_Id - RACFG_CMD_TABLES[TableIndex].cmdOffset;
+ if ((cmd_index >= 0) && (cmd_index < RACFG_CMD_TABLES[TableIndex].cmdSetSize))
+ {
+ RACFG_CMD_HANDLER *pCmdSet;
+
+ pCmdSet = RACFG_CMD_TABLES[TableIndex].cmdSet;
+
+ if (pCmdSet[cmd_index] != NULL)
+ Status = (*pCmdSet[cmd_index])(pAd, wrq, pRaCfg);
+ break;
+ }
+ TableIndex++;
+ }
+
+ /* In passive mode, only commands that read registers are allowed. */
+ if (pATEInfo->PassiveMode)
+ {
+ int entry, allowCmd = FALSE;
+ static int allowedCmds[] = {
+ RACFG_CMD_E2PROM_READ16, RACFG_CMD_E2PROM_READ_ALL,
+ RACFG_CMD_IO_READ, RACFG_CMD_IO_READ_BULK,
+ RACFG_CMD_BBP_READ8, RACFG_CMD_BBP_READ_ALL,
+ RACFG_CMD_ATE_E2PROM_READ_BULK,
+ RACFG_CMD_ATE_BBP_READ_BULK,
+ RACFG_CMD_ATE_RF_READ_BULK,
+ };
+
+ for (entry=0; entry<sizeof(allowedCmds)/sizeof(allowedCmds[0]); entry++)
+ {
+ if (Command_Id==allowedCmds[entry])
+ {
+ allowCmd = TRUE;
+ break;
+ }
+ }
+
+ /* Also allow writes to BF profile registers */
+ if (Command_Id==RACFG_CMD_BBP_WRITE8)
+ {
+ int offset = OS_NTOHS(pRaCfg->status);
+ if (offset==BBP_R27 || (offset>=BBP_R174 && offset<=BBP_R182))
+ allowCmd = TRUE;
+ }
+
+ /* If not allowed, then ignore the command. */
+ if (!allowCmd)
+ {
+ ResponseToGUI(pRaCfg, wrq, sizeof(pRaCfg->status), NDIS_STATUS_SUCCESS);
+ Status = NDIS_STATUS_FAILURE;
+ }
+ }
+
+ return Status;
+}
+
+
+INT RtmpDoAte(
+ IN PRTMP_ADAPTER pAd,
+ IN RTMP_IOCTL_INPUT_STRUCT *wrq,
+ IN PSTRING wrq_name)
+{
+ INT32 Status = NDIS_STATUS_SUCCESS;
+ struct ate_racfghdr *pRaCfg;
+ UINT32 ATEMagicNum;
+
+ os_alloc_mem_suspend(pAd, (UCHAR **)&pRaCfg, sizeof(struct ate_racfghdr));
+
+ if (!pRaCfg)
+ {
+ Status = -ENOMEM;
+ goto ERROR0;
+ }
+
+ NdisZeroMemory(pRaCfg, sizeof(struct ate_racfghdr));
+ Status = copy_from_user((PUCHAR)pRaCfg, wrq->u.data.pointer, wrq->u.data.length);
+
+ if (Status)
+ {
+ Status = -EFAULT;
+ goto ERROR1;
+ }
+
+ ATEMagicNum = OS_NTOHL(pRaCfg->magic_no);
+
+ switch(ATEMagicNum)
+ {
+ case RACFG_MAGIC_NO:
+ Status = RACfgCMDHandler(pAd, wrq, pRaCfg);
+ break;
+
+ default:
+ Status = NDIS_STATUS_FAILURE;
+ DBGPRINT_ERR(("Unknown magic number of RACFG command = %x\n", ATEMagicNum));
+ break;
+ }
+
+ ERROR1:
+ os_free_mem(NULL, pRaCfg);
+ ERROR0:
+ return Status;
+}
+
+
+VOID ATE_QA_Statistics(
+ IN RTMP_ADAPTER *pAd,
+ IN RXWI_STRUC *pRxWI,
+ IN RXINFO_STRUC *pRxInfo,
+ IN PHEADER_802_11 pHeader)
+{
+ PATE_INFO pATEInfo = &(pAd->ate);
+
+ /* update counter first */
+ if (pHeader != NULL)
+ {
+ if (pHeader->FC.Type == BTYPE_DATA)
+ {
+ if (pRxInfo->U2M)
+ {
+ pATEInfo->U2M++;
+ }
+ else
+ pATEInfo->OtherData++;
+ }
+ else if (pHeader->FC.Type == BTYPE_MGMT)
+ {
+ if (pHeader->FC.SubType == SUBTYPE_BEACON)
+ pATEInfo->Beacon++;
+ else
+ pATEInfo->OtherCount++;
+ }
+ else if (pHeader->FC.Type == BTYPE_CNTL)
+ {
+ pATEInfo->OtherCount++;
+ }
+ }
+ pATEInfo->RSSI0 = pRxWI->RxWIRSSI0;
+ pATEInfo->RSSI1 = pRxWI->RxWIRSSI1;
+ pATEInfo->RSSI2 = pRxWI->RxWIRSSI2;
+ pATEInfo->SNR0 = pRxWI->RxWISNR0;
+ pATEInfo->SNR1 = pRxWI->RxWISNR1;
+
+
+}
+
+
+INT Set_TxStop_Proc(
+ IN PRTMP_ADAPTER pAd,
+ IN PSTRING arg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("Set_TxStop_Proc\n"));
+
+ if (Set_ATE_Proc(pAd, "TXSTOP"))
+ {
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+
+INT Set_RxStop_Proc(
+ IN PRTMP_ADAPTER pAd,
+ IN PSTRING arg)
+{
+ DBGPRINT(RT_DEBUG_TRACE,("Set_RxStop_Proc\n"));
+
+ if (Set_ATE_Proc(pAd, "RXSTOP"))
+ {
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+
+#ifdef DBG
+INT Set_EERead_Proc(
+ IN PRTMP_ADAPTER pAd,
+ IN PSTRING arg)
+{
+ USHORT buffer[EEPROM_SIZE >> 1];
+ USHORT *p;
+ INT offset;
+
+ rt_ee_read_all(pAd, (USHORT *)buffer);
+ p = buffer;
+
+ for (offset = 0; offset < (EEPROM_SIZE >> 1); offset++)
+ {
+ DBGPRINT(RT_DEBUG_OFF, ("%4.4x ", *p));
+ if (((offset+1) % 16) == 0)
+ DBGPRINT(RT_DEBUG_OFF, ("\n"));
+ p++;
+ }
+
+ return TRUE;
+}
+
+
+INT Set_EEWrite_Proc(
+ IN PRTMP_ADAPTER pAd,
+ IN PSTRING arg)
+{
+ USHORT offset = 0, value;
+ PSTRING p2 = arg;
+
+ while ((*p2 != ':') && (*p2 != '\0'))
+ {
+ p2++;
+ }
+
+ if (*p2 == ':')
+ {
+ A2Hex(offset, arg);
+ A2Hex(value, p2 + 1);
+ }
+ else
+ {
+ A2Hex(value, arg);
+ }
+
+ if (offset >= EEPROM_SIZE)
+ {
+ DBGPRINT_ERR(("Offset can not exceed EEPROM_SIZE( == 0x%04x)\n", EEPROM_SIZE));
+ return FALSE;
+ }
+
+ RT28xx_EEPROM_WRITE16(pAd, offset, value);
+
+ return TRUE;
+}
+
+
+INT Set_BBPRead_Proc(
+ IN PRTMP_ADAPTER pAd,
+ IN PSTRING arg)
+{
+ UCHAR value = 0, offset;
+
+ A2Hex(offset, arg);
+
+ ATE_BBPRead(pAd, offset, &value);
+
+ DBGPRINT(RT_DEBUG_OFF, ("%x\n", value));
+
+ return TRUE;
+}
+
+
+INT Set_BBPWrite_Proc(
+ IN PRTMP_ADAPTER pAd,
+ IN PSTRING arg)
+{
+ USHORT offset = 0;
+ PSTRING p2 = arg;
+ UCHAR value;
+
+ while ((*p2 != ':') && (*p2 != '\0'))
+ {
+ p2++;
+ }
+
+ if (*p2 == ':')
+ {
+ A2Hex(offset, arg);
+ A2Hex(value, p2 + 1);
+ }
+ else
+ {
+ A2Hex(value, arg);
+ }
+
+ ATE_BBPWrite(pAd, offset, value);
+
+ return TRUE;
+}
+
+
+INT Set_RFWrite_Proc(
+ IN PRTMP_ADAPTER pAd,
+ IN PSTRING arg)
+{
+ PSTRING p2, p3, p4;
+ UINT32 R1, R2, R3, R4;
+
+ p2 = arg;
+
+ while ((*p2 != ':') && (*p2 != '\0'))
+ {
+ p2++;
+ }
+
+ if (*p2 != ':')
+ return FALSE;
+
+ p3 = p2 + 1;
+
+ while((*p3 != ':') && (*p3 != '\0'))
+ {
+ p3++;
+ }
+
+ if (*p3 != ':')
+ return FALSE;
+
+ p4 = p3 + 1;
+
+ while ((*p4 != ':') && (*p4 != '\0'))
+ {
+ p4++;
+ }
+
+ if (*p4 != ':')
+ return FALSE;
+
+
+ A2Hex(R1, arg);
+ A2Hex(R2, p2 + 1);
+ A2Hex(R3, p3 + 1);
+ A2Hex(R4, p4 + 1);
+
+ RTMP_RF_IO_WRITE32(pAd, R1);
+ RTMP_RF_IO_WRITE32(pAd, R2);
+ RTMP_RF_IO_WRITE32(pAd, R3);
+ RTMP_RF_IO_WRITE32(pAd, R4);
+
+ return TRUE;
+}
+#endif /* DBG */
+#endif /* RALINK_QA */
+