int ssw_switch_mode(char *buf, unsigned int len)
{
int ret = 0;
unsigned int mode = *((unsigned int *)buf);
SSW_DBG("sim switch: %s(%d) \n", mode?"Single Talk":"Dual Talk", curr_ssw_mode);
mutex_lock(&ssw_mutex);
if (curr_ssw_mode != mode) {
curr_ssw_mode = mode;
if (curr_ssw_mode == SSW_DUAL_TALK)
mt_set_gpio_out(ch_swap, GPIO_OUT_ONE);
else if (curr_ssw_mode == SSW_SING_TALK)
mt_set_gpio_out(ch_swap, GPIO_OUT_ZERO);
}
mutex_unlock(&ssw_mutex);
SSW_DBG("sim switch(%d) OK, ch_swap=%d, en=%d \n", curr_ssw_mode,
mt_get_gpio_out(ch_swap), mt_get_gpio_out(en));
return 0;
}
static int amp_enable(int on_state)
{
int err = 0;
switch (on_state) {
case 0:
err = mt_set_gpio_out(GPIO_SPK_AMP_EN, GPIO_OUT_ZERO);
EAMP_PRINTK("AMP_EN is set to %d\n", mt_get_gpio_out(GPIO_SPK_AMP_EN));
break;
case 1:
err = mt_set_gpio_out(GPIO_SPK_AMP_EN, GPIO_OUT_ONE);
EAMP_PRINTK("AMP_EN is set to %d\n", mt_get_gpio_out(GPIO_SPK_AMP_EN));
break;
case 2:
EAMP_PRINTK("amp enable bypass(%d)\n", on_state);
err = 0;
break;
default:
pr_err("amp enable fail\n");
err = 1;
break;
}
return err;
}
void cm_gpio_setup(void)
{
EMD_MSG_INF("chr","cm_gpio_setup 1\n");
atomic_set(&traffic_on, 0);
atomic_set(&allow_wk_md, 0);
// MD wake up AP pin
mt_set_gpio_pull_enable(GPIO_EXT_MD_WK_AP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_WK_AP, 0);
mt_set_gpio_dir(GPIO_EXT_MD_WK_AP, 0);
mt_set_gpio_mode(GPIO_EXT_MD_WK_AP, GPIO_EXT_MD_WK_AP_M_EINT);
EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_MD_WK_AP(%x)=%d\n",GPIO_EXT_MD_WK_AP,mt_get_gpio_out(GPIO_EXT_MD_WK_AP));
// AP wake up MD pin
mt_set_gpio_mode(GPIO_EXT_AP_WK_MD, GPIO_EXT_AP_WK_MD_M_GPIO); // GPIO Mode
mt_set_gpio_dir(GPIO_EXT_AP_WK_MD, 1);
mt_set_gpio_out(GPIO_EXT_AP_WK_MD, 0);
EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_AP_WK_MD(%x)=%d\n",GPIO_EXT_AP_WK_MD,mt_get_gpio_out(GPIO_EXT_AP_WK_MD));
// Rest MD pin
mt_set_gpio_mode(GPIO_EXT_MD_RST, GPIO_EXT_MD_RST_M_GPIO); //GPIO202 is reset pin
mt_set_gpio_pull_enable(GPIO_EXT_MD_RST, 0);
mt_set_gpio_pull_select(GPIO_EXT_MD_RST, 1);
cm_relese_rst_signal();
EMD_MSG_INF("chr","cm_gpio_setup 4\n");
EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_MD_RST(%x)=%d\n",GPIO_EXT_MD_RST,mt_get_gpio_out(GPIO_EXT_MD_RST));
// MD power key pin
mt_set_gpio_mode(GPIO_EXT_MD_PWR_KEY, GPIO_EXT_MD_PWR_KEY_M_GPIO); //GPIO 200 is power key
mt_set_gpio_pull_enable(GPIO_EXT_MD_PWR_KEY, 0);
mt_set_gpio_dir(GPIO_EXT_MD_PWR_KEY, 1);
mt_set_gpio_out(GPIO_EXT_MD_PWR_KEY, 0);
EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_MD_PWR_KEY(%x)=%d\n",GPIO_EXT_MD_PWR_KEY,mt_get_gpio_out(GPIO_EXT_MD_PWR_KEY));
// MD WDT irq pin
mt_set_gpio_pull_enable(GPIO_EXT_MD_WD, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_WD, 1);
mt_set_gpio_dir(GPIO_EXT_MD_WD, 0);
mt_set_gpio_mode(GPIO_EXT_MD_WD, GPIO_EXT_MD_WD_M_EINT); // EINT168
EMD_MSG_INF("chr","cm_gpio_setup GPIO_EXT_MD_WD(%x)(in)=%d\n",GPIO_EXT_MD_WD,mt_get_gpio_in(GPIO_EXT_MD_WD));
// MD Exception irq pin
mt_set_gpio_pull_enable(GPIO_EXT_MD_EXP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_EXP, 1);
mt_set_gpio_dir(GPIO_EXT_MD_EXP, 0);
mt_set_gpio_mode(GPIO_EXT_MD_EXP, GPIO_EXT_MD_EXP_M_EINT); //
EMD_MSG_INF("chr","cm_gpio_setup GPIO_EXT_MD_EXP(%x)(in)=%d\n",GPIO_EXT_MD_EXP,mt_get_gpio_in(GPIO_EXT_MD_EXP));
#ifndef GPIO_EXT_USB_SW2
mt_set_gpio_mode(GPIO_EXT_MD_META, GPIO_EXT_MD_META_M_GPIO);
mt_set_gpio_dir(GPIO_EXT_MD_META, 1);// Using input floating
mt_set_gpio_out(GPIO_EXT_MD_META, 0);// Default @ reset state
EMD_MSG_INF("chr","cm_gpio_setup:phone GPIO_EXT_MD_META(%x)=%d\n",GPIO_EXT_MD_META,mt_get_gpio_out(GPIO_EXT_MD_META));
#else
mt_set_gpio_pull_enable(GPIO_EXT_MD_DUMP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_DUMP, 0);
mt_set_gpio_dir(GPIO_EXT_MD_DUMP, 1);
mt_set_gpio_mode(GPIO_EXT_MD_DUMP, GPIO_EXT_MD_DUMP_M_GPIO);
EMD_MSG_INF("chr","cm_gpio_setup:evb GPIO_EXT_MD_DUMP(%x)(in)=(%d)\n",GPIO_EXT_MD_DUMP,mt_get_gpio_in(GPIO_EXT_MD_DUMP));
#endif
// Configure eint
eint_var_init();
}
void cm_release_wakeup_md_signal(void)
{
if(atomic_read(&allow_wk_md)) {
mt_set_gpio_out(GPIO_EXT_AP_WK_MD, 1);
EMD_MSG_INF("chr","cm_release_wakeup_md_signal:GPIO_EXT_AP_WK_MD=%d,1!\n",mt_get_gpio_out(GPIO_EXT_AP_WK_MD));
} else {
EMD_MSG_INF("chr","cm_release_wakeup_md_signal:GPIO_EXT_AP_WK_MD=%d,ignore!\n",mt_get_gpio_out(GPIO_EXT_AP_WK_MD));
}
}
void cm_dump_gpio(void)
{
unsigned int pin =0;
pin=GPIO_EXT_MD_DL_KEY;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_DL_KEY: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
pin=GPIO_EXT_MD_PWR_KEY;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_PWR_KEY: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
pin=GPIO_EXT_MD_RST;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_RST: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
pin=GPIO_EXT_MD_WD;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_WD: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
pin=GPIO_EXT_MD_WK_AP;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_WK_AP: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
pin=GPIO_EXT_AP_WK_MD;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_AP_WK_MD: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
pin=GPIO_EXT_MD_EXP;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_EXP: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
pin=GPIO_EXT_MD_DUMP;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_DUMP: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
#ifndef GPIO_EXT_USB_SW2
pin=GPIO_EXT_MD_META;
EMD_MSG_INF("chr","cm_dump_gpio:GPIO_EXT_MD_META: dir(%d) in(%d),out(%d)\n", \
mt_get_gpio_dir(pin), mt_get_gpio_in(pin), mt_get_gpio_out(pin));
#endif
}
void cm_hold_rst_signal(void)
{
EMD_MSG_INF("chr","cm_hold_rst_signal1:GPIO_EXT_MD_RST(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_RST));
mt_set_gpio_dir(GPIO_EXT_MD_RST, 1);
#ifdef GPIO_EXT_USB_SW2
mt_set_gpio_out(GPIO_EXT_MD_RST, 0);
EMD_MSG_INF("chr","cm_hold_rst_signal2:set evb GPIO_EXT_MD_RST(out)=%d!\n",mt_get_gpio_out(GPIO_EXT_MD_RST));
#else
mt_set_gpio_out(GPIO_EXT_MD_RST, 1);
EMD_MSG_INF("chr","cm_hold_rst_signal2:set phone GPIO_EXT_MD_RST(out)=%d!\n",mt_get_gpio_out(GPIO_EXT_MD_RST));
#endif
}
void cm_relese_rst_signal(void)
{
EMD_MSG_INF("chr","cm_relese_rst_signal1:GPIO_EXT_MD_RST(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_RST));
mt_set_gpio_dir(GPIO_EXT_MD_RST, 1);
#ifdef GPIO_EXT_USB_SW2
mt_set_gpio_out(GPIO_EXT_MD_RST, 1);
EMD_MSG_INF("chr","cm_relese_rst_signal2:GPIO_EXT_MD_RST(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_RST));
mt_set_gpio_pull_enable(GPIO_EXT_MD_RST, 1);
mt_set_gpio_dir(GPIO_EXT_MD_RST, 0);
mt_set_gpio_pull_select(GPIO_EXT_MD_RST, 1);
EMD_MSG_INF("chr","cm_relese_rst_signal3:set evb GPIO_EXT_MD_RST(in)=%d!\n",mt_get_gpio_in(GPIO_EXT_MD_RST));
#else
mt_set_gpio_out(GPIO_EXT_MD_RST, 0);
EMD_MSG_INF("chr","cm_relese_rst_signal3:set phoneGPIO_EXT_MD_RST(in)=%d!\n",mt_get_gpio_in(GPIO_EXT_MD_RST));
#endif
}
static ssize_t eamp_openheadPhone()
{
mt_set_gpio_out(GPIO_HP_AMP_EN, GPIO_OUT_ONE);
EAMP_PRINTK("eamp_openheadphone : set GPIO_HP_AMP_EN to %d", mt_get_gpio_out(GPIO_HP_AMP_EN));
ghp_on = true;
return 0;
}
static ssize_t eamp_closeheadPhone()
{
mt_set_gpio_out(GPIO_HP_AMP_EN, GPIO_OUT_ZERO);
EAMP_PRINTK("eamp_closeheadphone : set GPIO_HP_AMP_EN to %d", mt_get_gpio_out(GPIO_HP_AMP_EN));
ghp_on = false;
return 0;
}
int oem_gpio_get_value(int gpio)
{
if(GPIO_DIR_IN == mt_get_gpio_dir(gpio)){
return mt_get_gpio_in(gpio);
}else{
return mt_get_gpio_out(gpio);
}
}
static void md_gpio_get(GPIO_PIN pin, char *tag)
{
pr_debug
("GPIO%d(%s): mode=%d,dir=%d,in=%d,out=%d,pull_en=%d,pull_sel=%d,smt=%d\n",
pin, tag, mt_get_gpio_mode(pin), mt_get_gpio_dir(pin),
mt_get_gpio_in(pin), mt_get_gpio_out(pin),
mt_get_gpio_pull_enable(pin), mt_get_gpio_pull_select(pin),
mt_get_gpio_smt(pin));
}
static ssize_t mt_gpio_dump_regs(char *buf, ssize_t bufLen)
{
int idx = 0, len = 0;
GPIOMSG("PIN: [DIR] [DOUT] [DIN]\n");
for (idx = 0; idx < 8; idx++) {
len += snprintf(buf+len, bufLen-len, "%d: %d %d %d\n",
idx, mt_get_gpio_dir(idx), mt_get_gpio_out(idx),mt_get_gpio_in(idx));
}
GPIOMSG("PIN: [MODE] [PULL_SEL] [DIN] [DOUT] [PULL EN] [DIR] [INV]\n");
for (idx = GPIO_EXTEND_START; idx < MAX_GPIO_PIN; idx++) {
len += snprintf(buf+len, bufLen-len, "%d: %d %d %d %d %d %d %d\n",
idx,mt_get_gpio_mode(idx), mt_get_gpio_pull_select(idx), mt_get_gpio_in(idx),mt_get_gpio_out(idx),
mt_get_gpio_pull_enable(idx),mt_get_gpio_dir(idx),mt_get_gpio_inversion(idx));
}
return len;
}
/*----------------------------------------------------------------------------*/
void gpio_dump_regs(void)
{
int idx = 0;
GPIOMSG("PIN: [MODE] [PULL_SEL] [DIN] [DOUT] [PULL EN] [DIR] [INV] [IES]\n");
for (idx = 0; idx < MT_GPIO_MAX_PIN; idx++) {
printk("idx = %3d: %d %d %d %d %d %d %d %d\n",
idx,mt_get_gpio_mode(idx), mt_get_gpio_pull_select(idx), mt_get_gpio_in(idx),mt_get_gpio_out(idx),
mt_get_gpio_pull_enable(idx),mt_get_gpio_dir(idx),mt_get_gpio_inversion(idx),mt_get_gpio_ies(idx));
}
}
kal_bool is_charging_ic_enable(void)
{
if(mt_get_gpio_out(CHG_EN_SET_N))
{
return KAL_FALSE; // charging disable
}
else
{
return KAL_TRUE; // charging enable
}
}
int c2k_gpio_get_value(int gpio)
{
#ifdef CONFIG_EVDO_DT_VIA_SUPPORT
if (GPIO_DIR_IN == mt_get_gpio_dir(gpio))
return mt_get_gpio_in(gpio);
else
return mt_get_gpio_out(gpio);
#else
return c2k_gpio_get_ls(gpio);
#endif
}
INT32
wmt_plat_rst_ctrl (
ENUM_PIN_STATE state
)
{
switch(state)
{
case PIN_STA_INIT:
/*set to gpio output low, disable pull*/
mt_set_gpio_pull_enable(GPIO_COMBO_RST_PIN, GPIO_PULL_DISABLE);
mt_set_gpio_dir(GPIO_COMBO_RST_PIN, GPIO_DIR_OUT);
mt_set_gpio_mode(GPIO_COMBO_RST_PIN, GPIO_MODE_GPIO);
mt_set_gpio_out(GPIO_COMBO_RST_PIN, GPIO_OUT_ZERO);
WMT_DBG_FUNC("WMT-PLAT:RST init (out 0) \n");
break;
case PIN_STA_OUT_H:
mt_set_gpio_out(GPIO_COMBO_RST_PIN, GPIO_OUT_ONE);
WMT_DBG_FUNC("WMT-PLAT:RST (out 1) \n");
break;
case PIN_STA_OUT_L:
mt_set_gpio_out(GPIO_COMBO_RST_PIN, GPIO_OUT_ZERO);
WMT_DBG_FUNC("WMT-PLAT:RST (out 0) \n");
break;
case PIN_STA_IN_L:
case PIN_STA_DEINIT:
/*set to gpio input low, pull down enable*/
mt_set_gpio_mode(GPIO_COMBO_RST_PIN, GPIO_COMBO_RST_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_COMBO_RST_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_select(GPIO_COMBO_RST_PIN, GPIO_PULL_DOWN);
mt_set_gpio_pull_enable(GPIO_COMBO_RST_PIN, GPIO_PULL_ENABLE);
WMT_DBG_FUNC("WMT-PLAT:RST deinit (in pd) \n");
break;
case PIN_STA_SHOW:
WMT_INFO_FUNC("WMT-PLAT:RST PIN_STA_SHOW start\n");
WMT_INFO_FUNC("WMT-PLAT:RST Mode(%d)\n", mt_get_gpio_mode(GPIO_COMBO_RST_PIN));
WMT_INFO_FUNC("WMT-PLAT:RST Dir(%d)\n", mt_get_gpio_dir(GPIO_COMBO_RST_PIN));
WMT_INFO_FUNC("WMT-PLAT:RST Pull enable(%d)\n", mt_get_gpio_pull_enable(GPIO_COMBO_RST_PIN));
WMT_INFO_FUNC("WMT-PLAT:RST Pull select(%d)\n", mt_get_gpio_pull_select(GPIO_COMBO_RST_PIN));
WMT_INFO_FUNC("WMT-PLAT:RST out(%d)\n", mt_get_gpio_out(GPIO_COMBO_RST_PIN));
WMT_INFO_FUNC("WMT-PLAT:RST PIN_STA_SHOW end\n");
break;
default:
WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on RST\n", state);
break;
}
return 0;
}
static int eamp_read_procmem(char *buf, char **start, off_t offset,
int count , int *eof, void *data)
{
int len = 0;
u8 val;
EAMP_PRINTK("S\n");
len += sprintf(buf + len , "SPK Amp Enable GPIO (%d) = %s\n", mt_get_gpio_out(GPIO_SPK_AMP_EN), ON_OFF_STR(mt_get_gpio_out(GPIO_SPK_AMP_EN)));
len += sprintf(buf + len , "HPH Amp Enable GPIO (%d) = %s\n", mt_get_gpio_out(GPIO_HP_AMP_EN), ON_OFF_STR(mt_get_gpio_out(GPIO_HP_AMP_EN)));
if (gep_on == true) {
len += sprintf(buf + len , "gep_on is %d, RCV ON\n", gep_on);
} else {
len += sprintf(buf + len , "gep_on is %d, RCV OFF\n", gep_on);
}
eamp_read_byte(IC_CONTROL, &val);
len += sprintf(buf + len , "IC_CONTROL = 0x%x\n", val);
eamp_read_byte(AGC_ATTACK_CONTROL, &val);
len += sprintf(buf + len , "AGC_ATTACK_CONTROL = 0x%x\n", val);
eamp_read_byte(AGC_RELEASE_CONTROL, &val);
len += sprintf(buf + len , "AGC_RELEASE_CONTROL = 0x%x\n", val);
eamp_read_byte(AGC_HOLD_TIME_CONTROL, &val);
len += sprintf(buf + len , "AGC_HOLD_TIME_CONTROL = 0x%x\n", val);
eamp_read_byte(AGC_FIXED_GAIN_CONTROL, &val);
len += sprintf(buf + len , "AGC_FIXED_GAIN_CONTROL = 0x%x\n", val);
eamp_read_byte(AGC1_CONTROL, &val);
len += sprintf(buf + len , "AGC1_CONTROL = 0x%x\n", val);
eamp_read_byte(AGC2_CONTROL, &val);
len += sprintf(buf + len , "AGC2_CONTROL = 0x%x\n", val);
return len;
}
//sim switch hardware initial
static int ssw_init(unsigned int mode)
{
SSW_DBG("ssw_init: %s \n", mode?"Single Talk":"Dual Talk");
unsigned int ch_mode, en_mode;
//ch_swap = GPIO_SSW_CH_SWAP_PIN;
//en = GPIO_SSW_EN_PIN;
//ch_mode = GPIO_SSW_CH_SWAP_PIN_M_GPIO;
//en_mode = GPIO_SSW_EN_PIN_M_GPIO;
ch_swap = GPIO101;
en = GPIO105;
ch_mode = GPIO_MODE_00;
en_mode = GPIO_MODE_00;
//initial Ch_Swap pin: 1, host1->sim slot1, host2->sim slot2; 0, host1->sim slot2, host2->sim slot1
mt_set_gpio_mode(ch_swap, ch_mode);
mt_set_gpio_dir(ch_swap, GPIO_DIR_OUT);
//initial EN pin: 1, enable sim slot; 0, disable sim slot
mt_set_gpio_mode(en, en_mode);
mt_set_gpio_dir(en, GPIO_DIR_OUT);
curr_ssw_mode = mode;
if (mode == SSW_DUAL_TALK) {
mt_set_gpio_out(ch_swap, GPIO_OUT_ONE);
} else if (mode == SSW_SING_TALK) {
mt_set_gpio_out(ch_swap, GPIO_OUT_ZERO);
}
mt_set_gpio_out(en, GPIO_OUT_ONE);
SSW_DBG("ssw_init: ch_swap=(%d %d %d), en=(%d %d %d) \n",
ch_swap, ch_mode, mt_get_gpio_out(ch_swap),
en, en_mode, mt_get_gpio_out(en));
return 0;
}
int cm_enter_md_download_mode(void)
{
#ifdef CONFIG_MTK_DT_USB_SUPPORT
#ifdef CONFIG_PM_RUNTIME
/* make sure usb device tree is waked up so that usb is ready */
usb11_auto_resume();
#endif
#endif
EMD_MSG_INF("chr","cm_do_md_power_on:set GPIO_EXT_MD_DL_KEY(%d)\n",GPIO_EXT_MD_DL_KEY);
// Press download key to let md can enter download mode
mt_set_gpio_dir(GPIO_EXT_MD_DL_KEY, 1);
#ifdef GPIO_EXT_USB_SW2
mt_set_gpio_out(GPIO_EXT_MD_DL_KEY, 0);
EMD_MSG_INF("chr","cm_do_md_power_on:set evb GPIO_EXT_MD_DL_KEY=%d\n",mt_get_gpio_out(GPIO_EXT_MD_DL_KEY));
#else
mt_set_gpio_out(GPIO_EXT_MD_DL_KEY, 1);
EMD_MSG_INF("chr","cm_do_md_power_on:set phone GPIO_EXT_MD_DL_KEY=%d\n",mt_get_gpio_out(GPIO_EXT_MD_DL_KEY));
#endif
mt_set_gpio_dir(GPIO_EXT_MD_WK_AP, 0);
mt_set_gpio_pull_enable(GPIO_EXT_MD_WK_AP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_WK_AP, 0);
// Press power key
mt_set_gpio_dir(GPIO_EXT_MD_PWR_KEY, 1);
mt_set_gpio_out(GPIO_EXT_MD_PWR_KEY, 1);
msleep(POWER_ON_WAIT_RESET_TIME);
ignore_wdt_interrupt = 1;
cm_hold_rst_signal();
msleep(RESET_WAIT_RELEASE_TIME);
cm_relese_rst_signal();
// Hold on
msleep(POWER_ON_HOLD_TIME);
cm_enable_ext_md_wdt_irq();
cm_enable_ext_md_wakeup_irq();
cm_enable_ext_md_exp_irq();
return 0;
}
static int eamp_init()
{
int result = 0;
result = mt_set_gpio_mode(GPIO_HP_AMP_EN, GPIO_HP_AMP_EN_M_GPIO);
EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_mode %d\n", result);
result = mt_set_gpio_pull_enable(GPIO_HP_AMP_EN, GPIO_PULL_DISABLE);
EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_pull_enable %d\n", result);
result = mt_set_gpio_dir(GPIO_HP_AMP_EN, GPIO_DIR_OUT);
EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_dir %d\n", result);
result = mt_set_gpio_out(GPIO_HP_AMP_EN, GPIO_OUT_ONE);
EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_out %d, %d\n", result, mt_get_gpio_out(GPIO_HP_AMP_EN));
result = mt_set_gpio_mode(GPIO_SPK_AMP_EN, GPIO_SPK_AMP_EN_M_GPIO);
EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_mode %d\n", result);
result = mt_set_gpio_pull_enable(GPIO_SPK_AMP_EN, GPIO_PULL_DISABLE);
EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_pull_enable %d\n", result);
result = mt_set_gpio_dir(GPIO_SPK_AMP_EN, GPIO_DIR_OUT);
EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_dir %d\n", result);
result = mt_set_gpio_out(GPIO_SPK_AMP_EN, GPIO_OUT_ONE);
EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_out %d, %d\n", result, mt_get_gpio_out(GPIO_SPK_AMP_EN));
eamp_poweron();
eamp_powerdown();
return 0;
}
static int hw_get_gpio_value(int index)
{
switch(index){
case SDA_GPIO_INDX :
return mt_get_gpio_in(GPIO_I2C2_SDA_PIN);
case SCL_GPIO_INDX :
return mt_get_gpio_in(GPIO_I2C2_SCA_PIN);
case IRQ_GPIO_INDX :
return mt_get_gpio_in(GPIO_CTP_EINT_PIN);
case RST_GPIO_INDX :
return mt_get_gpio_out(GPIO_CTP_RST_PIN);
case IR_GPIO_INDX :
return mt_get_gpio_in(GPIO_IR_EINT_PIN);
default:
return -1 ;
}
return -1 ;
}
int cm_do_md_power_on(int bootmode)
{
EMD_MSG_INF("chr","cm_do_md_power_on\n");
cm_disable_ext_md_wdt_irq();
cm_disable_ext_md_wakeup_irq();
cm_disable_ext_md_exp_irq();
// Release download key to let md can enter normal boot
mt_set_gpio_dir(GPIO_EXT_MD_DL_KEY, 1);
#ifdef GPIO_EXT_USB_SW2
mt_set_gpio_out(GPIO_EXT_MD_DL_KEY, 1);
EMD_MSG_INF("chr","cm_do_md_power_on:set evb GPIO_EXT_MD_DL_KEY=%d\n",mt_get_gpio_out(GPIO_EXT_MD_DL_KEY));
#else
mt_set_gpio_out(GPIO_EXT_MD_DL_KEY, 0);
EMD_MSG_INF("chr","cm_do_md_power_on:set phone GPIO_EXT_MD_DL_KEY=%d\n",mt_get_gpio_out(GPIO_EXT_MD_DL_KEY));
#endif
mt_set_gpio_dir(GPIO_EXT_MD_PWR_KEY, 1);
mt_set_gpio_out(GPIO_EXT_MD_PWR_KEY, 1);
msleep(POWER_ON_WAIT_RESET_TIME);
ignore_wdt_interrupt = 1;
cm_hold_rst_signal();
is_hold_rst = 1;
EMD_MSG_INF("chr","cm_do_md_power_on:reset GPIO_EXT_MD_DL_KEY(%d),GPIO_EXT_MD_PWR_KEY(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_DL_KEY),mt_get_gpio_out(GPIO_EXT_MD_PWR_KEY));
if(bootmode)
{
#ifndef GPIO_EXT_USB_SW2
mt_set_gpio_dir(GPIO_EXT_MD_META, 1);
mt_set_gpio_out(GPIO_EXT_MD_META, 1);
EMD_MSG_INF("chr","cm_do_md_power_on:meta mode,phone GPIO_EXT_MD_META(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_META));
#else
mt_set_gpio_pull_enable(GPIO_EXT_MD_DUMP, 1);
mt_set_gpio_dir(GPIO_EXT_MD_DUMP, 1);
mt_set_gpio_out(GPIO_EXT_MD_DUMP, 1);
EMD_MSG_INF("chr","cm_do_md_power_on:meta mode,evb GPIO_EXT_MD_DUMP(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_DUMP));
#endif
}
else
{
#ifndef GPIO_EXT_USB_SW2
mt_set_gpio_dir(GPIO_EXT_MD_META, 1);
mt_set_gpio_out(GPIO_EXT_MD_META, 0);
EMD_MSG_INF("chr","cm_do_md_power_on,phone GPIO_EXT_MD_META(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_META));
#else
mt_set_gpio_dir(GPIO_EXT_MD_DUMP, 1);
mt_set_gpio_out(GPIO_EXT_MD_DUMP, 0);
EMD_MSG_INF("chr","cm_do_md_power_on,evb GPIO_EXT_MD_DUMP(%d)\n",mt_get_gpio_out(GPIO_EXT_MD_DUMP));
#endif
}
mt_set_gpio_dir(GPIO_EXT_MD_WK_AP, 0);
mt_set_gpio_pull_enable(GPIO_EXT_MD_WK_AP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_WK_AP, 0);
mt_set_gpio_dir(GPIO_EXT_MD_EXP, 0);
mt_set_gpio_pull_enable(GPIO_EXT_MD_EXP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_EXP, 1);
mtk_uart_freeze_enable(uart_port,1);
msleep(RESET_WAIT_RELEASE_TIME);
//For low power, we switch UART GPIO when power off md, so restore here according to dws default setting.
mt_set_gpio_mode(GPIO_UART_URXD1_PIN, 1);
mt_set_gpio_mode(GPIO_UART_UTXD1_PIN, 1);
mt_set_gpio_mode(GPIO_UART_URTS1_PIN, 1);
mt_set_gpio_mode(GPIO_UART_UCTS1_PIN, 1);
mt_set_gpio_dir(GPIO_UART_URXD1_PIN, 0);
mt_set_gpio_pull_enable(GPIO_UART_URXD1_PIN, 1);
mt_set_gpio_pull_select(GPIO_UART_URXD1_PIN, 1);
mt_set_gpio_dir(GPIO_UART_UTXD1_PIN, 1);
mt_set_gpio_out(GPIO_UART_UTXD1_PIN, 1);
mt_set_gpio_dir(GPIO_UART_URTS1_PIN, 1);
mt_set_gpio_out(GPIO_UART_URTS1_PIN, 1);
mt_set_gpio_dir(GPIO_UART_UCTS1_PIN, 0);
mt_set_gpio_pull_enable(GPIO_UART_UCTS1_PIN, 1);
mt_set_gpio_pull_select(GPIO_UART_UCTS1_PIN, 1);
EMD_MSG_INF("chr","uart gpio restore\n");
EMD_MSG_INF("chr","cm_do_md_power_on: GPIO_EXT_MD_EXP(%d),GPIO_EXT_MD_WD(%d),GPIO_EXT_MD_RST(%d),GPIO_EXT_MD_PWR_KEY(%d)\n", \
mt_get_gpio_in(GPIO_EXT_MD_EXP),mt_get_gpio_in(GPIO_EXT_MD_WD),mt_get_gpio_out(GPIO_EXT_MD_RST),mt_get_gpio_out(GPIO_EXT_MD_PWR_KEY));
return 0;
}
/*---------------------------------------------------------------------------*/
static long mt_gpio_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct mt_gpio_obj_t *obj = mt_gpio;
long res;
unsigned long pin;
GPIOFUC();
if (obj == NULL) {
GPIOERR("NULL pointer");
return -EFAULT;
}
switch(cmd)
{
case GPIO_IOCQMODE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_mode(pin);
break;
}
case GPIO_IOCTMODE0:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_00);
break;
}
case GPIO_IOCTMODE1:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_01);
break;
}
case GPIO_IOCTMODE2:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_02);
break;
}
case GPIO_IOCTMODE3:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_mode(pin, GPIO_MODE_03);
break;
}
case GPIO_IOCQDIR:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_dir(pin);
break;
}
case GPIO_IOCSDIRIN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_dir(pin, GPIO_DIR_IN);
break;
}
case GPIO_IOCSDIROUT:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_dir(pin, GPIO_DIR_OUT);
break;
}
case GPIO_IOCQPULLEN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_pull_enable(pin);
break;
}
case GPIO_IOCSPULLENABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_enable(pin, TRUE);
break;
}
case GPIO_IOCSPULLDISABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_enable(pin, FALSE);
break;
}
case GPIO_IOCQPULL:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_pull_select(pin);
break;
}
case GPIO_IOCSPULLDOWN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_select(pin, GPIO_PULL_DOWN);
break;
}
case GPIO_IOCSPULLUP:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_pull_select(pin, GPIO_PULL_UP);
break;
}
case GPIO_IOCQINV:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_inversion(pin);
break;
}
case GPIO_IOCSINVENABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_inversion(pin, TRUE);
break;
}
case GPIO_IOCSINVDISABLE:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_inversion(pin, FALSE);
break;
}
case GPIO_IOCQDATAIN:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EFAULT) : mt_get_gpio_in(pin);
break;
}
case GPIO_IOCQDATAOUT:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_get_gpio_out(pin);
break;
}
case GPIO_IOCSDATALOW:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_out(pin, GPIO_OUT_ZERO);
break;
}
case GPIO_IOCSDATAHIGH:
{
pin = (unsigned long)arg;
res = GIO_INVALID_OBJ(obj) ? (-EACCES) : mt_set_gpio_out(pin, GPIO_OUT_ONE);
break;
}
default:
{
res = -EPERM;
break;
}
}
if (res == -EACCES)
GPIOERR(" cmd = 0x%8X, invalid pointer\n", cmd);
else if (res < 0)
GPIOERR(" cmd = 0x%8X, err = %ld\n", cmd, res);
return res;
}
int cm_do_md_go(void)
{
int ret = -1;
if (is_hold_rst)
{
is_hold_rst=0;
unsigned int retry = 100;
EMD_MSG_INF("chr","cm_do_md_go:1\n");
EMD_MSG_INF("chr","cm_do_md_go2:GPIO_EXT_MD_RST(out)=%d,GPIO_EXT_MD_WD(in)=%d\n",mt_get_gpio_out(GPIO_EXT_MD_RST),mt_get_gpio_in(GPIO_EXT_MD_WD));
cm_relese_rst_signal();
atomic_set(&traffic_on, 1);
EMD_MSG_INF("chr","cm_do_md_go3:GPIO_EXT_MD_RST(out)=%d,GPIO_EXT_MD_WD(in)=%d\n",mt_get_gpio_out(GPIO_EXT_MD_RST),mt_get_gpio_in(GPIO_EXT_MD_WD));
// Check WDT pin to high
while(retry>0){
retry--;
if(mt_get_gpio_in(GPIO_EXT_MD_WD)==0)
{
msleep(10);
}
else
{
ret=100-retry;
break;
}
}
EMD_MSG_INF("chr","cm_do_md_go4:GPIO_EXT_MD_RST(out)=%d,GPIO_EXT_MD_WD(in)=%d\n",mt_get_gpio_out(GPIO_EXT_MD_RST),mt_get_gpio_in(GPIO_EXT_MD_WD));
msleep(POWER_ON_HOLD_TIME);
mt_set_gpio_out(GPIO_EXT_MD_PWR_KEY, 0);
}
mt_set_gpio_dir(GPIO_EXT_MD_WK_AP, 0);
mt_set_gpio_pull_enable(GPIO_EXT_MD_WK_AP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_WK_AP, 1);
cm_enable_ext_md_wdt_irq();
cm_enable_ext_md_wakeup_irq();
cm_enable_ext_md_exp_irq();
msleep(50);
ignore_wdt_interrupt = 0;
return ret;
}
void cm_hold_wakeup_md_signal(void)
{
EMD_MSG_INF("chr","cm_hold_wakeup_md_signal:GPIO_EXT_AP_WK_MD=%d,0!\n",mt_get_gpio_out(GPIO_EXT_AP_WK_MD));
mt_set_gpio_out(GPIO_EXT_AP_WK_MD, 0);
}
void cm_release_wakeup_md_signal(void)
{
mt_set_gpio_out(GPIO_EXT_AP_WK_MD, 1);
EMD_MSG_INF("chr","cm_release_wakeup_md_signal:GPIO_EXT_AP_WK_MD=%d,1!\n",mt_get_gpio_out(GPIO_EXT_AP_WK_MD));
}
void inno_chip_reset(void)
{
mt_set_gpio_mode(GPIO_CMMB_RST_PIN, GPIO_CMMB_RST_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_CMMB_RST_PIN, GPIO_DIR_OUT);
// mdelay(1);
mt_set_gpio_out(GPIO_CMMB_RST_PIN, GPIO_OUT_ZERO);
mdelay(30); //delay for power to reset typical:10ms max:50ms
mt_set_gpio_out(GPIO_CMMB_RST_PIN, GPIO_OUT_ONE);
// mt_set_gpio_pull_enable(GPIO_CMMB_RST_PIN, 1);
// mt_set_gpio_pull_select(GPIO_CMMB_RST_PIN, 1);
inno_msg("CMMB GPIO RST PIN mode:num:%d, %d,out:%d, dir:%d,pullen:%d,pullup%d",GPIO_CMMB_RST_PIN,mt_get_gpio_mode(GPIO_CMMB_RST_PIN),mt_get_gpio_out(GPIO_CMMB_RST_PIN),mt_get_gpio_dir(GPIO_CMMB_RST_PIN),mt_get_gpio_pull_enable(GPIO_CMMB_RST_PIN),mt_get_gpio_pull_select(GPIO_CMMB_RST_PIN));
mdelay(30); //delay for waiting system ready typical:10ms max:50ms
}
int cm_do_md_go(void)
{
int ret = -1;
if (is_hold_rst)
{
is_hold_rst=0;
unsigned int retry = 100;
EMD_MSG_INF("chr","cm_do_md_go:1\n");
EMD_MSG_INF("chr","cm_do_md_go2:GPIO_EXT_MD_RST(out)=%d,GPIO_EXT_MD_WD(in)=%d\n",mt_get_gpio_out(GPIO_EXT_MD_RST),mt_get_gpio_in(GPIO_EXT_MD_WD));
cm_relese_rst_signal();
EMD_MSG_INF("chr","cm_do_md_go3:GPIO_EXT_MD_RST(out)=%d,GPIO_EXT_MD_WD(in)=%d\n",mt_get_gpio_out(GPIO_EXT_MD_RST),mt_get_gpio_in(GPIO_EXT_MD_WD));
// Check WDT pin to high
while(retry>0){
retry--;
if(mt_get_gpio_in(GPIO_EXT_MD_WD)==0)
{
msleep(10);
}
else
{
ret=100-retry;
break;
}
}
atomic_set(&traffic_on, 1);
msleep(1000); // for use AP_WK_MD as EXT_MD_META, give 6261 bootloader sometime to read boot mode
atomic_set(&allow_wk_md, 1);
cm_hold_wakeup_md_signal();
EMD_MSG_INF("chr","cm_do_md_go4:GPIO_EXT_MD_RST(out)=%d,GPIO_EXT_MD_WD(in)=%d\n",mt_get_gpio_out(GPIO_EXT_MD_RST),mt_get_gpio_in(GPIO_EXT_MD_WD));
msleep(POWER_ON_HOLD_TIME);
mt_set_gpio_out(GPIO_EXT_MD_PWR_KEY, 0);
}
mt_set_gpio_dir(GPIO_EXT_MD_WK_AP, 0);
mt_set_gpio_pull_enable(GPIO_EXT_MD_WK_AP, 1);
mt_set_gpio_pull_select(GPIO_EXT_MD_WK_AP, 1);
cm_enable_ext_md_wdt_irq();
cm_enable_ext_md_wakeup_irq();
cm_enable_ext_md_exp_irq();
//msleep(50); // WDT IRQ is level triggered now, no need this debounce
ignore_wdt_interrupt = 0;
return ret;
}
void mt_gpio_self_test(void)
{
int i, val;
for (i = 0; i < MT_GPIO_EXT_MAX; i++)
{
s32 res,old;
GPIOMSG("GPIO-%3d test\n", i);
/*direction test*/
old = mt_get_gpio_dir(i);
if (old == 0 || old == 1) {
GPIOLOG(" dir old = %d\n", old);
} else {
GPIOERR(" test dir fail: %d\n", old);
break;
}
if ((res = mt_set_gpio_dir(i, GPIO_DIR_OUT)) != RSUCCESS) {
GPIOERR(" set dir out fail: %d\n", res);
break;
} else if ((res = mt_get_gpio_dir(i)) != GPIO_DIR_OUT) {
GPIOERR(" get dir out fail: %d\n", res);
break;
} else {
/*output test*/
s32 out = mt_get_gpio_out(i);
if (out != 0 && out != 1) {
GPIOERR(" get out fail = %d\n", old);
break;
}
for (val = 0; val < GPIO_OUT_MAX; val++) {
if ((res = mt_set_gpio_out(i,0)) != RSUCCESS) {
GPIOERR(" set out[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_out(i)) != 0) {
GPIOERR(" get out[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_out(i,out)) != RSUCCESS)
{
GPIOERR(" restore out fail: %d\n", res);
break;
}
}
if ((res = mt_set_gpio_dir(i, GPIO_DIR_IN)) != RSUCCESS) {
GPIOERR(" set dir in fail: %d\n", res);
break;
} else if ((res = mt_get_gpio_dir(i)) != GPIO_DIR_IN) {
GPIOERR(" get dir in fail: %d\n", res);
break;
} else {
GPIOLOG(" input data = %d\n", res);
}
if ((res = mt_set_gpio_dir(i, old)) != RSUCCESS) {
GPIOERR(" restore dir fail: %d\n", res);
break;
}
for (val = 0; val < GPIO_PULL_EN_MAX; val++) {
if ((res = mt_set_gpio_pull_enable(i,val)) != RSUCCESS) {
GPIOERR(" set pullen[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_pull_enable(i)) != val) {
GPIOERR(" get pullen[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_pull_enable(i, old)) != RSUCCESS) {
GPIOERR(" restore pullen fail: %d\n", res);
break;
}
/*pull select test*/
old = mt_get_gpio_pull_select(i);
if (old == 0 || old == 1)
GPIOLOG(" pullsel old = %d\n", old);
else {
GPIOERR(" pullsel fail: %d\n", old);
break;
}
for (val = 0; val < GPIO_PULL_MAX; val++) {
if ((res = mt_set_gpio_pull_select(i,val)) != RSUCCESS) {
GPIOERR(" set pullsel[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_pull_select(i)) != val) {
GPIOERR(" get pullsel[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_pull_select(i, old)) != RSUCCESS)
{
GPIOERR(" restore pullsel fail: %d\n", res);
break;
}
/*data inversion*/
old = mt_get_gpio_inversion(i);
if (old == 0 || old == 1)
GPIOLOG(" inv old = %d\n", old);
else {
GPIOERR(" inv fail: %d\n", old);
break;
}
for (val = 0; val < GPIO_DATA_INV_MAX; val++) {
if ((res = mt_set_gpio_inversion(i,val)) != RSUCCESS) {
GPIOERR(" set inv[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_inversion(i)) != val) {
GPIOERR(" get inv[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_inversion(i, old)) != RSUCCESS) {
GPIOERR(" restore inv fail: %d\n", res);
break;
}
/*mode control*/
// if((i<=GPIOEXT6) || (i >= GPIOEXT9)){
old = mt_get_gpio_mode(i);
if ((old >= GPIO_MODE_00) && (val < GPIO_MODE_MAX))
{
GPIOLOG(" mode old = %d\n", old);
}
else
{
GPIOERR(" get mode fail: %d\n", old);
break;
}
for (val = 0; val < GPIO_MODE_MAX; val++) {
if ((res = mt_set_gpio_mode(i, val)) != RSUCCESS) {
GPIOERR("set mode[%d] fail: %d\n", val, res);
break;
} else if ((res = mt_get_gpio_mode(i)) != val) {
GPIOERR("get mode[%d] fail: %d\n", val, res);
break;
}
}
if ((res = mt_set_gpio_mode(i,old)) != RSUCCESS) {
GPIOERR(" restore mode fail: %d\n", res);
break;
}
// }
}
GPIOLOG("GPIO test done\n");
}
/*
* Set and Reset SPI GPIO pins
*
* Parameter:
* enable <in> : Set and Reset SPI GPIO pins
*
* Example:
* INNO_SPI_Init(1); // Set SPI GPIO pins
* INNO_SPI_Init(0); // Reset SPI GPIO pins
*/
INNO_RET INNO_SPI_GPIO_Set(int enable)
{
mutex_lock(&inno_spi_mutex);
if(enable)
{
mt_set_gpio_mode(GPIO_SPI_CS_PIN, GPIO_SPI_CS_PIN_M_SPI_CS);
mt_set_gpio_pull_enable(GPIO_SPI_CS_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_SPI_CS_PIN, GPIO_PULL_UP);
mt_set_gpio_mode(GPIO_SPI_SCK_PIN, GPIO_SPI_SCK_PIN_M_SPI_CK);
mt_set_gpio_pull_enable(GPIO_SPI_SCK_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_SPI_SCK_PIN, GPIO_PULL_DOWN);
mt_set_gpio_mode(GPIO_SPI_MISO_PIN, GPIO_SPI_MISO_PIN_M_SPI_MI);
mt_set_gpio_pull_enable(GPIO_SPI_MISO_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_SPI_MISO_PIN, GPIO_PULL_DOWN);
mt_set_gpio_mode(GPIO_SPI_MOSI_PIN, GPIO_SPI_MOSI_PIN_M_SPI_MO);
mt_set_gpio_pull_enable(GPIO_SPI_MOSI_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_SPI_MOSI_PIN, GPIO_PULL_DOWN);
inno_msg("CMMB GPIO CS SPI PIN mode:num:%d, %d,out:%d, dir:%d,pullen:%d,pullup%d",GPIO_SPI_CS_PIN,mt_get_gpio_mode(GPIO_SPI_CS_PIN),mt_get_gpio_out(GPIO_SPI_CS_PIN),
mt_get_gpio_dir(GPIO_SPI_CS_PIN),mt_get_gpio_pull_enable(GPIO_SPI_CS_PIN),mt_get_gpio_pull_select(GPIO_SPI_CS_PIN));
}
else
{
mt_set_gpio_mode(GPIO_SPI_CS_PIN, GPIO_SPI_CS_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_SPI_CS_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_SPI_CS_PIN, GPIO_PULL_DISABLE);
mt_set_gpio_mode(GPIO_SPI_SCK_PIN, GPIO_SPI_SCK_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_SPI_SCK_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_SPI_SCK_PIN, GPIO_PULL_DISABLE);
mt_set_gpio_mode(GPIO_SPI_MISO_PIN, GPIO_SPI_MISO_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_SPI_MISO_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_SPI_MISO_PIN, GPIO_PULL_DISABLE);
mt_set_gpio_mode(GPIO_SPI_MOSI_PIN, GPIO_SPI_MOSI_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_SPI_MOSI_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_SPI_MOSI_PIN, GPIO_PULL_DISABLE);
}
mutex_unlock(&inno_spi_mutex);
return INNO_NO_ERROR;
}
