__s32 NAND_GetParam(boot_nand_para_t * nand_param)
{
__u32 i;
nand_param->ChannelCnt = NandStorageInfo.ChannelCnt ;
nand_param->ChipCnt = NandStorageInfo.ChipCnt ;
nand_param->ChipConnectInfo = NandStorageInfo.ChipConnectInfo ;
nand_param->RbCnt = NandStorageInfo.RbCnt ;
nand_param->RbConnectInfo = NandStorageInfo.RbConnectInfo ;
nand_param->RbConnectMode = NandStorageInfo.RbConnectMode ;
nand_param->BankCntPerChip = NandStorageInfo.BankCntPerChip ;
nand_param->DieCntPerChip = NandStorageInfo.DieCntPerChip ;
nand_param->PlaneCntPerDie = NandStorageInfo.PlaneCntPerDie ;
nand_param->SectorCntPerPage = NandStorageInfo.SectorCntPerPage ;
nand_param->PageCntPerPhyBlk = NandStorageInfo.PageCntPerPhyBlk ;
nand_param->BlkCntPerDie = NandStorageInfo.BlkCntPerDie ;
nand_param->OperationOpt = NandStorageInfo.OperationOpt ;
nand_param->FrequencePar = NandStorageInfo.FrequencePar ;
nand_param->EccMode = NandStorageInfo.EccMode ;
nand_param->ValidBlkRatio = NandStorageInfo.ValidBlkRatio ;
nand_param->good_block_ratio = NandStorageInfo.ValidBlkRatio ;
nand_param->ReadRetryType = NandStorageInfo.ReadRetryType ;
nand_param->DDRType = NandStorageInfo.DDRType ;
PHY_ERR("DDRType: %d\n", nand_param->DDRType);
if ((nand_param->DDRType == 0x2) || (nand_param->DDRType == 0x12)) {
PHY_ERR("set ddrtype 0, freq 30Mhz\n");
nand_param->DDRType = 0;
nand_param->FrequencePar = 30;
} else if (nand_param->DDRType == 0x13) {
PHY_ERR("set ddrtype 3, freq 30Mhz\n");
nand_param->DDRType = 3;
nand_param->FrequencePar = 30;
}
for(i =0; i<8; i++)
nand_param->NandChipId[i] = NandStorageInfo.NandChipId[i];
return 0;
}
__s32 _UpdateExtMultiPlanePara(void)
{
__u32 id_number_ctl;
__u32 script_twoplane, para;
id_number_ctl = NAND_GetNandIDNumCtrl();
if (0x0 != id_number_ctl)
{
if (id_number_ctl & (1U<<1))//bit 1, set twoplane para
{
para = NAND_GetNandExtPara(1);
if(0xffffffff != para) //get script success
{
if(((para & 0xffffff) == NandIDNumber) || ((para & 0xffffff) == 0xeeeeee))
{
script_twoplane = (para >> 24) & 0xff;
PHY_DBG("_UpdateExtMultiPlanePara: get twoplane para from script success: ", script_twoplane);
if (script_twoplane == 1) {
PHY_DBG("%d\n", script_twoplane);
if (NandSupportTwoPlaneOp) {
//PHY_DBG("NAND_UpdatePhyArch: current nand support two plane op!\n");
NandStorageInfo.PlaneCntPerDie = 2;
NandStorageInfo.OperationOpt |= NAND_MULTI_READ;
NandStorageInfo.OperationOpt |= NAND_MULTI_PROGRAM;
} else {
PHY_DBG("_UpdateExtMultiPlanePara: current nand do not support two plane op, set to 0!\n");
NandStorageInfo.PlaneCntPerDie = 1;
NandStorageInfo.OperationOpt &= ~NAND_MULTI_READ;
NandStorageInfo.OperationOpt &= ~NAND_MULTI_PROGRAM;
}
} else if (script_twoplane == 0){
PHY_DBG("%d\n", script_twoplane);
NandStorageInfo.PlaneCntPerDie = 1;
NandStorageInfo.OperationOpt &= ~NAND_MULTI_READ;
NandStorageInfo.OperationOpt &= ~NAND_MULTI_PROGRAM;
} else {
PHY_DBG("%d, wrong parameter(0,1)\n", script_twoplane);
return -1;
}
}
else
{
PHY_ERR("_UpdateExtMultiPlanePara: wrong id number, 0x%x/0x%x\n", (para & 0xffffff), NandIDNumber);
return -1;
}
}
static ssize_t read_file_recv(struct file *file, char __user *user_buf,
size_t count, loff_t *ppos)
{
#define PHY_ERR(s, p) \
len += snprintf(buf + len, size - len, "%20s : %10u\n", s, \
priv->debug.rx_stats.err_phy_stats[p]);
struct ath9k_htc_priv *priv = file->private_data;
char *buf;
unsigned int len = 0, size = 1500;
ssize_t retval = 0;
buf = kzalloc(size, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "SKBs allocated",
priv->debug.rx_stats.skb_allocated);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "SKBs completed",
priv->debug.rx_stats.skb_completed);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "SKBs Dropped",
priv->debug.rx_stats.skb_dropped);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "CRC ERR",
priv->debug.rx_stats.err_crc);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "DECRYPT CRC ERR",
priv->debug.rx_stats.err_decrypt_crc);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "MIC ERR",
priv->debug.rx_stats.err_mic);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "PRE-DELIM CRC ERR",
priv->debug.rx_stats.err_pre_delim);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "POST-DELIM CRC ERR",
priv->debug.rx_stats.err_post_delim);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "DECRYPT BUSY ERR",
priv->debug.rx_stats.err_decrypt_busy);
len += snprintf(buf + len, size - len,
"%20s : %10u\n", "TOTAL PHY ERR",
priv->debug.rx_stats.err_phy);
PHY_ERR("UNDERRUN", ATH9K_PHYERR_UNDERRUN);
PHY_ERR("TIMING", ATH9K_PHYERR_TIMING);
PHY_ERR("PARITY", ATH9K_PHYERR_PARITY);
PHY_ERR("RATE", ATH9K_PHYERR_RATE);
PHY_ERR("LENGTH", ATH9K_PHYERR_LENGTH);
PHY_ERR("RADAR", ATH9K_PHYERR_RADAR);
PHY_ERR("SERVICE", ATH9K_PHYERR_SERVICE);
PHY_ERR("TOR", ATH9K_PHYERR_TOR);
PHY_ERR("OFDM-TIMING", ATH9K_PHYERR_OFDM_TIMING);
PHY_ERR("OFDM-SIGNAL-PARITY", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
PHY_ERR("OFDM-RATE", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
PHY_ERR("OFDM-LENGTH", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
PHY_ERR("OFDM-POWER-DROP", ATH9K_PHYERR_OFDM_POWER_DROP);
PHY_ERR("OFDM-SERVICE", ATH9K_PHYERR_OFDM_SERVICE);
PHY_ERR("OFDM-RESTART", ATH9K_PHYERR_OFDM_RESTART);
PHY_ERR("FALSE-RADAR-EXT", ATH9K_PHYERR_FALSE_RADAR_EXT);
PHY_ERR("CCK-TIMING", ATH9K_PHYERR_CCK_TIMING);
PHY_ERR("CCK-HEADER-CRC", ATH9K_PHYERR_CCK_HEADER_CRC);
PHY_ERR("CCK-RATE", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
PHY_ERR("CCK-SERVICE", ATH9K_PHYERR_CCK_SERVICE);
PHY_ERR("CCK-RESTART", ATH9K_PHYERR_CCK_RESTART);
PHY_ERR("CCK-LENGTH", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
PHY_ERR("CCK-POWER-DROP", ATH9K_PHYERR_CCK_POWER_DROP);
PHY_ERR("HT-CRC", ATH9K_PHYERR_HT_CRC_ERROR);
PHY_ERR("HT-LENGTH", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
PHY_ERR("HT-RATE", ATH9K_PHYERR_HT_RATE_ILLEGAL);
if (len > size)
len = size;
retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
kfree(buf);
return retval;
#undef PHY_ERR
}
__s32 _SetNewPhysicArch(void *phy_arch)
{
__s32 ret;
__u32 i, b, p, chip = 0;
__u32 start_blk=12, blk_cnt=100;
__u8 oob[128];
__u32 good_blk_no;
struct __NandStorageInfo_t *parch;
struct __NandStorageInfo_t arch_tmp = {0};
struct boot_physical_param nand_op;
//parch = (struct __NandStorageInfo_t *)PHY_TMP_PAGE_CACHE;
parch = (struct __NandStorageInfo_t *)MALLOC(64*1024);
/* in order to get good block, get old physic arch info */
ret = _GetOldPhysicArch(&arch_tmp, &good_blk_no);
if (ret == -1) {
/* can not find good block */
PHY_ERR("_SetNewPhysicArch: can not find good block: 12~112\n");
FREE(parch, 64*1024);
return ret;
}
PHY_DBG("_SetNewPhysicArch: write physic arch to blk %d...\n", good_blk_no);
for (b=good_blk_no; b<start_blk+blk_cnt; b++)
{
nand_op.chip = chip;
nand_op.block = b;
nand_op.page = 0;
nand_op.mainbuf = (void *)parch; //PHY_TMP_PAGE_CACHE;
nand_op.oobbuf = oob;
ret = PHY_SimpleErase(&nand_op); //PHY_SimpleErase_CurCH(&nand_op);
if (ret<0)
{
PHY_ERR("_SetNewPhysicArch: erase chip %d, block %d error\n", nand_op.chip, nand_op.block);
for (i=0; i<128; i++)
oob[i] = 0x0;
for (p=0; p<NandStorageInfo.PageCntPerPhyBlk; p++)
{
nand_op.page = p;
ret = PHY_SimpleWrite(&nand_op); //PHY_SimpleWrite_CurCH(&nand_op);
if (ret<0) {
PHY_ERR("_SetNewPhysicArch: mark bad block, write chip %d, block %d, page %d error\n", nand_op.chip, nand_op.block, nand_op.page);
}
}
}
else
{
PHY_DBG("_SetNewPhysicArch: erase block %d ok.\n", b);
for (i=0; i<128; i++)
oob[i] = 0x88;
oob[0] = 0x00; //bad block flag
oob[1] = 0x50; //80; //'P'
oob[2] = 0x48; //72; //'H'
oob[3] = 0x59; //89; //'Y'
oob[4] = 0x41; //65; //'A'
oob[5] = 0x52; //82; //'R'
oob[6] = 0x43; //67; //'C'
oob[7] = 0x48; //72; //'H'
//MEMSET(parch, 0x0, 1024);
MEMCPY(parch, phy_arch, sizeof(struct __NandStorageInfo_t));
//*parch = *((struct __NandStorageInfo_t *)phy_arch);
for (p=0; p<NandStorageInfo.PageCntPerPhyBlk; p++)
{
nand_op.page = p;
ret = PHY_SimpleWrite(&nand_op); //PHY_SimpleWrite_CurCH(&nand_op);
if(ret<0)
{
PHY_ERR("_SetNewPhysicArch: write chip %d, block %d, page %d error\n", nand_op.chip, nand_op.block, nand_op.page);
FREE(parch, 64*1024);
return -1;
}
}
break;
}
}
PHY_DBG("_SetNewPhysicArch: ============\n");
ret = _GetOldPhysicArch(&arch_tmp, &good_blk_no);
if (ret == -1) {
/* can not find good block */
PHY_ERR("_SetNewPhysicArch: can not find good block: 12~112\n");
FREE(parch, 64*1024);
return ret;
}
FREE(parch, 64*1024);
return 0;
}
static ssize_t read_file_phy_err(struct file *file, char __user *user_buf,
size_t count, loff_t *ppos)
{
#define PHY_ERR(s, p) \
len += scnprintf(buf + len, size - len, "%22s : %10u\n", s, \
rxstats->phy_err_stats[p]);
struct ath_rx_stats *rxstats = file->private_data;
char *buf;
unsigned int len = 0, size = 1600;
ssize_t retval = 0;
buf = kzalloc(size, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
PHY_ERR("UNDERRUN ERR", ATH9K_PHYERR_UNDERRUN);
PHY_ERR("TIMING ERR", ATH9K_PHYERR_TIMING);
PHY_ERR("PARITY ERR", ATH9K_PHYERR_PARITY);
PHY_ERR("RATE ERR", ATH9K_PHYERR_RATE);
PHY_ERR("LENGTH ERR", ATH9K_PHYERR_LENGTH);
PHY_ERR("RADAR ERR", ATH9K_PHYERR_RADAR);
PHY_ERR("SERVICE ERR", ATH9K_PHYERR_SERVICE);
PHY_ERR("TOR ERR", ATH9K_PHYERR_TOR);
PHY_ERR("OFDM-TIMING ERR", ATH9K_PHYERR_OFDM_TIMING);
PHY_ERR("OFDM-SIGNAL-PARITY ERR", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
PHY_ERR("OFDM-RATE ERR", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
PHY_ERR("OFDM-LENGTH ERR", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
PHY_ERR("OFDM-POWER-DROP ERR", ATH9K_PHYERR_OFDM_POWER_DROP);
PHY_ERR("OFDM-SERVICE ERR", ATH9K_PHYERR_OFDM_SERVICE);
PHY_ERR("OFDM-RESTART ERR", ATH9K_PHYERR_OFDM_RESTART);
PHY_ERR("FALSE-RADAR-EXT ERR", ATH9K_PHYERR_FALSE_RADAR_EXT);
PHY_ERR("CCK-TIMING ERR", ATH9K_PHYERR_CCK_TIMING);
PHY_ERR("CCK-HEADER-CRC ERR", ATH9K_PHYERR_CCK_HEADER_CRC);
PHY_ERR("CCK-RATE ERR", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
PHY_ERR("CCK-SERVICE ERR", ATH9K_PHYERR_CCK_SERVICE);
PHY_ERR("CCK-RESTART ERR", ATH9K_PHYERR_CCK_RESTART);
PHY_ERR("CCK-LENGTH ERR", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
PHY_ERR("CCK-POWER-DROP ERR", ATH9K_PHYERR_CCK_POWER_DROP);
PHY_ERR("HT-CRC ERR", ATH9K_PHYERR_HT_CRC_ERROR);
PHY_ERR("HT-LENGTH ERR", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
PHY_ERR("HT-RATE ERR", ATH9K_PHYERR_HT_RATE_ILLEGAL);
if (len > size)
len = size;
retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
kfree(buf);
return retval;
#undef PHY_ERR
}
static ssize_t read_file_recv(struct file *file, char __user *user_buf,
size_t count, loff_t *ppos)
{
#define PHY_ERR(s, p) \
len += snprintf(buf + len, size - len, "%18s : %10u\n", s, \
sc->debug.stats.rxstats.phy_err_stats[p]);
struct ath_softc *sc = file->private_data;
char *buf;
unsigned int len = 0, size = 1152;
ssize_t retval = 0;
buf = kzalloc(size, GFP_KERNEL);
if (buf == NULL)
return 0;
len += snprintf(buf + len, size - len,
"%18s : %10u\n", "CRC ERR",
sc->debug.stats.rxstats.crc_err);
len += snprintf(buf + len, size - len,
"%18s : %10u\n", "DECRYPT CRC ERR",
sc->debug.stats.rxstats.decrypt_crc_err);
len += snprintf(buf + len, size - len,
"%18s : %10u\n", "PHY ERR",
sc->debug.stats.rxstats.phy_err);
len += snprintf(buf + len, size - len,
"%18s : %10u\n", "MIC ERR",
sc->debug.stats.rxstats.mic_err);
len += snprintf(buf + len, size - len,
"%18s : %10u\n", "PRE-DELIM CRC ERR",
sc->debug.stats.rxstats.pre_delim_crc_err);
len += snprintf(buf + len, size - len,
"%18s : %10u\n", "POST-DELIM CRC ERR",
sc->debug.stats.rxstats.post_delim_crc_err);
len += snprintf(buf + len, size - len,
"%18s : %10u\n", "DECRYPT BUSY ERR",
sc->debug.stats.rxstats.decrypt_busy_err);
PHY_ERR("UNDERRUN", ATH9K_PHYERR_UNDERRUN);
PHY_ERR("TIMING", ATH9K_PHYERR_TIMING);
PHY_ERR("PARITY", ATH9K_PHYERR_PARITY);
PHY_ERR("RATE", ATH9K_PHYERR_RATE);
PHY_ERR("LENGTH", ATH9K_PHYERR_LENGTH);
PHY_ERR("RADAR", ATH9K_PHYERR_RADAR);
PHY_ERR("SERVICE", ATH9K_PHYERR_SERVICE);
PHY_ERR("TOR", ATH9K_PHYERR_TOR);
PHY_ERR("OFDM-TIMING", ATH9K_PHYERR_OFDM_TIMING);
PHY_ERR("OFDM-SIGNAL-PARITY", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
PHY_ERR("OFDM-RATE", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
PHY_ERR("OFDM-LENGTH", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
PHY_ERR("OFDM-POWER-DROP", ATH9K_PHYERR_OFDM_POWER_DROP);
PHY_ERR("OFDM-SERVICE", ATH9K_PHYERR_OFDM_SERVICE);
PHY_ERR("OFDM-RESTART", ATH9K_PHYERR_OFDM_RESTART);
PHY_ERR("FALSE-RADAR-EXT", ATH9K_PHYERR_FALSE_RADAR_EXT);
PHY_ERR("CCK-TIMING", ATH9K_PHYERR_CCK_TIMING);
PHY_ERR("CCK-HEADER-CRC", ATH9K_PHYERR_CCK_HEADER_CRC);
PHY_ERR("CCK-RATE", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
PHY_ERR("CCK-SERVICE", ATH9K_PHYERR_CCK_SERVICE);
PHY_ERR("CCK-RESTART", ATH9K_PHYERR_CCK_RESTART);
PHY_ERR("CCK-LENGTH", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
PHY_ERR("CCK-POWER-DROP", ATH9K_PHYERR_CCK_POWER_DROP);
PHY_ERR("HT-CRC", ATH9K_PHYERR_HT_CRC_ERROR);
PHY_ERR("HT-LENGTH", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
PHY_ERR("HT-RATE", ATH9K_PHYERR_HT_RATE_ILLEGAL);
retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
kfree(buf);
return retval;
#undef PHY_ERR
}
