Ejemplo n.º 1
0
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;
}
Ejemplo n.º 3
0
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();
}
Ejemplo n.º 4
0
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));
	}
}
Ejemplo n.º 5
0
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
}
Ejemplo n.º 6
0
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
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 10
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);
    }
}
Ejemplo n.º 11
0
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));
}
Ejemplo n.º 12
0
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;
}
Ejemplo n.º 13
0
/*----------------------------------------------------------------------------*/
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)); 
    }
}
Ejemplo n.º 14
0
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
    }
}
Ejemplo n.º 15
0
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
}
Ejemplo n.º 16
0
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;
}
Ejemplo n.º 18
0
//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;
}
Ejemplo n.º 19
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;
}
Ejemplo n.º 21
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 ;
}
Ejemplo n.º 22
0
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;
}
Ejemplo n.º 23
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;
}
Ejemplo n.º 24
0
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;
}
Ejemplo n.º 25
0
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);
}
Ejemplo n.º 26
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));
}
Ejemplo n.º 27
0
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
}
Ejemplo n.º 28
0
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");
}
Ejemplo n.º 30
0
/*
 * 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;
	
}