void mt_gpio_checkpoint_compare(void)
{
#if defined(GPIO_INIT_DEBUG)
UINT32 latest[sizeof(gpio_init_value)/((sizeof(UINT32))*(MASK_BIT+1))];
int idx;
memset(&latest[0], 0x00, sizeof(latest));
for (idx = 0; idx < sizeof(gpio_init_value)/((sizeof(UINT32))*(MASK_BIT+1)); idx++)
latest[idx] = GPIO_RD32(gpio_init_value[idx][0]);
if (memcmp(&latest, &save, sizeof(gpio_init_value)/((sizeof(UINT32))*(MASK_BIT+1)))) {
GPIODBG("checkpoint compare fail!!\n");
GPIODBG("dump checkpoint....\n");
//mt_gpio_dump(&save);
GPIODBG("\n\n");
GPIODBG("dump current state\n");
//mt_gpio_dump(&latest);
GPIODBG("\n\n");
mt_gpio_dump_diff(&save, &latest);
//WARN_ON(1);
} else {
GPIODBG("checkpoint compare success!!\n");
}
#endif
//mt_gpio_checkpoint_compare_ext();
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_dir_base(unsigned long pin, unsigned long dir)
{
unsigned long bit;
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
if (dir >= GPIO_DIR_MAX)
return -ERINVAL;
/* GPIOERR("before pin:%ld, dir:%ld\n",pin,dir); */
/* pos = pin / MAX_GPIO_REG_BITS; */
bit = DIR_offset[pin].offset;
#ifdef GPIO_BRINGUP
reg = GPIO_RD32(DIR_addr[pin].addr);
if (dir == GPIO_DIR_IN)
reg &= (~(1 << bit));
else
reg |= (1 << bit);
GPIO_WR32(DIR_addr[pin].addr, reg);
#else
if (dir == GPIO_DIR_IN)
GPIO_SET_BITS((1L << bit), DIR_addr[pin].addr + 8);
else
GPIO_SET_BITS((1L << bit), DIR_addr[pin].addr + 4);
#endif
/* GPIOERR("%s:pin:%ld, dir:%ld, value:0x%x\n",__FUNCTION__, pin, dir, GPIO_RD32(DIR_addr[pin].addr)); */
return RSUCCESS;
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_pull_select_base(unsigned long pin)
{
unsigned long pos;
unsigned long bit;
unsigned long data=0;
unsigned long i,j;
GPIO_REGS *reg = gpio_reg;
/*for special kpad pupd*/
for(i = 0; i < sizeof(kpad_pupd_spec)/sizeof(kpad_pupd_spec[0]); i++) {
if (pin == kpad_pupd_spec[i].pin) {
data = GPIO_RD32(®->kpad_ctrl[kpad_pupd_spec[i].reg].val);
return (((data & (1L << kpad_pupd_spec[i].bit)) != 0)? 0: 1);
}
}
if (((pin >= GPIO114)&&(pin <= GPIO119))||((pin >= GPIO99)&&(pin <= GPIO104))||((pin >= GPIO124)&&(pin <= GPIO129))) {
/* msdc IO */
for(i = 0; i < sizeof(msdc_pupd_spec)/sizeof(msdc_pupd_spec[0]); i++) {
for(j = 0; j < sizeof(msdc_pupd_spec[0])/sizeof(msdc_pupd_spec[0][0]); j++) {
if (pin == msdc_pupd_spec[i][j].pin) {
if (i == 0) {
data = GPIO_RD32(®->msdc1_ctrl[msdc_pupd_spec[i][j].reg].val);
} else if (i == 1) {
data = GPIO_RD32(®->msdc2_ctrl[msdc_pupd_spec[i][j].reg].val);
} else if (i == 2) {
data = GPIO_RD32(®->msdc3_ctrl[msdc_pupd_spec[i][j].reg].val);
}
}
return (((data & (1L << msdc_pupd_spec[i][j].bit)) != 0)? 0: 1);
}
}
} else if((pin >= GPIO141)&&(pin <= GPIO166)) {
return GPIO_PULL_EN_UNSUPPORTED;
} else {
pos = pin / MAX_GPIO_REG_BITS;
bit = pin % MAX_GPIO_REG_BITS;
data = GPIO_RD32(®->pullsel[pos].val);
}
return (((data & (1L << bit)) != 0)? 1: 0);
}
void mt_gpio_checkpoint_save_ext(void)
{
#if defined(GPIO_INIT_DEBUG)
int idx;
memset(save_ext, 0x00, sizeof(gpio_init_value_ext)/((sizeof(UINT32))*(MASK_BIT+1)));
for (idx = 0; idx < sizeof(gpio_init_value_ext)/((sizeof(UINT32))*(MASK_BIT+1)); idx++)
save_ext[idx] = GPIO_RD32(gpio_init_value_ext[idx][0]);
#endif
}
/*----------------------------------------------------------------------------*/
void mt_gpio_checkpoint_save(void)
{
#if defined(GPIO_INIT_DEBUG)
GPIO_REGS *pReg = (GPIO_REGS*)(GPIO_BASE);
GPIO_REGS *cur = &saved;
unsigned int idx;
memset(cur, 0x00, sizeof(*cur));
for (idx = 0; idx < sizeof(pReg->dir)/sizeof(pReg->dir[0]); idx++)
cur->dir[idx].val = GPIO_RD32(&pReg->dir[idx]);
for (idx = 0; idx < sizeof(pReg->pullen)/sizeof(pReg->pullen[0]); idx++)
cur->pullen[idx].val = GPIO_RD32(&pReg->pullen[idx]);
for (idx = 0; idx < sizeof(pReg->pullsel)/sizeof(pReg->pullsel[0]); idx++)
cur->pullsel[idx].val =GPIO_RD32(&pReg->pullsel[idx]);
for (idx = 0; idx < sizeof(pReg->dout)/sizeof(pReg->dout[0]); idx++)
cur->dout[idx].val = GPIO_RD32(&pReg->dout[idx]);
for (idx = 0; idx < sizeof(pReg->mode)/sizeof(pReg->mode[0]); idx++)
cur->mode[idx].val = GPIO_RD32(&pReg->mode[idx]);
#endif
}
/*----------------------------------------------------------------------------*/
void mt_gpio_checkpoint_compare(void)
{
#if defined(GPIO_INIT_DEBUG)
GPIO_REGS *pReg = (GPIO_REGS*)(GPIO_BASE);
GPIO_REGS latest;
GPIO_REGS *cur = &latest;
unsigned int idx;
memset(cur, 0x00, sizeof(*cur));
for (idx = 0; idx < sizeof(pReg->dir)/sizeof(pReg->dir[0]); idx++)
cur->dir[idx].val = GPIO_RD32(&pReg->dir[idx]);
for (idx = 0; idx < sizeof(pReg->pullen)/sizeof(pReg->pullen[0]); idx++)
cur->pullen[idx].val = GPIO_RD32(&pReg->pullen[idx]);
for (idx = 0; idx < sizeof(pReg->pullsel)/sizeof(pReg->pullsel[0]); idx++)
cur->pullsel[idx].val =GPIO_RD32(&pReg->pullsel[idx]);
/* for (idx = 0; idx < sizeof(pReg->dinv)/sizeof(pReg->dinv[0]); idx++)
cur->dinv[idx].val =GPIO_RD32(&pReg->dinv[idx]);*/
for (idx = 0; idx < sizeof(pReg->dout)/sizeof(pReg->dout[0]); idx++)
cur->dout[idx].val = GPIO_RD32(&pReg->dout[idx]);
for (idx = 0; idx < sizeof(pReg->mode)/sizeof(pReg->mode[0]); idx++)
cur->mode[idx].val = GPIO_RD32(&pReg->mode[idx]);
//mt_gpio_dump_diff(&latest, &saved);
//GPIODBG("memcmp(%p, %p, %d) = %d\n", &latest, &saved, sizeof(GPIO_REGS), memcmp(&latest, &saved, sizeof(GPIO_REGS)));
if (memcmp(&latest, &saved, sizeof(GPIO_REGS))) {
GPIODBG("checkpoint compare fail!!\n");
GPIODBG("dump checkpoint....\n");
//mt_gpio_dump(&saved);
GPIODBG("\n\n");
GPIODBG("dump current state\n");
//mt_gpio_dump(&latest);
GPIODBG("\n\n");
mt_gpio_dump_diff(&saved, &latest);
//WARN_ON(1);
} else {
GPIODBG("checkpoint compare success!!\n");
}
#endif
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_ies_base(unsigned long pin)
{
int i = 0;
unsigned long data;
GPIO_REGS *reg = gpio_reg;
for(; i < ARRAY_SIZE(mt_ies_smt_map); i++) {
if(pin >= mt_ies_smt_map[i].index_start && pin <= mt_ies_smt_map[i].index_end)
break;
}
data = GPIO_RD32(®->ies[mt_ies_smt_map[i].reg_index].val);
return (((data & (1L << mt_ies_smt_map[i].bit)) != 0)? 1: 0);
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_dir_base(unsigned long pin)
{
unsigned long bit;
unsigned long reg;
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
bit = DIR_offset[pin].offset;
reg = GPIO_RD32(DIR_addr[pin].addr);
return ((reg & (1L << bit)) != 0) ? 1 : 0;
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_pull_select_base(unsigned long pin)
{
unsigned long data;
unsigned long bit = 0;
u32 mask = (1L << 4) - 1;
if (pin >= 160 && pin <= 165) {
bit = pupd_offset[pin].offset;
data = GPIO_RD32(pupd_addr[pin].addr);
return ((((data >> bit) & mask) == 0x2)) ? 1 : 0;
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_in_base(unsigned long pin)
{
unsigned long pos;
unsigned long bit;
unsigned long data;
GPIO_REGS *reg = gpio_reg;
pos = pin / MAX_GPIO_REG_BITS;
bit = pin % MAX_GPIO_REG_BITS;
data = GPIO_RD32(®->din[pos].val);
return (((data & (1L << bit)) != 0)? 1: 0);
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_ies_base(unsigned long pin)
{
unsigned long data;
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
if (IES_offset[pin].offset == -1)
return GPIO_IES_UNSUPPORTED;
data = GPIO_RD32(IES_addr[pin].addr);
return ((data & (1L << (IES_offset[pin].offset))) != 0) ? 1 : 0;
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_smt_base(unsigned long pin)
{
unsigned long data;
unsigned long bit = 0;
bit = SMT_offset[pin].offset;
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
if (SMT_offset[pin].offset == -1)
return GPIO_SMT_UNSUPPORTED;
data = GPIO_RD32(SMT_addr[pin].addr);
return ((data & (1L << bit)) != 0) ? 1 : 0;
}
void mt_gpio_set_driving(void)
{
#if 0
u32 val;
u32 mask;
/* [MT6571] for MD BSI request */
mask = 0x3000;
val = GPIO_RD32(IO_CFG_T_BASE+0xF0);
val &= ~(mask);
val |= (0x0000 & mask);
GPIO_WR32(IO_CFG_T_BASE+0xF0, val);
/* [MT6571] end */
/* [MT6571] for desense request (AUD IO) */
mask = 0x30;
val = GPIO_RD32(IO_CFG_L_BASE+0xA0);
val &= ~(mask);
val |= (0x00 & mask);
GPIO_WR32(IO_CFG_L_BASE+0xA0, val);
/* [MT6571] end */
#endif
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_pull_enable_base(unsigned long pin)
{
unsigned long data;
u32 bit = 0;
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
if (PULLEN_offset[pin].offset == -1 && pupd_offset[pin].offset == -1)
return GPIO_PULL_EN_UNSUPPORTED;
if (PULLEN_offset[pin].offset != -1) {
bit = PULLEN_offset[pin].offset;
data = GPIO_RD32(PULLEN_addr[pin].addr);
return ((data & (1L << bit)) != 0) ? 1 : 0;
}
bit = pupd_offset[pin].offset;
data = GPIO_RD32(pupd_addr[pin].addr);
return ((data & (0x7 << bit)) != 0) ? 1 : 0;
}
void mt_gpio_set_dsel(u8 bpi_1v8)
{
GPIO_REGS *pReg = (GPIO_REGS*)(GPIO_BASE);
if (bpi_1v8 == GPIO_VIO18) {
/*bpi_ctrl[9:4] = b`000000, [3:0] = b`0000*/
GPIO_WR32(&pReg->bpi_ctrl[0].rst, 0x3FF);
} else if (bpi_1v8 == GPIO_VIO28){
/*bpi_ctrl[9:4] = b`001100, [3:0] = b`0101*/
GPIO_WR32(&pReg->bpi_ctrl[0].set, 0xC5);
GPIO_WR32(&pReg->bpi_ctrl[0].rst, 0x33A);
}
GPIOVER("BPI 0x%x\n",GPIO_RD32(&pReg->bpi_ctrl[0].val));
}
/*---------------------------------------------------------------------------*/
int mt_get_gpio_mode_base(unsigned long pin)
{
unsigned long pos;
unsigned long bit;
unsigned long data;
unsigned long mask = (1L << GPIO_MODE_BITS) - 1;
GPIO_REGS *reg = gpio_reg;
pos = pin / MAX_GPIO_MODE_PER_REG;
bit = pin % MAX_GPIO_MODE_PER_REG;
data = GPIO_RD32(®->mode[pos].val);
return ((data >> (GPIO_MODE_BITS*bit)) & mask);
}
void mt_gpio_set_power(void)
{
#if 0
u32 val;
val = GPIO_RD32(GPIO_BASE+0x510);
if(((val & 0x100)>>8) == 1){
GPIO_WR32(IO_CFG_L_BASE+0x48, 0x8000);
}
if(((val & 0x200)>>9) == 1){
GPIO_WR32(IO_CFG_L_BASE+0x48, 0x10000);
}
#endif
}
void mt_gpio_set_default_chip(void)
{
u32 idx;
u32 val;
u32 mask;
for (idx = 0; idx < sizeof(gpio_init_value)/((sizeof(UINT32))*(MASK_BIT+1)); idx++){
mask = gpio_init_value[idx][MASK_BIT];
val = GPIO_RD32(gpio_init_value[idx][ADDR_BIT]);
val &= ~(mask);
val |= ((gpio_init_value[idx][VAL_BIT])&mask);
GPIO_WR32(gpio_init_value[idx][ADDR_BIT],val);
}
//GPIOVER("mt_gpio_set_default() done\n");
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_mode_base(unsigned long pin, unsigned long mode)
{
unsigned long pos;
unsigned long bit;
unsigned long data;
unsigned long mask = (1L << GPIO_MODE_BITS) - 1;
GPIO_REGS *reg = gpio_reg;
pos = pin / MAX_GPIO_MODE_PER_REG;
bit = pin % MAX_GPIO_MODE_PER_REG;
data = GPIO_RD32(®->mode[pos].val);
data &= ~(mask << (GPIO_MODE_BITS*bit));
data |= (mode << (GPIO_MODE_BITS*bit));
GPIO_WR32(®->mode[pos].val, data);
return RSUCCESS;
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_smt_base(unsigned long pin, unsigned long enable)
{
/* unsigned long flags; */
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
#ifdef GPIO_BRINGUP
if (SMT_offset[pin].offset == -1) {
return GPIO_SMT_UNSUPPORTED;
} else {
bit = SMT_offset[pin].offset;
reg = GPIO_RD32(SMT_addr[pin].addr);
if (enable == GPIO_SMT_DISABLE)
reg &= (~(1 << bit));
else
reg |= (1 << bit);
}
/* printk("SMT addr(%x),value(%x)\n",SMT_addr[pin].addr,GPIO_RD32(SMT_addr[pin].addr)); */
GPIO_WR32(SMT_addr[pin].addr, reg);
#else
if (SMT_offset[pin].offset == -1) {
gpio_smt_unsupport[pin] = -1;
return GPIO_SMT_UNSUPPORTED;
}
if (enable == GPIO_SMT_DISABLE)
GPIO_SET_BITS((1L << (SMT_offset[pin].offset)), SMT_addr[pin].addr + 8);
else
GPIO_SET_BITS((1L << (SMT_offset[pin].offset)), SMT_addr[pin].addr + 4);
#endif
/* GPIOERR("%s:pin:%ld, enable:%ld, value:0x%x\n",__FUNCTION__, pin, enable, GPIO_RD32(SMT_addr[pin].addr)); */
return RSUCCESS;
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_pull_enable_base(unsigned long pin, unsigned long enable)
{
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
#ifdef GPIO_BRINGUP
bit = PULLEN_offset[pin].offset;
if (PULLEN_offset[pin].offset == -1)
return GPIO_PULL_EN_UNSUPPORTED;
reg = GPIO_RD32(PULLEN_addr[pin].addr);
if (enable == GPIO_PULL_DISABLE)
reg &= (~(1 << bit));
else
reg |= (1 << bit);
GPIO_WR32(PULLEN_addr[pin].addr, reg);
#else
if (PULLEN_offset[pin].offset == -1) {
gpio_pullen_unsupport[pin] = -1;
return GPIO_PULL_EN_UNSUPPORTED;
}
if (enable == GPIO_PULL_DISABLE)
GPIO_SET_BITS((1L << (PULLEN_offset[pin].offset)),
PULLEN_addr[pin].addr + 8);
else
GPIO_SET_BITS((1L << (PULLEN_offset[pin].offset)),
PULLEN_addr[pin].addr + 4);
#endif
return RSUCCESS;
}
/*---------------------------------------------------------------------------*/
int mt_set_gpio_pull_select_base(unsigned long pin, unsigned long select)
{
/* unsigned long flags; */
unsigned long bit = 0;
/*u32 mask = (1L << 4) - 1;*/
if (pin >= MAX_GPIO_PIN)
return -ERINVAL;
if (pin == 5) {
pr_err("XXX MSDC SD CD PIN be touched!\n");
dump_stack();
}
#ifdef GPIO_BRINGUP
if (PULL_offset[pin].offset == -1 && pupd_offset[pin].offset == -1)
return GPIO_PULL_UNSUPPORTED;
if (pin >= 160 && pin <= 165) {
bit = pupd_offset[pin].offset;
reg = GPIO_RD32(pupd_addr[pin].addr);
if (select == GPIO_PULL_UP) { /* 0x2 pull up */
reg &= (~(mask << bit));
reg |= (0x2 << bit);
} else { /* 0x6 pull down */
reg &= (~(mask << bit));
reg |= (0x6 << bit);
}
/* printk("fwq pullset pin=%d,3.............\n",pin); */
GPIO_WR32(pupd_addr[pin].addr, reg);
return RSUCCESS;
}
/* printk("fwq pullset pin=%d,select(%d)\n",pin,select); */
if (PULL_offset[pin].offset != -1) {
bit = PULL_offset[pin].offset;
reg = GPIO_RD32(PULL_addr[pin].addr);
if (select == GPIO_PULL_DOWN)
reg &= (~(1 << bit));
else
reg |= (1 << bit);
/* printk("fwq pullset pin=%d,2.............\n",pin); */
GPIO_WR32(PULL_addr[pin].addr, reg);
} else {
bit = pupd_offset[pin].offset + 2;
reg = GPIO_RD32(pupd_addr[pin].addr);
if (select == GPIO_PULL_UP)
reg &= (~(1 << bit));
else
reg |= (1 << bit);
/* printk("fwq pullset pin=%d,3.............\n",pin); */
GPIO_WR32(pupd_addr[pin].addr, reg);
}
#else
if ((PULL_offset[pin].offset == -1) && (pupd_offset[pin].offset == -1)) {
gpio_pull_select_unsupport[pin] = -1;
return GPIO_PULL_UNSUPPORTED;
}
/* printk("fwq pullset pin=%ld,1.............\n",pin); */
if (pin >= 160 && pin <= 165) {
if (select == GPIO_PULL_UP) { /* 0x2 pull up */
/* reg &= (~(mask << bit)); */
/* reg |= (0x2 << bit); */
GPIO_SET_BITS((2L << (pupd_offset[pin].offset)), pupd_addr[pin].addr + 4);
} else { /* 0x6 pull down */
/* reg &= (~(mask << bit)); */
/* reg |= (0x6 << bit); */
GPIO_SET_BITS((6L << (pupd_offset[pin].offset)), pupd_addr[pin].addr + 4);
}
return RSUCCESS;
}
/* printk("fwq pullset pin=%ld,2.............\n",pin); */
/* printk("fwq pullset pin=%d,select(%d)\n",pin,select); */
if (PULL_offset[pin].offset != -1) {
bit = PULL_offset[pin].offset;
/* reg = GPIO_RD32(PULL_addr[pin].addr); */
if (select == GPIO_PULL_DOWN)
GPIO_SET_BITS((1L << bit), PULL_addr[pin].addr + 8);
else
GPIO_SET_BITS((1L << bit), PULL_addr[pin].addr + 4);
/* printk("fwq pullset pin=%d,2.............\n",pin); */
} else {
bit = pupd_offset[pin].offset + 2;
/* reg = GPIO_RD32(pupd_addr[pin].addr); */
if (select == GPIO_PULL_UP)
GPIO_SET_BITS((1L << (bit)), pupd_addr[pin].addr + 8);
else
GPIO_SET_BITS((1L << (bit)), pupd_addr[pin].addr + 4);
}
#endif
/* GPIOERR("%s:pin:%ld, select:%ld, value:0x%x\n",__FUNCTION__, pin, select, GPIO_RD32(PULL_addr[pin].addr)); */
return RSUCCESS;
}
void mt_gpio_set_dsel(u8 nml2_1v8,u8 bsi_1v8,u8 bpi_1v8)
{
#if 0
u32 mask;
u32 val;
u32 bit;
#define TDSEL_1V8 0x0
#define TDSEL_3V3 0x5
#define RDSEL_1V8 0x0
#define RDSEL_3V3 0xC
#define GPIO_NML2_OFFSET 0x730
#define GPIO_NML2_PWMR_OFFSET 0x740
#define GPIO_BSI_OFFSET 0x750
#define GPIO_BPI_OFFSET 0x740
//set NML2 UART
val = GPIO_RD32(GPIO_BASE + GPIO_NML2_OFFSET);
mask = (1L << 4) - 1;
bit = 8;
val &= ~(mask << (bit));
val |= (nml2_1v8?TDSEL_1V8:TDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_NML2_OFFSET, val);
val = GPIO_RD32(GPIO_BASE + GPIO_NML2_OFFSET);
mask = (1L << 6) - 1;
bit = 16;
val &= ~(mask << (bit));
val |= (nml2_1v8?RDSEL_1V8:RDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_NML2_OFFSET, val);
//set NML2 PWM
val = GPIO_RD32(GPIO_BASE + GPIO_NML2_OFFSET);
mask = (1L << 4) - 1;
bit = 24;
val &= ~(mask << (bit));
val |= (nml2_1v8?TDSEL_1V8:TDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_NML2_OFFSET, val);
val = GPIO_RD32(GPIO_BASE + GPIO_NML2_PWMR_OFFSET);
mask = (1L << 6) - 1;
bit = 0;
val &= ~(mask << (bit));
val |= (nml2_1v8?RDSEL_1V8:RDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_NML2_PWMR_OFFSET, val);
//set BPI
val = GPIO_RD32(GPIO_BASE + GPIO_BPI_OFFSET);
mask = (1L << 4) - 1;
bit = 8;
val &= ~(mask << (bit));
val |= (bpi_1v8?TDSEL_1V8:TDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_BPI_OFFSET, val);
val = GPIO_RD32(GPIO_BASE + GPIO_BPI_OFFSET );
mask = (1L << 6) - 1;
bit = 16;
val &= ~(mask << (bit));
val |= (bpi_1v8?RDSEL_1V8:RDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_BPI_OFFSET, val);
//set BSI
val = GPIO_RD32(GPIO_BASE + GPIO_BSI_OFFSET);
mask = (1L << 4) - 1;
bit = 0;
val &= ~(mask << (bit));
val |= (bsi_1v8?TDSEL_1V8:TDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_BSI_OFFSET, val);
val = GPIO_RD32(GPIO_BASE + GPIO_BSI_OFFSET );
mask = (1L << 6) - 1;
bit = 8;
val &= ~(mask << (bit));
val |= (bsi_1v8?RDSEL_1V8:RDSEL_3V3)<<bit;
GPIO_WR32(GPIO_BASE + GPIO_BSI_OFFSET, val);
GPIOVER("NML2 0x%x,BPI 0x%x, BSI 0x%x\n",GPIO_RD32(GPIO_BASE + GPIO_NML2_OFFSET),GPIO_RD32(GPIO_BASE + GPIO_BPI_OFFSET),GPIO_RD32(GPIO_BASE + GPIO_BSI_OFFSET));
#endif
}
