?? art_if.c
字號:
A_UINT32 devNum,
A_UINT32 physAddr,
A_UINT32 length,
A_UCHAR *buf
)
{
A_UINT32 *pAddr;
A_UINT16 devIndex;
devIndex = (A_UINT16)dev2drv(devNum);
/* check to see if the size will make us bigger than the send buffer */
if (length > MAX_BLOCK_BYTES) {
uiPrintf("Error: block size too large, can only write %x bytes\n", MAX_BLOCK_BYTES);
return(0);
}
if (!configSetup.remote) {
#ifndef __ATH_DJGPPDOS__
/* write the memory */
if(hwMemWriteBlock(devIndex, buf, length, &(physAddr)) == -1) {
uiPrintf("Failed call to hwMemWriteBlock()\n");
return(0);
}
#else
uiPrintf(" NOt Implemented in DOS Version \n");
#endif
pAddr = &physAddr;
} else {
GlobalCmd.devNum = (A_INT8) devNum;
/* create cmd structure and send command */
GlobalCmd.cmdID = MEM_WRITE_BLOCK_CMD_ID;
GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD.physAddr = physAddr;
GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD.length = length;
memcpy(GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD.bytes, buf, length);
if(!artSendCmd(&GlobalCmd,
(sizeof(GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD)+sizeof(GlobalCmd.cmdID) - MAX_BLOCK_BYTES + length),
(void **)&pAddr))
{
uiPrintf("Error: Unable to successfully send MEM_WRITE_BLOCK command\n");
return 0;
}
}
return(*pAddr);
}
/**************************************************************************
* mem_write - Command for write a block of memory
*
* RETURNS: value write
*/
A_UINT32 art_memWrite
(
A_UINT32 devNum,
A_UINT32 physAddr,
A_UCHAR *bytesWrite,
A_UINT32 length
)
{
A_UINT32 ii, startAddr_ii, len_ii, arrayStart_ii;
A_UINT32 retAddr=0;
A_UINT32 ret;
A_UINT16 devIndex = (A_UINT16)dev2drv(devNum);
//uiPrintf("SNOOP::art_memWrite:devNum=%d:physAddr=%x:length=%d\n", devNum, physAddr, length);
// Split the writes into blocks of 2048 bytes only if the memory is already allocated
if (!physAddr) {
physAddr = art_memAlloc(length, 0, devNum);
}
ii = length;
startAddr_ii= physAddr;
arrayStart_ii=0;
while( ii > 0)
{
if(ii > MAX_MEM_CMD_BLOCK_SIZE) {
len_ii = MAX_MEM_CMD_BLOCK_SIZE;
} else {
len_ii = ii;
}
ret = mem_write_block_2048(devNum, startAddr_ii, len_ii, ((A_UCHAR *)bytesWrite+arrayStart_ii));
if (ret == 0) return 0;
if (retAddr == 0) retAddr = ret;
startAddr_ii += len_ii;
ii -= len_ii;
arrayStart_ii += len_ii;
}
return retAddr;
}
/**************************************************************************
* reg_read - Command for reading a register
*
* RETURNS: value read
*/
A_UINT32 art_regRead
(
A_UINT32 devNum,
A_UINT32 regOffset
)
{
A_UINT32 *pRegValue, regReturn;
A_UINT16 devIndex;
devIndex = (A_UINT16)dev2drv(devNum);
//sent_bytes=received_bytes=0;
//uiPrintf("SNOOP::art_regRead:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);
if (!configSetup.remote)
{
/* read the register */
if (thin_client) {
#ifndef __ATH_DJGPPDOS__
regReturn = hwMemRead32(devIndex, (globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->aregPhyAddr[globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->bar_select]) + regOffset);
#endif
//regReturn = hwMemRead32(devIndex, regOffset);
}
else {
regReturn = REGR(devNum, regOffset);
}
pRegValue = ®Return;
}
else
{
GlobalCmd.devNum = (A_INT8) devNum;
/* create cmd structure and send command */
GlobalCmd.cmdID = REG_READ_CMD_ID;
GlobalCmd.CMD_U.REG_READ_CMD.readAddr = regOffset;
if(!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.REG_READ_CMD)+sizeof(GlobalCmd.cmdID),
(void **)&pRegValue))
{
uiPrintf("Error: Unable to successfully send REG_READ command\n");
return 0xdeadbeef;
}
}
// q_uiPrintf("Register at offset %08lx: %08lx\n", regOffset, *pRegValue);
//uiPrintf("SNOOP::AFTER art_regRead:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);
//if(checkLibError(devNum, 1)) {
// return 0xdeadbeef;
//}
return(*pRegValue);
}
A_UINT32 art_hwReset(A_UINT32 devNum, A_UINT32 rMask) {
A_UINT32 *pRevIdValue;
A_UINT16 devIndex;
devIndex = (A_UINT16)dev2drv(devNum);
//uiPrintf("SNOOP::art_hwReset:rMask=%x\n", rMask);
GlobalCmd.devNum = (A_INT8) devNum;
/* create cmd structure and send command */
GlobalCmd.cmdID = M_HW_RESET_CMD_ID;
GlobalCmd.CMD_U.HW_RESET_CMD.resetMask = (A_UINT8) rMask;
if(!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.CMD_U.HW_RESET_CMD)+sizeof(GlobalCmd.cmdID),
(void **)&pRevIdValue))
{
uiPrintf("Error: Unable to successfully send HW_RESET command\n");
return 0xdeadbeef;
}
if(checkLibError(devNum, 1)) {
return 0xdeadbeef;
}
return(*pRevIdValue);
}
void art_pllProgram(A_UINT32 devNum, A_UINT32 turbo, A_UINT32 mode) {
A_UINT32 *pRevIdValue;
A_UINT16 devIndex;
devIndex = (A_UINT16)dev2drv(devNum);
GlobalCmd.devNum = (A_INT8) devNum;
/* create cmd structure and send command */
GlobalCmd.cmdID = M_PLL_PROGRAM_CMD_ID;
GlobalCmd.CMD_U.PLL_PROGRAM_CMD.turbo = (A_UINT8) turbo;
GlobalCmd.CMD_U.PLL_PROGRAM_CMD.mode = (A_UINT8) mode;
if(!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.PLL_PROGRAM_CMD)+sizeof(GlobalCmd.cmdID),
(void **)&pRevIdValue))
{
uiPrintf("Error: Unable to successfully send PLL_PROGRAM command\n");
}
}
void art_pciWrite(A_UINT32 devNum, PCI_VALUES *pPciValues, A_UINT32 length) {
A_UINT32 dataSize;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.cmdID = M_PCI_WRITE_CMD_ID;
GlobalCmd.CMD_U.PCI_WRITE_CMD.length = length;
memcpy(GlobalCmd.CMD_U.PCI_WRITE_CMD.pPciValues, pPciValues, length * sizeof(PCI_VALUES));
dataSize = sizeof(GlobalCmd.CMD_U.PCI_WRITE_CMD) - ((MAX_PCI_ENTRIES-length) * sizeof(PCI_VALUES));
if (!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.cmdID)+ dataSize, NULL))
{
uiPrintf("Error: Unable to successfully send PCI_WRITE command\n");
}
}
A_UINT32 art_calCheck (A_UINT32 devNum, A_UINT32 enableCal, A_UINT32 timeout ) {
A_UINT32 *pRegValue;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.cmdID = M_CAL_CHECK_CMD_ID;
GlobalCmd.CMD_U.CAL_CHECK_CMD.enableCal = enableCal;
GlobalCmd.CMD_U.CAL_CHECK_CMD.timeout = timeout;
if (!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.CMD_U.CAL_CHECK_CMD)+sizeof(GlobalCmd.cmdID), (void **)&pRegValue))
{
uiPrintf("Error: Unable to successfully send CAL_CHECK command\n");
return(0xdeadbeef);
}
return(*pRegValue);
}
/**************************************************************************
* reg_write - User interface command for writing a register
*
*
* RETURNS: 1 if OK, 0 if error
*/
A_UINT32 art_regWrite
(
A_UINT32 devNum,
A_UINT32 regOffset,
A_UINT32 regValue
)
{
A_UINT16 devIndex = (A_UINT16)dev2drv(devNum);
//sent_bytes=received_bytes=0;
//uiPrintf("SNOOP::art_regWrite:offset=%x\n", regOffset);
//uiPrintf("SNOOP::art_regWrite:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);
if (!configSetup.remote)
{
if (thin_client) {
#ifndef __ATH_DJGPPDOS__
hwMemWrite32(devIndex, (globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->aregPhyAddr[globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->bar_select]) + regOffset, regValue);
#endif
}
else {
REGW(devNum,regOffset,regValue);
}
}
else
{
GlobalCmd.devNum = (A_INT8) devNum;
/* create cmd structure and send command */
GlobalCmd.cmdID = REG_WRITE_CMD_ID;
GlobalCmd.CMD_U.REG_WRITE_CMD.writeAddr = regOffset;
GlobalCmd.CMD_U.REG_WRITE_CMD.regValue = regValue;
if(!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.REG_WRITE_CMD)+sizeof(GlobalCmd.cmdID),
NULL))
{
uiPrintf("Error: Unable to successfully send REG_WRITE command\n");
return 0;
}
}
//uiPrintf("SNOOP::AFTER art_regWrite:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);
return 1;
}
void art_setResetParams
(
A_UINT32 devNum,
A_CHAR *pFilename,
A_BOOL eePromLoad,
A_BOOL forceCfgLoad,
A_UCHAR mode,
A_UINT16 initCodeFlag
)
{
A_UINT32 *pRegValue;
if (!configSetup.remote || !configSetup.remote_exec)
{
setResetParams(devNum,pFilename,eePromLoad, forceCfgLoad, mode, initCodeFlag);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_SET_RESET_PARAMS_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.eePromLoad = (A_UINT32)eePromLoad;
GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.forceCfgLoad = (A_UINT32)forceCfgLoad;
GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.mode = (A_UINT32)mode;
GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.use_init = (A_UINT16)initCodeFlag;
if (pFilename) strcpy(GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.fileName, pFilename);
else GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.fileName[0] = '\0';
if ( !artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD)+sizeof(GlobalCmd.cmdID),
(void **)&pRegValue)) {
uiPrintf("Error: Unable to successfully send SET_RESET_PARAMS command to client!\n");
}
}
checkLibError(devNum, 1);
}
A_UINT32 art_resetDevice
(
A_UINT32 devNum,
A_UCHAR *mac,
A_UCHAR *bss,
A_UINT32 freq,
A_UINT32 turbo
)
{
//** 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 a quarter channel has been requested, then add the flag onto turbo
//do it here, so can contain the changes to one place
if(configSetup.quarterChannel) {
freq = freq * 10 + 25;
}
if(!configSetup.remote || !configSetup.remote_exec)
{
resetDevice(devNum, mac, bss, freq, turbo);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_RESET_DEVICE_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
memcpy(GlobalCmd.CMD_U.RESET_DEVICE_CMD.mac, mac, 6);
memcpy(GlobalCmd.CMD_U.RESET_DEVICE_CMD.bss, bss, 6);
GlobalCmd.CMD_U.RESET_DEVICE_CMD.freq = freq;
GlobalCmd.CMD_U.RESET_DEVICE_CMD.turbo = turbo;
if (!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.RESET_DEVICE_CMD)+sizeof(GlobalCmd.cmdID),
NULL))
{
uiPrintf("Error: Unable to successfully send RESET_DEVICE_CMD command to client, exiting!!\n");
closeEnvironment();
exit(0);
}
}
if(checkLibError(devNum, 1)) {
uiPrintf("Error: resetDevice command was unsuccessful, exiting!!\n");
// exit(0);
}
//printf("SNOOP: writing pll\n");
//Sleep(5);
//art_ap_reg_write(devNum, 0x0c000014, 0x502c);
//printf("SNOOP: pll written\n");
//Sleep(10);
return 1;
}
void art_getDeviceInfo
(
A_UINT32 devNum,
SUB_DEV_INFO *devStruct
)
{
A_UCHAR *pReadValues; /* pointer to the values that were read */
if (!configSetup.remote || !configSetup.remote_exec)
{
getDeviceInfo(devNum, devStruct);
}
else {
// create cmd to send to client
GlobalCmd.cmdID = M_GET_DEVICE_INFO_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
if ( !artSendCmd(&GlobalCmd, sizeof(GlobalCmd.cmdID),
(void **)&pReadValues))
{
uiPrintf("Error: Unable to successfully send GET_DEVICE_INFO_CMD command to client!\n");
return;
}
if(checkLibError(devNum, 1)) return;
memcpy((void *)devStruct,(void *)pReadValues,sizeof(SUB_DEV_INFO));
}
checkLibError(devNum, 1);
}
A_UINT32 art_eepromRead
(
A_UINT32 devNum,
A_UINT32 eepromOffset
)
{
A_UINT32 *pRegValue;
A_UINT32 eepromValue;
if (!configSetup.remote)
{
eepromValue = eepromRead(devNum, eepromOffset);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_EEPROM_READ_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.EEPROM_READ_CMD.offset = eepromOffset;
if ( !artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.EEPROM_READ_CMD)+sizeof(GlobalCmd.cmdID),
(void **)&pRegValue))
{
uiPrintf("Error: Unable to successfully send EEPROM_READ_CMD command to client!\n");
//printf("IF EEPRO< DEAD \n" );
return 0xdeadbeef;
}
eepromValue = *pRegValue;
//printf("SNOOP::art_eepromRead::eepromValue=%x:*pRegValue=%x\n", eepromValue, *pRegValue);
}
//printf("SNOOP::art_eepromRead::eepromValue=%x:*pRegValue=%x\n", eepromValue, *pRegValue);
if(checkLibError(devNum, 1)) {
return 0xdeadbeef;
}
return eepromValue;
}
void art_eepromWrite
(
A_UINT32 devNum,
A_UINT32 eepromOffset,
A_UINT32 eepromValue
)
{
if (!configSetup.remote)
{
eepromWrite(devNum, eepromOffset, eepromValue);
}
else
{
// create cmd to send to client
GlobalCmd.cmdID = M_EEPROM_WRITE_CMD_ID;
GlobalCmd.devNum = (A_INT8) devNum;
GlobalCmd.CMD_U.EEPROM_WRITE_CMD.offset = eepromOffset;
GlobalCmd.CMD_U.EEPROM_WRITE_CMD.value = eepromValue;
if (!artSendCmd(&GlobalCmd,
sizeof(GlobalCmd.CMD_U.EEPROM_WRITE_CMD)+sizeof(GlobalCmd.cmdID),
NULL))
{
uiPrintf("Error: Unable to successfully send EEPROM_WRITE_CMD command to client!\n");
}
}
checkLibError(devNum, 1);
}
static A_INT32 art_eepromWriteBlock_256
(
A_UINT32 devNum,
A_UINT32 startOffset,
A_UINT32 length,
A_UINT32 *buf
)
{
int ii;
if (!configSetup.remote) {
eepromWriteBlock(devNum,startOffset,length,buf);
} else {
/* setup the command struct to send */
GlobalCmd.cmdID = M_EEPROM_WRITE_BLOCK_CMD_ID;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -