?? art_if.c
字號:
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.length = length;
GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset = startOffset;
memset(GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue, 0, length * 4);
memcpy(GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue, buf, length * 4);
//printf(" Write the Length %d \n", length);
/* for(ii =0 ;ii < 10 ; ii++)
{
printf ("Write Block is %x \n",GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue[ii]);
}*/
/* send the command. Note that the size to send is only for num bytes want to write */
if(!artSendCmd(&GlobalCmd,
(sizeof(GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD) + sizeof(GlobalCmd.cmdID) - ((MAX_BLOCK_DWORDS - length)*4)),
NULL)) {
uiPrintf("Error: Unable to successfully send EEPROM_WRITE_BLOCK command\n");
return 0;
}
}
if (checkLibError(devNum, 1)) return 0;
return 1;
}
void art_eepromWriteBlock
(
A_UINT32 devNum,
A_UINT32 startOffset,
A_UINT32 length,
A_UINT32 *buf
)
{
A_UINT32 ii = length, startAddr_ii=startOffset, len_ii, arrayStart_ii=0;
A_UINT32 max_locs_per_write;
if (sdio_client)
max_locs_per_write = 256;
else
max_locs_per_write = 256;
while( ii > 0)
{
if(ii > (max_locs_per_write-1))
{
len_ii = max_locs_per_write;
} else
{
len_ii = ii;
}
if (!art_eepromWriteBlock_256(devNum, startAddr_ii, len_ii, &(buf[arrayStart_ii]))) break;
startAddr_ii += len_ii;
ii -= len_ii;
arrayStart_ii += len_ii;
}
return;
}
static A_INT32 art_eepromReadBlock_256
(
A_UINT32 devNum,
A_UINT32 startOffset,
A_UINT32 length,
A_UINT32 *buf
)
{
A_UCHAR *pReadValues; /* pointer to the values that were read */
int ii;
//printf("SNOOP: setting eeprom mode\n");
//art_ap_reg_write(devNum, 0x0c004004, 0x90020044);
if(!configSetup.remote) {
eepromReadBlock(devNum,startOffset,length,buf);
} else {
/* setup the command struct to send */
GlobalCmd.cmdID = M_EEPROM_READ_BLOCK_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD.length = length;
GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD.startOffset = startOffset;
//printf(" Read Eeprom the Length %d", length);
/* send the command. Note that the size to send is only for num bytes want to write */
if(!artSendCmd(&GlobalCmd,
(sizeof(GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD) + sizeof(GlobalCmd.cmdID)),
(void **)(&pReadValues))) {
uiPrintf("Error: Unable to successfully send EEPROM_READ_BLOCK command\n");
return 0;
}
if(checkLibError(devNum, 1)) return 0;
/*for(ii =0 ;ii < length ; ii++)
{
printf ("Read Block is %x \n",GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue[ii]);
}*/
memcpy((void *)buf,(void *)pReadValues, length * 4);
}
if (checkLibError(devNum, 1)) return 0;
return 1;
}
void art_eepromReadBlock
(
A_UINT32 devNum,
A_UINT32 startOffset,
A_UINT32 length,
A_UINT32 *buf
)
{
A_UINT32 ii = length, startAddr_ii=startOffset, len_ii, arrayStart_ii=0;
A_UINT32 max_locs_per_read;
if (sdio_client)
max_locs_per_read = 128;
else
max_locs_per_read = 256;
while( ii > 0)
{
if(ii > (max_locs_per_read-1))
{
len_ii = max_locs_per_read;
} else
{
len_ii = ii;
}
if (!art_eepromReadBlock_256(devNum, startAddr_ii, len_ii, &(buf[arrayStart_ii]))) return;
startAddr_ii += len_ii;
ii -= len_ii;
arrayStart_ii += len_ii;
}
return;
}
void art_eepromReadLocs
(
A_UINT32 devNum,
A_UINT32 startOffset,
A_UINT32 length,
A_UINT8 *buf
)
{
A_UCHAR *pReadValues; /* pointer to the values that were read */
/* setup the command struct to send */
GlobalCmd.cmdID = M_EEPROM_READ_LOCS_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.EEPROM_READ_LOCS_CMD.length = length;
GlobalCmd.CMD_U.EEPROM_READ_LOCS_CMD.startOffset = startOffset;
/* send the command. Note that the size to send is only for num bytes want to write */
if(!artSendCmd(&GlobalCmd,
(sizeof(GlobalCmd.CMD_U.EEPROM_READ_LOCS_CMD) + sizeof(GlobalCmd.cmdID)),
(void **)(&pReadValues))) {
uiPrintf("Error: Unable to successfully send EEPROM_READ_LOCS command\n");
return ;
}
if(checkLibError(devNum, 1)) { uiPrintf("remote command error\n"); return ;}
memcpy((void *)buf,(void *)pReadValues, length * NUM_BYTES_PER_EEPROM_LOC);
}
#if 0
void art_eepromWriteLocs
(
A_UINT32 devNum,
A_UINT32 startOffset,
A_UINT32 length,
A_UINT8 *buf
)
{
A_UCHAR *pReadValues; /* pointer to the values that were read */
A_UINT32 *pBuffer;
//allocate a 32 bit value buffer for sending regular eeprom write command
pBuffer = malloc(sizeof(A_UINT32) * length);
if(pBuffer == NULL) {
uiPrintf("Error: unable to allocate buffer for sending eeprom write, eepromWriteLocs\n");
return;
}
for (i = 0; i < length; i++) {
pBuffer[i] = buf[i];
}
art_eepromWriteBlock
}
#endif
A_UINT32 art_checkRegs
(
A_UINT32 devNum
)
{
A_UINT32 *pRegValue;
A_UINT32 regValue;
if(!configSetup.remote || !configSetup.remote_exec)
{
regValue = checkRegs(devNum);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_CHECK_REGS_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
if (!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.cmdID),
(void **)&pRegValue))
{
uiPrintf("Error: Unable to successfully send EEPROM_READ_CMD command to client!\n");
return 0xdeadbeef;
}
regValue = *pRegValue;
}
if(checkLibError(devNum, 1)) {
return 0xdeadbeef;
}
return regValue;
}
A_UINT32 art_checkProm
(
A_UINT32 devNum,
A_UINT32 enablePrint
)
{
A_UINT32 *pRegValue;
A_UINT32 regValue;
if(!configSetup.remote || !configSetup.remote_exec)
{
regValue = checkProm(devNum, enablePrint);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_CHECK_PROM_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.SET_ONE_CMD.param = enablePrint;
if (!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.SET_ONE_CMD)+sizeof(GlobalCmd.cmdID),
(void **)&pRegValue))
{
uiPrintf("Error: Unable to successfully send CHECK_PROM_CMD command to client!\n");
return(1);
}
regValue = *pRegValue;
}
if(checkLibError(devNum, 1)) {
return 1;
}
return regValue;
}
void art_enableHwCal
(
A_UINT32 devNum,
A_UINT32 calFlag
)
{
if(!configSetup.remote || !configSetup.remote_exec)
{
//enableCal = calFlag;
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = ENABLE_HW_CAL_CMD;
GlobalCmd.devNum = (A_INT8) calFlag;
if (!artSendCmd(&GlobalCmd,sizeof(GlobalCmd.cmdID),
NULL))
{
uiPrintf("Error: Unable to successfully send ENABLE_HW_CAL_CMD command to client!\n");
}
}
checkLibError(devNum, 1);
}
void art_rereadProm
(
A_UINT32 devNum
)
{
if(!configSetup.remote || !configSetup.remote_exec)
{
rereadProm(devNum);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_REREAD_PROM_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
if (!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.cmdID),
NULL))
{
uiPrintf("Error: Unable to successfully send REREAD_PROM_CMD command to client!\n");
}
}
checkLibError(devNum, 1);
}
void art_changeChannel
(
A_UINT32 devNum,
A_UINT32 freq
)
{
//** the following added by ccshiang
{
double cf;
AgN4010_GetProperty(AgN4010_PropName_CenterFrequency_MHz,&cf);
if (freq > 10000) {
if (freq != (A_UINT32) (cf * 10))
AgN4010_SetProperty(AgN4010_PropName_CenterFrequency_MHz,(double) freq/10.0);
}
else {
if (freq != (A_UINT32) cf)
AgN4010_SetProperty(AgN4010_PropName_CenterFrequency_MHz,freq);
}
}
//** the above added by ccshiang
if(!configSetup.remote || !configSetup.remote_exec) {
changeChannel(devNum, freq);
} else {
// create cmd to send to client
GlobalCmd.cmdID = M_CHANGE_CHANNEL_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.SET_ONE_CMD.param = freq;
if ( !artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.SET_ONE_CMD)+sizeof(GlobalCmd.cmdID), NULL)) {
uiPrintf("Error: Unable to successfully send CHANGE_CHANNEL_CMD command to client!\n");
}
}
checkLibError(devNum, 1);
}
void art_txDataSetup
(
A_UINT32 devNum,
A_UINT32 rateMask,
A_UCHAR *dest,
A_UINT32 numDescPerRate,
A_UINT32 dataBodyLength,
A_UCHAR *dataPattern,
A_UINT32 dataPatternLength,
A_UINT32 retries,
A_UINT32 antenna,
A_UINT32 broadcast
)
{
int ii;
if(!configSetup.remote || !configSetup.remote_exec)
{
txDataSetup(devNum, rateMask, dest, numDescPerRate, dataBodyLength,
dataPattern, dataPatternLength, retries, antenna, broadcast);
} else {
// create cmd to send to client
GlobalCmd.cmdID = M_TX_DATA_SETUP_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.rateMask = rateMask;
memcpy(GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dest, dest, 6);
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.numDescPerRate = numDescPerRate;
//printf(">>>>>>rateMask %x\n",rateMask);
//GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.numDescPerRate = 10;
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataBodyLength = dataBodyLength;
memcpy(GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataPattern, dataPattern, dataPatternLength);
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataPatternLength = dataPatternLength;
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.retries = retries;
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.antenna = antenna;
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.broadcast = broadcast;
if (!artSendCmd(&GlobalCmd,
(sizeof(GlobalCmd.CMD_U.TX_DATA_SETUP_CMD)+
sizeof(GlobalCmd.cmdID)-
MAX_BLOCK_BYTES+
GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataPatternLength),
NULL))
{
uiPrintf("Error: Unable to successfully send TX_DATA_SETUP_CMD command to client!\n");
}
}
checkLibError(devNum, 1);
}
void art_txDataBegin
(
A_UINT32 devNum,
A_UINT32 timeout,
A_UINT32 remoteStats
)
{
//printf("*********TIME OUT IS %d*********\n",timeout);
if(!configSetup.remote || !configSetup.remote_exec)
{
txDataBegin(devNum, timeout, remoteStats);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_TX_DATA_BEGIN_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.TX_DATA_BEGIN_CMD.timeout = timeout;
GlobalCmd.CMD_U.TX_DATA_BEGIN_CMD.remoteStats = remoteStats;
if (!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.TX_DATA_BEGIN_CMD)+sizeof(GlobalCmd.cmdID),
NULL))
{
uiPrintf("Error: Unable to successfully send TX_DATA_BEGIN_CMD command to client!\n");
}
}
checkLibError(devNum, 1);
}
void art_rxDataSetup
(
A_UINT32 devNum,
A_UINT32 numDesc,
A_UINT32 dataBodyLength,
A_UINT32 enablePPM
)
{
if(!configSetup.remote || !configSetup.remote_exec)
{
rxDataSetup(devNum, numDesc, dataBodyLength, enablePPM);
}
else
{
// create cmd to send to client
//printf("CMD ID IS M_RX_DATA_SETUP_CMD_ID :\n");
GlobalCmd.cmdID = M_RX_DATA_SETUP_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.RX_DATA_SETUP_CMD.numDesc = numDesc;
GlobalCmd.CMD_U.RX_DATA_SETUP_CMD.dataBodyLength = dataBodyLength;
GlobalCmd.CMD_U.RX_DATA_SETUP_CMD.enablePPM = enablePPM;
if (!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.RX_DATA_SETUP_CMD)+sizeof(GlobalCmd.cmdID),
NULL))
{
uiPrintf("Error: Unable to successfully send RX_DATA_SETUP_CMD command to client!\n");
}
}
checkLibError(devNum, 1);
}
void art_rxDataBegin
(
A_UINT32 devNum,
A_UINT32 waitTime,
A_UINT32 timeout,
A_UINT32 remoteStats,
A_UINT32 enableCompare,
A_UCHAR *dataPattern,
A_UINT32 dataPatternLength
)
{
if(!configSetup.remote || !configSetup.remote_exec)
{
rxDataBegin(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_RX_DATA_BEGIN_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.waitTime = waitTime;
GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.timeout = timeout;
GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.remoteStats = remoteStats;
GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.enableCompare = enableCompare;
GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPatternLength = dataPatternLength;
memcpy(GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPattern, dataPattern, dataPatternLength);
if (!artSendCmd(&GlobalCmd,
(sizeof(GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD) +
sizeof(GlobalCmd.cmdID) -
MAX_BLOCK_BYTES +
GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPatternLength),
NULL))
{
uiPrintf("Error: Unable to successfully send RX_DATA_BEGIN_CMD command to client!\n");
}
}
// checkLibError(devNum, 1);
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -