| /* |
| * Copyright (c) 2007-2008 Atheros Communications Inc. |
| * |
| * Permission to use, copy, modify, and/or distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
| * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| #include "../80211core/cprecomp.h" |
| #include "hpani.h" |
| #include "hpusb.h" |
| #include "hpreg.h" |
| #include "../80211core/ratectrl.h" |
| |
| extern void zfIdlCmd(zdev_t* dev, u32_t* cmd, u16_t cmdLen); |
| |
| extern void zfCoreCwmBusy(zdev_t* dev, u16_t busy); |
| u16_t zfDelayWriteInternalReg(zdev_t* dev, u32_t addr, u32_t val); |
| u16_t zfFlushDelayWrite(zdev_t* dev); |
| |
| //#define zm_hp_priv(x) struct zsHpPriv* hpPriv=zgWlanDev.hpPrivate; |
| |
| void zfInitCmdQueue(zdev_t* dev) |
| { |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv = (struct zsHpPriv*)(wd->hpPrivate); |
| |
| zmw_declare_for_critical_section(); |
| |
| zmw_enter_critical_section(dev); |
| #ifdef ZM_XP_USB_MULTCMD |
| hpPriv->cmdTail = hpPriv->cmdHead = hpPriv->cmdSend = 0; |
| #else |
| hpPriv->cmdTail = hpPriv->cmdHead = 0; |
| #endif |
| hpPriv->cmdPending = 0; |
| hpPriv->cmd.delayWcmdCount = 0; |
| zmw_leave_critical_section(dev); |
| } |
| |
| u16_t zfPutCmd(zdev_t* dev, u32_t* cmd, u16_t cmdLen, u16_t src, u8_t* buf) |
| { |
| u16_t i; |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| /* Make sure command length < ZM_MAX_CMD_SIZE */ |
| zm_assert(cmdLen <= ZM_MAX_CMD_SIZE); |
| /* Make sure command queue not full */ |
| //zm_assert(((hpPriv->cmdTail+1) & (ZM_CMD_QUEUE_SIZE-1)) != hpPriv->cmdHead); |
| if (((hpPriv->cmdTail+1) & (ZM_CMD_QUEUE_SIZE-1)) == hpPriv->cmdHead ) { |
| zm_debug_msg0("CMD queue full!!"); |
| return 0; |
| } |
| |
| hpPriv->cmdQ[hpPriv->cmdTail].cmdLen = cmdLen; |
| hpPriv->cmdQ[hpPriv->cmdTail].src = src; |
| hpPriv->cmdQ[hpPriv->cmdTail].buf = buf; |
| for (i=0; i<(cmdLen>>2); i++) |
| { |
| hpPriv->cmdQ[hpPriv->cmdTail].cmd[i] = cmd[i]; |
| } |
| |
| hpPriv->cmdTail = (hpPriv->cmdTail+1) & (ZM_CMD_QUEUE_SIZE-1); |
| |
| return 0; |
| } |
| |
| u16_t zfGetCmd(zdev_t* dev, u32_t* cmd, u16_t* cmdLen, u16_t* src, u8_t** buf) |
| { |
| u16_t i; |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| if (hpPriv->cmdTail == hpPriv->cmdHead) |
| { |
| return 3; |
| } |
| |
| *cmdLen = hpPriv->cmdQ[hpPriv->cmdHead].cmdLen; |
| *src = hpPriv->cmdQ[hpPriv->cmdHead].src; |
| *buf = hpPriv->cmdQ[hpPriv->cmdHead].buf; |
| for (i=0; i<((*cmdLen)>>2); i++) |
| { |
| cmd[i] = hpPriv->cmdQ[hpPriv->cmdHead].cmd[i]; |
| } |
| |
| hpPriv->cmdHead = (hpPriv->cmdHead+1) & (ZM_CMD_QUEUE_SIZE-1); |
| |
| return 0; |
| } |
| |
| #ifdef ZM_XP_USB_MULTCMD |
| void zfSendCmdEx(zdev_t* dev) |
| { |
| u32_t ncmd[ZM_MAX_CMD_SIZE/4]; |
| u16_t ncmdLen = 0; |
| u16_t cmdFlag = 0; |
| u16_t i; |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| zmw_declare_for_critical_section(); |
| |
| zmw_enter_critical_section(dev); |
| |
| if (hpPriv->cmdPending == 0) |
| { |
| if (hpPriv->cmdTail != hpPriv->cmdSend) |
| { |
| cmdFlag = 1; |
| /* Get queueing command */ |
| ncmdLen= hpPriv->cmdQ[hpPriv->cmdSend].cmdLen; |
| for (i=0; i<(ncmdLen>>2); i++) |
| { |
| ncmd[i] = hpPriv->cmdQ[hpPriv->cmdSend].cmd[i]; |
| } |
| hpPriv->cmdSend = (hpPriv->cmdSend+1) & (ZM_CMD_QUEUE_SIZE-1); |
| |
| hpPriv->cmdPending = 1; |
| } |
| } |
| |
| zmw_leave_critical_section(dev); |
| |
| if ((cmdFlag == 1)) |
| { |
| zfIdlCmd(dev, ncmd, ncmdLen); |
| } |
| } |
| |
| void zfiSendCmdComp(zdev_t* dev) |
| { |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| zmw_declare_for_critical_section(); |
| |
| zmw_enter_critical_section(dev); |
| hpPriv->cmdPending = 0; |
| zmw_leave_critical_section(dev); |
| |
| zfSendCmdEx(dev); |
| } |
| #endif |
| |
| u16_t zfIssueCmd(zdev_t* dev, u32_t* cmd, u16_t cmdLen, u16_t src, u8_t* buf) |
| { |
| u16_t cmdFlag = 0; |
| u16_t ret; |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| zmw_declare_for_critical_section(); |
| |
| zm_msg2_mm(ZM_LV_1, "cmdLen=", cmdLen); |
| |
| zmw_enter_critical_section(dev); |
| |
| #ifdef ZM_XP_USB_MULTCMD |
| ret = zfPutCmd(dev, cmd, cmdLen, src, buf); |
| zmw_leave_critical_section(dev); |
| |
| if (ret != 0) |
| { |
| return 1; |
| } |
| |
| zfSendCmdEx(dev); |
| #else |
| if (hpPriv->cmdPending == 0) |
| { |
| hpPriv->cmdPending = 1; |
| cmdFlag = 1; |
| } |
| ret = zfPutCmd(dev, cmd, cmdLen, src, buf); |
| |
| zmw_leave_critical_section(dev); |
| |
| if (ret != 0) |
| { |
| return 1; |
| } |
| |
| if (cmdFlag == 1) |
| { |
| zfIdlCmd(dev, cmd, cmdLen); |
| } |
| #endif |
| return 0; |
| } |
| |
| void zfIdlRsp(zdev_t* dev, u32_t* rsp, u16_t rspLen) |
| { |
| u32_t cmd[ZM_MAX_CMD_SIZE/4]; |
| u16_t cmdLen; |
| u16_t src; |
| u8_t* buf; |
| u32_t ncmd[ZM_MAX_CMD_SIZE/4]; |
| u16_t ncmdLen = 0; |
| u16_t ret; |
| u16_t cmdFlag = 0; |
| u16_t i; |
| s32_t nf; |
| s32_t noisefloor[4]; |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| |
| zmw_declare_for_critical_section(); |
| |
| zmw_enter_critical_section(dev); |
| |
| ret = zfGetCmd(dev, cmd, &cmdLen, &src, &buf); |
| #if 0 |
| zm_assert(ret == 0); |
| #else |
| if (ret != 0) |
| { |
| zm_debug_msg0("Error IdlRsp because none cmd!!\n"); |
| #ifndef ZM_XP_USB_MULTCMD |
| zmw_leave_critical_section(dev); |
| return; |
| #endif |
| } |
| #endif |
| #ifdef ZM_XP_USB_MULTCMD |
| zmw_leave_critical_section(dev); |
| #else |
| if (hpPriv->cmdTail != hpPriv->cmdHead) |
| { |
| cmdFlag = 1; |
| /* Get queueing command */ |
| ncmdLen= hpPriv->cmdQ[hpPriv->cmdHead].cmdLen; |
| for (i=0; i<(ncmdLen>>2); i++) |
| { |
| ncmd[i] = hpPriv->cmdQ[hpPriv->cmdHead].cmd[i]; |
| } |
| } |
| else |
| { |
| hpPriv->cmdPending = 0; |
| } |
| |
| zmw_leave_critical_section(dev); |
| |
| if (cmdFlag == 1) |
| { |
| zfIdlCmd(dev, ncmd, ncmdLen); |
| } |
| #endif |
| if (src == ZM_OID_READ) |
| { |
| ZM_PERFORMANCE_REG(dev, 0x11772c, rsp[1]); |
| zfwDbgReadRegDone(dev, cmd[1], rsp[1]); |
| } |
| else if (src == ZM_OID_FLASH_CHKSUM) |
| { |
| zfwDbgGetFlashChkSumDone(dev, rsp+1); |
| } |
| else if (src == ZM_OID_FLASH_READ) |
| { |
| u32_t datalen; |
| u16_t i; |
| |
| datalen = (rsp[0] & 255); |
| |
| zfwDbgReadFlashDone(dev, cmd[1], rsp+1, datalen); |
| } |
| else if (src == ZM_OID_FLASH_PROGRAM) |
| { |
| /* Non do */ |
| } |
| else if (src == ZM_OID_WRITE) |
| { |
| zfwDbgWriteRegDone(dev, cmd[1], cmd[2]); |
| } |
| else if (src == ZM_OID_TALLY) |
| { |
| zfCollectHWTally(dev, rsp, 0); |
| } |
| else if (src == ZM_OID_TALLY_APD) |
| { |
| zfCollectHWTally(dev, rsp, 1); |
| zfwDbgReadTallyDone(dev); |
| #ifdef ZM_ENABLE_BA_RATECTRL |
| zfRateCtrlAggrSta(dev); |
| #endif |
| } |
| else if (src == ZM_OID_DKTX_STATUS) |
| { |
| zm_debug_msg0("src = zm_OID_DKTX_STATUS"); |
| zfwDbgQueryHwTxBusyDone(dev, rsp[1]); |
| } |
| else if (src == ZM_CMD_SET_FREQUENCY) |
| { |
| |
| //#ifdef ZM_OTUS_ENABLE_RETRY_FREQ_CHANGE |
| #if 0 |
| zm_debug_msg1("Retry Set Frequency = ", rsp[1]); |
| |
| #if 1 |
| // Read the Noise Floor value ! |
| nf = ((rsp[2]>>19) & 0x1ff); |
| if ((nf & 0x100) != 0x0) |
| { |
| noisefloor[0] = 0 - ((nf ^ 0x1ff) + 1); |
| } |
| else |
| { |
| noisefloor[0] = nf; |
| } |
| |
| zm_debug_msg1("Noise Floor[1] = ", noisefloor[0]); |
| |
| nf = ((rsp[3]>>19) & 0x1ff); |
| if ((nf & 0x100) != 0x0) |
| { |
| noisefloor[1] = 0 - ((nf ^ 0x1ff) + 1); |
| } |
| else |
| { |
| noisefloor[1] = nf; |
| } |
| |
| zm_debug_msg1("Noise Floor[2] = ", noisefloor[1]); |
| zm_debug_msg1("Is Site Survey = ", hpPriv->isSiteSurvey); |
| #endif |
| |
| if ( (rsp[1] && hpPriv->freqRetryCounter == 0) || |
| (((noisefloor[0]>-60)||(noisefloor[1]>-60)) && hpPriv->freqRetryCounter==0) || |
| ((abs(noisefloor[0]-noisefloor[1])>=9) && hpPriv->freqRetryCounter==0) ) |
| { |
| zm_debug_msg0("Retry to issue the frequency change command"); |
| |
| if ( hpPriv->recordFreqRetryCounter == 1 ) |
| { |
| zm_debug_msg0("Cold Reset"); |
| |
| zfHpSetFrequencyEx(dev, hpPriv->latestFrequency, |
| hpPriv->latestBw40, |
| hpPriv->latestExtOffset, |
| 2); |
| |
| if ( hpPriv->isSiteSurvey != 2 ) |
| { |
| hpPriv->freqRetryCounter++; |
| } |
| hpPriv->recordFreqRetryCounter = 0; |
| } |
| else |
| { |
| zfHpSetFrequencyEx(dev, hpPriv->latestFrequency, |
| hpPriv->latestBw40, |
| hpPriv->latestExtOffset, |
| 0); |
| } |
| hpPriv->recordFreqRetryCounter++; |
| } |
| else |
| #endif |
| |
| /* ret: Bit0: AGC calibration 0=>finish 1=>unfinish */ |
| /* Bit1: Noise calibration 0=>finish 1=>unfinish */ |
| /* Bit2: Noise calibration finish, but NF value unexcepted => 1 */ |
| if ( (rsp[1] & 0x1) || (rsp[1] & 0x4) ) |
| { |
| zm_debug_msg1("Set Frequency fail : ret = ", rsp[1]); |
| |
| /* 1. AGC Calibration fail */ |
| /* 2. Noise Calibration finish but error NoiseFloor value */ |
| /* and not in sitesurvey, try more twice */ |
| if ( hpPriv->isSiteSurvey == 2 ) |
| { |
| if ( hpPriv->recordFreqRetryCounter < 2 ) |
| { |
| /* cold reset */ |
| zfHpSetFrequencyEx(dev, hpPriv->latestFrequency, |
| hpPriv->latestBw40, |
| hpPriv->latestExtOffset, |
| 2); |
| hpPriv->recordFreqRetryCounter++; |
| zm_debug_msg1("Retry to issue the frequency change command(cold reset) counter = ", hpPriv->recordFreqRetryCounter); |
| } |
| else |
| { |
| /* Fail : we would not accept this result! */ |
| zm_debug_msg0("\n\n\n\n Fail twice cold reset \n\n\n\n"); |
| hpPriv->coldResetNeedFreq = 0; |
| hpPriv->recordFreqRetryCounter = 0; |
| zfCoreSetFrequencyComplete(dev); |
| } |
| } |
| else |
| { |
| /* in sitesurvey, coldreset in next channel */ |
| hpPriv->coldResetNeedFreq = 1; |
| hpPriv->recordFreqRetryCounter = 0; |
| zfCoreSetFrequencyComplete(dev); |
| } |
| } |
| else if (rsp[1] & 0x2) |
| { |
| zm_debug_msg1("Set Frequency fail 2 : ret = ", rsp[1]); |
| |
| /* Noise Calibration un-finish */ |
| /* and not in sitesurvey, try more once */ |
| if ( hpPriv->isSiteSurvey == 2 ) |
| { |
| if ( hpPriv->recordFreqRetryCounter < 1 ) |
| { |
| /* cold reset */ |
| zfHpSetFrequencyEx(dev, hpPriv->latestFrequency, |
| hpPriv->latestBw40, |
| hpPriv->latestExtOffset, |
| 2); |
| hpPriv->recordFreqRetryCounter++; |
| zm_debug_msg1("2 Retry to issue the frequency change command(cold reset) counter = ", hpPriv->recordFreqRetryCounter); |
| } |
| else |
| { |
| /* Fail : we would not accept this result! */ |
| zm_debug_msg0("\n\n\n\n 2 Fail twice cold reset \n\n\n\n"); |
| hpPriv->coldResetNeedFreq = 0; |
| hpPriv->recordFreqRetryCounter = 0; |
| zfCoreSetFrequencyComplete(dev); |
| } |
| } |
| else |
| { |
| /* in sitesurvey, skip this frequency */ |
| hpPriv->coldResetNeedFreq = 0; |
| hpPriv->recordFreqRetryCounter = 0; |
| zfCoreSetFrequencyComplete(dev); |
| } |
| } |
| //else if (rsp[1] & 0x4) |
| //{ |
| // zm_debug_msg1("Set Frequency fail 3 : ret = ", rsp[1]); |
| // hpPriv->coldResetNeedFreq = 0; |
| // hpPriv->recordFreqRetryCounter = 0; |
| // zfCoreSetFrequencyComplete(dev); |
| //} |
| else |
| { |
| //hpPriv->freqRetryCounter = 0; |
| zm_debug_msg2(" return complete, ret = ", rsp[1]); |
| |
| /* set bb_heavy_clip_enable */ |
| if (hpPriv->enableBBHeavyClip && hpPriv->hwBBHeavyClip && |
| hpPriv->doBBHeavyClip) |
| { |
| u32_t setValue = 0x200; |
| |
| setValue |= hpPriv->setValueHeavyClip; |
| |
| //zm_dbg(("Do heavy clip setValue = %d\n", setValue)); |
| |
| zfDelayWriteInternalReg(dev, 0x99e0+0x1bc000, setValue); |
| zfFlushDelayWrite(dev); |
| } |
| |
| hpPriv->coldResetNeedFreq = 0; |
| hpPriv->recordFreqRetryCounter = 0; |
| zfCoreSetFrequencyComplete(dev); |
| } |
| |
| #if 1 |
| // Read the Noise Floor value ! |
| nf = ((rsp[2]>>19) & 0x1ff); |
| if ((nf & 0x100) != 0x0) |
| { |
| noisefloor[0] = 0 - ((nf ^ 0x1ff) + 1); |
| } |
| else |
| { |
| noisefloor[0] = nf; |
| } |
| |
| //zm_debug_msg1("Noise Floor[1] = ", noisefloor[0]); |
| |
| nf = ((rsp[3]>>19) & 0x1ff); |
| if ((nf & 0x100) != 0x0) |
| { |
| noisefloor[1] = 0 - ((nf ^ 0x1ff) + 1); |
| } |
| else |
| { |
| noisefloor[1] = nf; |
| } |
| |
| //zm_debug_msg1("Noise Floor[2] = ", noisefloor[1]); |
| |
| nf = ((rsp[5]>>23) & 0x1ff); |
| if ((nf & 0x100) != 0x0) |
| { |
| noisefloor[2] = 0 - ((nf ^ 0x1ff) + 1); |
| } |
| else |
| { |
| noisefloor[2] = nf; |
| } |
| |
| //zm_debug_msg1("Noise Floor ext[1] = ", noisefloor[2]); |
| |
| nf = ((rsp[6]>>23) & 0x1ff); |
| if ((nf & 0x100) != 0x0) |
| { |
| noisefloor[3] = 0 - ((nf ^ 0x1ff) + 1); |
| } |
| else |
| { |
| noisefloor[3] = nf; |
| } |
| |
| //zm_debug_msg1("Noise Floor ext[2] = ", noisefloor[3]); |
| |
| //zm_debug_msg1("Is Site Survey = ", hpPriv->isSiteSurvey); |
| #endif |
| } |
| else if (src == ZM_CMD_SET_KEY) |
| { |
| zfCoreSetKeyComplete(dev); |
| } |
| else if (src == ZM_CWM_READ) |
| { |
| zm_msg2_mm(ZM_LV_0, "CWM rsp[1]=", rsp[1]); |
| zm_msg2_mm(ZM_LV_0, "CWM rsp[2]=", rsp[2]); |
| zfCoreCwmBusy(dev, zfCwmIsExtChanBusy(rsp[1], rsp[2])); |
| } |
| else if (src == ZM_MAC_READ) |
| { |
| /* rsp[1] = ZM_SEEPROM_MAC_ADDRESS_OFFSET; */ |
| /* rsp[2] = ZM_SEEPROM_MAC_ADDRESS_OFFSET+4; */ |
| /* rsp[3] = ZM_SEEPROM_REGDOMAIN_OFFSET; */ |
| /* rsp[4] = ZM_SEEPROM_VERISON_OFFSET; */ |
| /* rsp[5] = ZM_SEEPROM_HARDWARE_TYPE_OFFSET; */ |
| /* rsp[6] = ZM_SEEPROM_HW_HEAVY_CLIP; */ |
| |
| u8_t addr[6], CCS, WWR; |
| u16_t CountryDomainCode; |
| |
| /* BB heavy clip */ |
| //hpPriv->eepromHeavyClipFlag = (u8_t)((rsp[6]>>24) & 0xff); // force enable 8107 |
| //zm_msg2_mm(ZM_LV_0, "eepromHeavyClipFlag", hpPriv->eepromHeavyClipFlag); |
| #if 0 |
| if (hpPriv->hwBBHeavyClip) |
| { |
| zm_msg0_mm(ZM_LV_0, "enable BB Heavy Clip"); |
| } |
| else |
| { |
| zm_msg0_mm(ZM_LV_0, "Not enable BB Heavy Clip"); |
| } |
| #endif |
| zm_msg2_mm(ZM_LV_0, "MAC rsp[1]=", rsp[1]); |
| zm_msg2_mm(ZM_LV_0, "MAC rsp[2]=", rsp[2]); |
| |
| addr[0] = (u8_t)(rsp[1] & 0xff); |
| addr[1] = (u8_t)((rsp[1]>>8) & 0xff); |
| addr[2] = (u8_t)((rsp[1]>>16) & 0xff); |
| addr[3] = (u8_t)((rsp[1]>>24) & 0xff); |
| addr[4] = (u8_t)(rsp[2] & 0xff); |
| addr[5] = (u8_t)((rsp[2]>>8) & 0xff); |
| /*#ifdef ZM_FB50 |
| addr[0] = (u8_t)(0 & 0xff); |
| addr[1] = (u8_t)(3 & 0xff); |
| addr[2] = (u8_t)(127 & 0xff); |
| addr[3] = (u8_t)(0 & 0xff); |
| addr[4] = (u8_t)(9 & 0xff); |
| addr[5] = (u8_t)(11 & 0xff); |
| #endif*/ |
| |
| zfDelayWriteInternalReg(dev, ZM_MAC_REG_MAC_ADDR_L, |
| ((((u32_t)addr[3])<<24) | (((u32_t)addr[2])<<16) | (((u32_t)addr[1])<<8) | addr[0])); |
| zfDelayWriteInternalReg(dev, ZM_MAC_REG_MAC_ADDR_H, |
| ((((u32_t)addr[5])<<8) | addr[4])); |
| zfFlushDelayWrite(dev); |
| |
| wd->ledStruct.ledMode[0] = (u16_t)(rsp[5]&0xffff); |
| wd->ledStruct.ledMode[1] = (u16_t)(rsp[5]>>16); |
| zm_msg2_mm(ZM_LV_0, "ledMode[0]=", wd->ledStruct.ledMode[0]); |
| zm_msg2_mm(ZM_LV_0, "ledMode[1]=", wd->ledStruct.ledMode[1]); |
| |
| /* Regulatory Related Setting */ |
| zm_msg2_mm(ZM_LV_0, "RegDomain rsp=", rsp[3]); |
| zm_msg2_mm(ZM_LV_0, "OpFlags+EepMisc=", rsp[4]); |
| hpPriv->OpFlags = (u8_t)((rsp[4]>>16) & 0xff); |
| if ((rsp[2] >> 24) == 0x1) //Tx mask == 0x1 |
| { |
| zm_msg0_mm(ZM_LV_0, "OTUS 1x2"); |
| hpPriv->halCapability |= ZM_HP_CAP_11N_ONE_TX_STREAM; |
| } |
| else |
| { |
| zm_msg0_mm(ZM_LV_0, "OTUS 2x2"); |
| } |
| if (hpPriv->OpFlags & 0x1) |
| { |
| hpPriv->halCapability |= ZM_HP_CAP_5G; |
| } |
| if (hpPriv->OpFlags & 0x2) |
| { |
| hpPriv->halCapability |= ZM_HP_CAP_2G; |
| } |
| |
| |
| CCS = (u8_t)((rsp[3] & 0x8000) >> 15); |
| WWR = (u8_t)((rsp[3] & 0x4000) >> 14); |
| CountryDomainCode = (u16_t)(rsp[3] & 0x3FFF); |
| |
| if (rsp[3] != 0xffffffff) |
| { |
| if (CCS) |
| { |
| //zm_debug_msg0("CWY - Get Regulation Table from Country Code"); |
| zfHpGetRegulationTablefromCountry(dev, CountryDomainCode); |
| } |
| else |
| { |
| //zm_debug_msg0("CWY - Get Regulation Table from Reg Domain"); |
| zfHpGetRegulationTablefromRegionCode(dev, CountryDomainCode); |
| } |
| if (WWR) |
| { |
| //zm_debug_msg0("CWY - Enable 802.11d"); |
| /* below line shall be unmarked after A band is ready */ |
| //zfiWlanSetDot11DMode(dev, 1); |
| } |
| } |
| else |
| { |
| zfHpGetRegulationTablefromRegionCode(dev, NO_ENUMRD); |
| } |
| |
| zfCoreMacAddressNotify(dev, addr); |
| |
| } |
| else if (src == ZM_EEPROM_READ) |
| { |
| #if 0 |
| u8_t addr[6], CCS, WWR; |
| u16_t CountryDomainCode; |
| #endif |
| for (i=0; i<ZM_HAL_MAX_EEPROM_PRQ; i++) |
| { |
| if (hpPriv->eepromImageIndex < 1024) |
| { |
| hpPriv->eepromImage[hpPriv->eepromImageIndex++] = rsp[i+1]; |
| } |
| } |
| |
| if (hpPriv->eepromImageIndex == (ZM_HAL_MAX_EEPROM_REQ*ZM_HAL_MAX_EEPROM_PRQ)) |
| { |
| #if 0 |
| for (i=0; i<1024; i++) |
| { |
| zm_msg2_mm(ZM_LV_0, "index=", i); |
| zm_msg2_mm(ZM_LV_0, "eepromImage=", hpPriv->eepromImage[i]); |
| } |
| #endif |
| zm_msg2_mm(ZM_LV_0, "MAC [1]=", hpPriv->eepromImage[0x20c/4]); |
| zm_msg2_mm(ZM_LV_0, "MAC [2]=", hpPriv->eepromImage[0x210/4]); |
| #if 0 |
| addr[0] = (u8_t)(hpPriv->eepromImage[0x20c/4] & 0xff); |
| addr[1] = (u8_t)((hpPriv->eepromImage[0x20c/4]>>8) & 0xff); |
| addr[2] = (u8_t)((hpPriv->eepromImage[0x20c/4]>>16) & 0xff); |
| addr[3] = (u8_t)((hpPriv->eepromImage[0x20c/4]>>24) & 0xff); |
| addr[4] = (u8_t)(hpPriv->eepromImage[0x210/4] & 0xff); |
| addr[5] = (u8_t)((hpPriv->eepromImage[0x210/4]>>8) & 0xff); |
| |
| zfCoreMacAddressNotify(dev, addr); |
| |
| zfDelayWriteInternalReg(dev, ZM_MAC_REG_MAC_ADDR_L, |
| ((((u32_t)addr[3])<<24) | (((u32_t)addr[2])<<16) | (((u32_t)addr[1])<<8) | addr[0])); |
| zfDelayWriteInternalReg(dev, ZM_MAC_REG_MAC_ADDR_H, |
| ((((u32_t)addr[5])<<8) | addr[4])); |
| zfFlushDelayWrite(dev); |
| |
| /* Regulatory Related Setting */ |
| zm_msg2_mm(ZM_LV_0, "RegDomain =", hpPriv->eepromImage[0x208/4]); |
| CCS = (u8_t)((hpPriv->eepromImage[0x208/4] & 0x8000) >> 15); |
| WWR = (u8_t)((hpPriv->eepromImage[0x208/4] & 0x4000) >> 14); |
| /* below line shall be unmarked after A band is ready */ |
| //CountryDomainCode = (u16_t)(hpPriv->eepromImage[0x208/4] & 0x3FFF); |
| CountryDomainCode = 8; |
| if (CCS) |
| { |
| //zm_debug_msg0("CWY - Get Regulation Table from Country Code"); |
| zfHpGetRegulationTablefromCountry(dev, CountryDomainCode); |
| } |
| else |
| { |
| //zm_debug_msg0("CWY - Get Regulation Table from Reg Domain"); |
| zfHpGetRegulationTablefromRegionCode(dev, CountryDomainCode); |
| } |
| if (WWR) |
| { |
| //zm_debug_msg0("CWY - Enable 802.11d"); |
| /* below line shall be unmarked after A band is ready */ |
| //zfiWlanSetDot11DMode(dev, 1); |
| } |
| #endif |
| zfCoreHalInitComplete(dev); |
| } |
| else |
| { |
| hpPriv->eepromImageRdReq++; |
| zfHpLoadEEPROMFromFW(dev); |
| } |
| } |
| else if (src == ZM_EEPROM_WRITE) |
| { |
| zfwDbgWriteEepromDone(dev, cmd[1], cmd[2]); |
| } |
| else if (src == ZM_ANI_READ) |
| { |
| u32_t cycleTime, ctlClear; |
| |
| zm_msg2_mm(ZM_LV_0, "ANI rsp[1]=", rsp[1]); |
| zm_msg2_mm(ZM_LV_0, "ANI rsp[2]=", rsp[2]); |
| zm_msg2_mm(ZM_LV_0, "ANI rsp[3]=", rsp[3]); |
| zm_msg2_mm(ZM_LV_0, "ANI rsp[4]=", rsp[4]); |
| |
| hpPriv->ctlBusy += rsp[1]; |
| hpPriv->extBusy += rsp[2]; |
| |
| cycleTime = 100000; //100 miniseconds |
| |
| if (cycleTime > rsp[1]) |
| { |
| ctlClear = (cycleTime - rsp[1]) / 100; |
| } |
| else |
| { |
| ctlClear = 0; |
| } |
| if (wd->aniEnable) |
| zfHpAniArPoll(dev, ctlClear, rsp[3], rsp[4]); |
| } |
| else if (src == ZM_CMD_ECHO) |
| { |
| if ( ((struct zsHpPriv*)wd->hpPrivate)->halReInit ) |
| { |
| zfCoreHalInitComplete(dev); |
| ((struct zsHpPriv*)wd->hpPrivate)->halReInit = 0; |
| } |
| else |
| { |
| zfHpLoadEEPROMFromFW(dev); |
| } |
| } |
| else if (src == ZM_OID_FW_DL_INIT) |
| { |
| zfwDbgDownloadFwInitDone(dev); |
| } |
| return; |
| } |
| |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfWriteRegInternalReg */ |
| /* Write on chip internal register immediately. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* val : value */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Stephen Chen ZyDAS Technology Corporation 2005.11 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfWriteRegInternalReg(zdev_t* dev, u32_t addr, u32_t val) |
| { |
| u32_t cmd[3]; |
| u16_t ret; |
| |
| cmd[0] = 0x00000108; |
| cmd[1] = addr; |
| cmd[2] = val; |
| |
| ret = zfIssueCmd(dev, cmd, 12, ZM_OID_INTERNAL_WRITE, NULL); |
| return ret; |
| } |
| |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfDelayWriteInternalReg */ |
| /* Write on chip internal register, write operation may be */ |
| /* postponed to form a multiple write command. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* val : value */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : command been postponed */ |
| /* 1 : commands been executed */ |
| /* */ |
| /* AUTHOR */ |
| /* Stephen Chen ZyDAS Technology Corporation 2005.11 */ |
| /* */ |
| /************************************************************************/ |
| u16_t zfDelayWriteInternalReg(zdev_t* dev, u32_t addr, u32_t val) |
| { |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u16_t i; |
| u16_t ret; |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| zmw_declare_for_critical_section(); |
| |
| /* enter critical section */ |
| zmw_enter_critical_section(dev); |
| |
| /* Store command to global buffer */ |
| hpPriv->cmd.delayWcmdAddr[hpPriv->cmd.delayWcmdCount] = addr; |
| hpPriv->cmd.delayWcmdVal[hpPriv->cmd.delayWcmdCount++] = val; |
| |
| /* If pending command reach size limit */ |
| if ((hpPriv->cmd.delayWcmdCount) >= ((ZM_MAX_CMD_SIZE - 4) >> 3)) |
| { |
| cmd[0] = 0x00000100 + (hpPriv->cmd.delayWcmdCount<<3); |
| |
| /* copy command to cmd buffer */ |
| for (i=0; i<hpPriv->cmd.delayWcmdCount; i++) |
| { |
| cmd[1+(i<<1)] = hpPriv->cmd.delayWcmdAddr[i]; |
| cmd[2+(i<<1)] = hpPriv->cmd.delayWcmdVal[i]; |
| } |
| /* reset pending command */ |
| hpPriv->cmd.delayWcmdCount = 0; |
| |
| /* leave critical section */ |
| zmw_leave_critical_section(dev); |
| |
| /* issue write command */ |
| ret = zfIssueCmd(dev, cmd, 4+(i<<3), ZM_OID_INTERNAL_WRITE, NULL); |
| |
| return 1; |
| } |
| else |
| { |
| /* leave critical section */ |
| zmw_leave_critical_section(dev); |
| |
| return 0; |
| } |
| } |
| |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfFlushDelayWrite */ |
| /* Flush pending write command. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : no pending command */ |
| /* 1 : commands been executed */ |
| /* */ |
| /* AUTHOR */ |
| /* Stephen Chen ZyDAS Technology Corporation 2005.11 */ |
| /* */ |
| /************************************************************************/ |
| u16_t zfFlushDelayWrite(zdev_t* dev) |
| { |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u16_t i; |
| u16_t ret; |
| struct zsHpPriv* hpPriv; |
| |
| zmw_get_wlan_dev(dev); |
| hpPriv=wd->hpPrivate; |
| |
| zmw_declare_for_critical_section(); |
| |
| /* enter critical section */ |
| zmw_enter_critical_section(dev); |
| |
| /* If there is pending command */ |
| if (hpPriv->cmd.delayWcmdCount > 0) |
| { |
| cmd[0] = 0x00000100 + (hpPriv->cmd.delayWcmdCount<<3); |
| |
| /* copy command to cmd buffer */ |
| for (i=0; i<hpPriv->cmd.delayWcmdCount; i++) |
| { |
| cmd[1+(i<<1)] = hpPriv->cmd.delayWcmdAddr[i]; |
| cmd[2+(i<<1)] = hpPriv->cmd.delayWcmdVal[i]; |
| } |
| /* reset pending command */ |
| hpPriv->cmd.delayWcmdCount = 0; |
| |
| /* leave critical section */ |
| zmw_leave_critical_section(dev); |
| |
| /* issue write command */ |
| ret = zfIssueCmd(dev, cmd, 4+(i<<3), ZM_OID_INTERNAL_WRITE, NULL); |
| |
| return 1; |
| } |
| else |
| { |
| /* leave critical section */ |
| zmw_leave_critical_section(dev); |
| |
| return 0; |
| } |
| } |
| |
| |
| u32_t zfiDbgDelayWriteReg(zdev_t* dev, u32_t addr, u32_t val) |
| { |
| zfDelayWriteInternalReg(dev, addr, val); |
| return 0; |
| } |
| |
| u32_t zfiDbgFlushDelayWrite(zdev_t* dev) |
| { |
| zfFlushDelayWrite(dev); |
| return 0; |
| } |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgWriteReg */ |
| /* Write register. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* val : value */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Stephen Chen ZyDAS Technology Corporation 2005.10 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgWriteReg(zdev_t* dev, u32_t addr, u32_t val) |
| { |
| u32_t cmd[3]; |
| u16_t ret; |
| |
| cmd[0] = 0x00000108; |
| cmd[1] = addr; |
| cmd[2] = val; |
| |
| ret = zfIssueCmd(dev, cmd, 12, ZM_OID_WRITE, 0); |
| return ret; |
| } |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgWriteFlash */ |
| /* Write flash. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* val : value */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Yjsung ZyDAS Technology Corporation 2007.02 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgWriteFlash(zdev_t* dev, u32_t addr, u32_t val) |
| { |
| u32_t cmd[3]; |
| u16_t ret; |
| |
| //cmd[0] = 0x0000B008; |
| /* len[0] : type[0xB0] : seq[?] */ |
| cmd[0] = 8 | (ZM_CMD_WFLASH << 8); |
| cmd[1] = addr; |
| cmd[2] = val; |
| |
| ret = zfIssueCmd(dev, cmd, 12, ZM_OID_WRITE, 0); |
| return ret; |
| } |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgWriteEeprom */ |
| /* Write EEPROM. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* val : value */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul ZyDAS Technology Corporation 2007.06 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgWriteEeprom(zdev_t* dev, u32_t addr, u32_t val) |
| { |
| u32_t cmd[3]; |
| u16_t ret; |
| |
| //cmd[0] = 0x0000B008; |
| /* len[0] : type[0xB0] : seq[?] */ |
| cmd[0] = 8 | (ZM_CMD_WREEPROM << 8); |
| cmd[1] = addr; |
| cmd[2] = val; |
| |
| ret = zfIssueCmd(dev, cmd, 12, ZM_EEPROM_WRITE, 0); |
| return ret; |
| } |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgBlockWriteEeprom */ |
| /* Block Write Eeprom. */ |
| /* */ |
| /* p.s: now,it will write 16 bytes register data per block (N=4) */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* buf : input data buffer pointer */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul ZyDAS Technology Corporation 2007.06 */ |
| /* */ |
| /************************************************************************/ |
| //#define N buflen/4 |
| //#define SIZE (2*N+1) |
| |
| u32_t zfiDbgBlockWriteEeprom(zdev_t* dev, u32_t addr, u32_t* buf) |
| { |
| u32_t cmd[9]; //2N+1 |
| u16_t ret,i; |
| |
| //cmd[0] = 0x0000B008; |
| /* len[0] : type[0xB0] : seq[?] */ |
| |
| //cmd[0] = (8*N) | (ZM_CMD_WFLASH << 8); |
| cmd[0] = 32 | (ZM_CMD_WREEPROM << 8); //8N |
| |
| for (i=0; i<4; i++) // i<N |
| { |
| cmd[(2*i)+1] = addr+(4*i); |
| cmd[(2*i)+2] = *(buf+i); |
| } |
| |
| ret = zfIssueCmd(dev, cmd, 36, ZM_EEPROM_WRITE, 0); //8N+4 |
| |
| // added for EEPROMUpdate, wait a moment for prevent cmd queue full! |
| //zfwSleep(dev, 1); |
| |
| return ret; |
| } |
| |
| |
| /* write EEPROM with wrlen : wrlen must be 4*n */ |
| /* command format : cmd_info(4) + addr(4) + eeprom(wrlen) */ |
| u32_t zfiDbgBlockWriteEeprom_v2(zdev_t* dev, u32_t addr, u32_t* buf, u32_t wrlen) |
| { |
| u32_t cmd[16]; |
| u16_t ret,i; |
| |
| /* len[0] : type[0xB0] : seq[?] */ |
| /* len = addr(4) + eeprom_block(wrlen) */ |
| cmd[0] = (wrlen+4) | (ZM_CMD_MEM_WREEPROM << 8); |
| cmd[1] = addr; |
| |
| for (i=0; i<(wrlen/4); i++) // i<wrlen/4 |
| { |
| cmd[2+i] = *(buf+i); |
| } |
| /* cmd_info(4) + addr(4) + eeprom(wrlen) */ |
| ret = zfIssueCmd(dev, cmd, (u16_t)(wrlen+8), ZM_EEPROM_WRITE, 0); |
| |
| return ret; |
| } |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfDbgOpenEeprom */ |
| /* Open EEPROM. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* */ |
| /* OUTPUTS */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul ZyDAS Technology Corporation 2007.06 */ |
| /* */ |
| /************************************************************************/ |
| void zfDbgOpenEeprom(zdev_t* dev) |
| { |
| // unlock EEPROM |
| zfDelayWriteInternalReg(dev, 0x1D1400, 0x12345678); |
| zfDelayWriteInternalReg(dev, 0x1D1404, 0x55aa00ff); |
| zfDelayWriteInternalReg(dev, 0x1D1408, 0x13579ace); |
| zfDelayWriteInternalReg(dev, 0x1D1414, 0x0); |
| zfFlushDelayWrite(dev); |
| } |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfDbgCloseEeprom */ |
| /* Close EEPROM. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* */ |
| /* OUTPUTS */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul ZyDAS Technology Corporation 2007.05 */ |
| /* */ |
| /************************************************************************/ |
| void zfDbgCloseEeprom(zdev_t* dev) |
| { |
| // lock EEPROM |
| zfDelayWriteInternalReg(dev, 0x1D1400, 0x87654321); |
| //zfDelayWriteInternalReg(dev, 0x1D1404, 0xffffffff); |
| //zfDelayWriteInternalReg(dev, 0x1D1408, 0xffffffff); |
| //zfDelayWriteInternalReg(dev, 0x1D1414, 0x100); |
| zfFlushDelayWrite(dev); |
| } |
| #if 0 |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiSeriallyWriteEeprom */ |
| /* Write EEPROM Serially. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : start address of writing EEPROM */ |
| /* buf : input data buffer */ |
| /* buflen : size of input data buffer */ |
| /* (length of data write into EEPROM) */ |
| /* */ |
| /* OUTPUTS */ |
| /* */ |
| /* */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul ZyDAS Technology Corporation 2007.06 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiSeriallyWriteEeprom(zdev_t* dev, u32_t addr, u32_t* buf, u32_t buflen) |
| { |
| u32_t count; |
| u16_t i,ret,blocksize; |
| u8_t temp[2]; |
| |
| // per 4 bytes = 1 count |
| count = buflen/4; |
| |
| // Open EEPROM |
| zfDbgOpenEeprom(dev); |
| |
| // Write EEPROM |
| for (i=0; i<count; i++) |
| { |
| if (zfwWriteEeprom(dev, (addr+(4*i)), *(buf+i), 0) != 0) |
| { |
| // Update failed, Close EEPROM |
| zm_debug_msg0("zfwWriteEeprom failed \n"); |
| zfDbgCloseEeprom(dev); |
| return 1; |
| } |
| } |
| |
| // Close EEPROM |
| zfDbgCloseEeprom(dev); |
| return 0; |
| } |
| #endif |
| #if 0 |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiSeriallyBlockWriteEeprom */ |
| /* Block Write EEPROM Serially. */ |
| /* (BlockWrite: per 16bytes write EEPROM once) */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* buf : input data buffer */ |
| /* buflen : access data size of buf */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul ZyDAS Technology Corporation 2007.05 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiSeriallyBlockWriteEeprom(zdev_t* dev, u32_t addr, u32_t* buf, u32_t buflen) |
| { |
| u32_t count; |
| u16_t i,ret,blocksize; |
| u8_t temp[2]; |
| |
| // per 4 bytes = 1 count |
| count = buflen/4; |
| |
| // Open EEPROM |
| zfDbgOpenEeprom(dev); |
| |
| // Write EEPROM |
| // EEPROM Write start address from: 0x1000!? |
| // per 16bytes(N=4) block write EEPROM once |
| for (i=0; i<(count/4); i++) // count/N |
| { |
| //zfiDbgBlockWriteEeprom(dev, (addr+(4*N*i)), buf+(N*i)); |
| //zfiDbgBlockWriteEeprom(dev, (addr+(16*i)), buf+(4*i)); |
| if (zfwBlockWriteEeprom(dev, (addr+(16*i)), buf+(4*i), 0) != 0) |
| { |
| zm_debug_msg0("zfiDbgBlockWriteEeprom failed \n"); |
| // Close EEPROM |
| zfDbgCloseEeprom(dev); |
| return 1; |
| } |
| } |
| |
| // Close EEPROM |
| zfDbgCloseEeprom(dev); |
| return 0; |
| } |
| #endif |
| #if 0 |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgDumpEeprom */ |
| /* Dump EEPROM. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : start address of dumping EEPROM */ |
| /* datalen : length of access EEPROM data */ |
| /* buf : point of buffer, the buffer saved dump data */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul ZyDAS Technology Corporation 2007.06 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgDumpEeprom(zdev_t* dev, u32_t addr, u32_t datalen, u32_t* buf) |
| { |
| u32_t count; |
| u16_t i,ret; |
| |
| count = datalen/4; |
| |
| // over EEPROM length |
| if(datalen > 0x2000) |
| { |
| return 1; |
| } |
| |
| for(i=0; i<count; i++) |
| { |
| buf[i] = zfwReadEeprom(dev, addr+(4*i)); |
| } |
| |
| return 0; |
| } |
| #endif |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgReadReg */ |
| /* Read register. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : register address */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Stephen Chen ZyDAS Technology Corporation 2005.10 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgReadReg(zdev_t* dev, u32_t addr) |
| { |
| u32_t cmd[2]; |
| u16_t ret; |
| |
| cmd[0] = 0x00000004; |
| cmd[1] = addr; |
| |
| ret = zfIssueCmd(dev, cmd, 8, ZM_OID_READ, 0); |
| return ret; |
| } |
| |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgReadTally */ |
| /* Read register. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Stephen Chen ZyDAS Technology Corporation 2005.10 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgReadTally(zdev_t* dev) |
| { |
| u32_t cmd[1]; |
| u16_t ret; |
| zmw_get_wlan_dev(dev); |
| |
| if ( ((struct zsHpPriv*)wd->hpPrivate)->halReInit ) |
| { |
| return 1; |
| } |
| |
| /* len[0] : type[0x81] : seq[?] */ |
| cmd[0] = 0 | (ZM_CMD_TALLY << 8); |
| ret = zfIssueCmd(dev, cmd, 4, ZM_OID_TALLY, 0); |
| |
| /* len[0] : type[0x82] : seq[?] */ |
| cmd[0] = 0 | (ZM_CMD_TALLY_APD << 8); |
| ret = zfIssueCmd(dev, cmd, 4, ZM_OID_TALLY_APD, 0); |
| |
| return ret; |
| } |
| |
| |
| u32_t zfiDbgSetIFSynthesizer(zdev_t* dev, u32_t value) |
| { |
| u32_t cmd[2]; |
| u16_t ret; |
| |
| /* len[4] : type[0x32] : seq[?] */ |
| cmd[0] = 0x4 | (ZM_OID_SYNTH << 8); |
| cmd[1] = value; |
| |
| ret = zfIssueCmd(dev, cmd, 8, ZM_OID_SYNTH, 0); |
| return ret; |
| } |
| |
| u32_t zfiDbgQueryHwTxBusy(zdev_t* dev) |
| { |
| u32_t cmd[1]; |
| u16_t ret; |
| |
| /* len[4] : type[0xC0] : seq[?] */ |
| cmd[0] = 0 | (ZM_CMD_DKTX_STATUS << 8); |
| |
| ret = zfIssueCmd(dev, cmd, 4, ZM_OID_DKTX_STATUS, 0); |
| return ret; |
| } |
| |
| //Paul++ |
| #if 0 |
| u16_t zfHpBlockEraseFlash(zdev_t *dev, u32_t addr) |
| { |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u16_t ret; |
| |
| cmd[0] = 0x00000004 | (ZM_CMD_FLASH_ERASE << 8); |
| cmd[1] = addr; |
| |
| ret = zfIssueCmd(dev, cmd, 8, ZM_OID_INTERNAL_WRITE, NULL); |
| return ret; |
| } |
| #endif |
| |
| #if 0 |
| u16_t zfiDbgProgramFlash(zdev_t *dev, u32_t offset, u32_t len, u32_t *data) |
| { |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u16_t ret; |
| u16_t i; |
| |
| |
| cmd[0] = (ZM_CMD_FLASH_PROG << 8) | ((len+8) & 0xff); |
| cmd[1] = offset; |
| cmd[2] = len; |
| |
| for (i = 0; i < (len >> 2); i++) |
| { |
| cmd[3+i] = data[i]; |
| } |
| |
| ret = zfIssueCmd(dev, cmd, 12, ZM_OID_FLASH_PROGRAM, NULL); |
| |
| return ret; |
| } |
| #endif |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgChipEraseFlash */ |
| /* Chip Erase Flash. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul Atheros Technology Corporation 2007.09 */ |
| /* */ |
| /************************************************************************/ |
| u16_t zfiDbgChipEraseFlash(zdev_t *dev) |
| { |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u16_t ret; |
| |
| cmd[0] = 0x00000000 | (ZM_CMD_FLASH_ERASE << 8); |
| |
| ret = zfIssueCmd(dev, cmd, 4, ZM_OID_INTERNAL_WRITE, NULL); |
| return ret; |
| } |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgGetFlashCheckSum */ |
| /* Get FlashCheckSum. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : Start address of getchksum */ |
| /* len : total lenth of calculate getchksum */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul Atheros Technology Corporation 2007.08 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgGetFlashCheckSum(zdev_t *dev, u32_t addr, u32_t len) |
| { |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u32_t ret; |
| |
| cmd[0] = 0x00000008 | (ZM_CMD_FLASH_CHKSUM << 8); |
| cmd[1] = addr; |
| cmd[2] = len; |
| |
| ret = zfIssueCmd(dev, cmd, 12, ZM_OID_FLASH_CHKSUM, NULL); |
| |
| return ret; |
| } |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDbgReadFlash */ |
| /* Read Flash. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* addr : Start address of read flash */ |
| /* len : total lenth of read flash data */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul Atheros Technology Corporation 2007.09 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDbgReadFlash(zdev_t *dev, u32_t addr, u32_t len) |
| { |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u32_t ret; |
| |
| cmd[0] = len | (ZM_CMD_FLASH_READ << 8); |
| cmd[1] = addr; |
| |
| ret = zfIssueCmd(dev, cmd, 8, ZM_OID_FLASH_READ, NULL); |
| return ret; |
| } |
| |
| /************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfiDownloadFwSet */ |
| /* Before Download FW, */ |
| /* Command FW to Software reset and close watch dog control. */ |
| /* */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* */ |
| /* OUTPUTS */ |
| /* 0 : success */ |
| /* other : fail */ |
| /* */ |
| /* AUTHOR */ |
| /* Paul Atheros Technology Corporation 2007.09 */ |
| /* */ |
| /************************************************************************/ |
| u32_t zfiDownloadFwSet(zdev_t *dev) |
| { |
| //softwarereset |
| //close watch dog |
| u32_t cmd[(ZM_MAX_CMD_SIZE/4)]; |
| u32_t ret; |
| |
| cmd[0] = 0x00000008 | (ZM_CMD_FW_DL_INIT << 8); |
| |
| ret = zfIssueCmd(dev, cmd, 12, ZM_OID_FW_DL_INIT, NULL); |
| |
| return ret; |
| } |
| //Paul-- |
