static ssize_t battery_id_read_proc(char *page, char **start, off_t off,
int count, int *eof, void *data){
static int init = 0;
int batt_id1, batt_id2;
if(off > 0){
*eof = 1;
return 0;
}
if(!init){
mt_set_gpio_mode(GPIOEXT31, GPIO_MODE_00);
mt_set_gpio_dir(GPIOEXT31, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIOEXT31, GPIO_PULL_DISABLE);
mt_set_gpio_mode(GPIOEXT39, GPIO_MODE_00);
mt_set_gpio_dir(GPIOEXT39, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIOEXT39, GPIO_PULL_DISABLE);
msleep(100);
init = 1;
}
batt_id1 = mt_get_gpio_in(GPIOEXT31);
batt_id2 = mt_get_gpio_in(GPIOEXT39);
if(batt_id1 == 1 && batt_id2 == 1)
return sprintf(page, "%s\n", "LGC") + 1;
else if(batt_id1 == 0 && batt_id2 == 1)
return sprintf(page, "%s\n", "Panasonic") + 1;
else
return sprintf(page, "%s\n", "unknown") + 1;
}
static void tpd_fw_init()
{
#ifdef CTP_DETECT_SUPPLIER_THROUGH_GPIO
int tpd_choice[2] = {0};
#ifdef GPIO_CTP_COMPAT_PIN1
mt_set_gpio_mode(GPIO_CTP_COMPAT_PIN1, GPIO_MODE_00);
mt_set_gpio_dir(GPIO_CTP_COMPAT_PIN1, GPIO_DIR_IN);
tpd_choice[0] = mt_get_gpio_in(GPIO_CTP_COMPAT_PIN1);
#endif
#ifdef GPIO_CTP_COMPAT_PIN2
mt_set_gpio_mode(GPIO_CTP_COMPAT_PIN2, GPIO_MODE_00);
mt_set_gpio_dir(GPIO_CTP_COMPAT_PIN2, GPIO_DIR_IN);
tpd_choice[1] = mt_get_gpio_in(GPIO_CTP_COMPAT_PIN2);
#endif
TPD_DMESG("[TPD] tpd_choice[0] = 0x%x,tpd_choice[1] = 0x%x\n", tpd_choice[0], tpd_choice[1]);
if(tpd_choice[0] || tpd_choice[1])
{
tpd_compat.tpd_pt = TPD_FW0;
tpd_compat.size = sizeof(TPD_FW0);
tpd_supplier = TPD_SUPPLIER_0;
}
else
{
tpd_compat.tpd_pt = TPD_FW1;
tpd_compat.size = sizeof(TPD_FW1);
tpd_supplier = TPD_SUPPLIER_1;
}
#else //CTP_DETECT_SUPPLIER_THROUGH_GPIO
tpd_compat.tpd_pt = TPD_FW;
tpd_compat.size = sizeof(TPD_FW);
#endif //CTP_DETECT_SUPPLIER_THROUGH_GPIO
}
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();
}
static bool musb_is_host(void)
{
u8 devctl = 0;
int iddig_state = 1;
bool usb_is_host = 0;
DBG(0, "will mask PMIC charger detection\n");
#ifndef FPGA_PLATFORM
pmic_chrdet_int_en(0);
#endif
musb_platform_enable(mtk_musb);
#ifdef ID_PIN_USE_EX_EINT
#ifndef CONFIG_MTK_FPGA
#ifdef CONFIG_OF
#if defined(CONFIG_MTK_LEGACY)
iddig_state = mt_get_gpio_in(iddig_pin);
#else
iddig_state = __gpio_get_value(iddig_pin);
#endif
#else
iddig_state = mt_get_gpio_in(GPIO_OTG_IDDIG_EINT_PIN);
#endif
DBG(0, "iddig_state = %d\n", iddig_state);
#endif
#else
iddig_state = 0;
devctl = musb_readb(mtk_musb->mregs, MUSB_DEVCTL);
DBG(0, "devctl = %x before end session\n", devctl);
devctl &= ~MUSB_DEVCTL_SESSION; /* this will cause A-device change back to B-device after A-cable plug out */
musb_writeb(mtk_musb->mregs, MUSB_DEVCTL, devctl);
msleep(delay_time);
devctl = musb_readb(mtk_musb->mregs, MUSB_DEVCTL);
DBG(0, "devctl = %x before set session\n", devctl);
devctl |= MUSB_DEVCTL_SESSION;
musb_writeb(mtk_musb->mregs, MUSB_DEVCTL, devctl);
msleep(delay_time1);
devctl = musb_readb(mtk_musb->mregs, MUSB_DEVCTL);
DBG(0, "devclt = %x\n", devctl);
#endif
if (devctl & MUSB_DEVCTL_BDEVICE || iddig_state) {
DBG(0, "will unmask PMIC charger detection\n");
#ifndef FPGA_PLATFORM
pmic_chrdet_int_en(1);
#endif
usb_is_host = false;
} else {
usb_is_host = true;
}
DBG(0, "usb_is_host = %d\n", usb_is_host);
return usb_is_host;
}
static int get_lcd_id(void)
{
mt_set_gpio_mode(GPIO_LCD_ID_PIN,0);
mt_set_gpio_dir(GPIO_LCD_ID_PIN,0);
mt_set_gpio_pull_enable(GPIO_LCD_ID_PIN,1);
mt_set_gpio_pull_select(GPIO_LCD_ID_PIN,0);
MDELAY(1);
Lcd_Log("MYCAT ILI9806 A40318 get_lcd_id=%d\n",mt_get_gpio_in(GPIO_LCD_ID_PIN));
return mt_get_gpio_in(GPIO_LCD_ID_PIN);
}
static int get_lcd_id(void)
{
mt_set_gpio_mode(GPIO_LCD_ID_PIN,0);
mt_set_gpio_dir(GPIO_LCD_ID_PIN,0);
mt_set_gpio_pull_enable(GPIO_LCD_ID_PIN,1);
mt_set_gpio_pull_select(GPIO_LCD_ID_PIN,1);
MDELAY(1);
Lcd_Log("wqcat apex GPIO_LCD_ID_PIN=%d\n", mt_get_gpio_in(GPIO_LCD_ID_PIN));
return mt_get_gpio_in(GPIO_LCD_ID_PIN);
}
static void cci_get_platform_id(void)
{
platform_id = 0;
platform_id |= (mt_get_gpio_in(100)&0x01)?0x01:0x00;
platform_id |= (mt_get_gpio_in(101)&0x01)?0x02:0x00;
platform_id |= (mt_get_gpio_in(102)&0x01)?0x04:0x00;
platform_id |= (mt_get_gpio_in(105)&0x01)?0x08:0x00;
platform_id |= (mt_get_gpio_in(109)&0x01)?0x10:0x00;
}
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
}
static ssize_t rf_version_read_proc(char *page, char **start, off_t off,
int count, int *eof, void *data){
char messages[RF_VER_SIZE] = {0};
int rf_ver0 = 1; //gpioExt27
int rf_ver1 = 1; //gpioExt28
static int init = 0;
if(!init){
mt_set_gpio_mode(GPIOEXT27, GPIO_MODE_00);
mt_set_gpio_dir(GPIOEXT27, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIOEXT27, GPIO_PULL_DISABLE);
//mt_set_gpio_pull_select(GPIOEXT27, GPIO_PULL_UP);
mt_set_gpio_mode(GPIOEXT28, GPIO_MODE_00);
mt_set_gpio_dir(GPIOEXT28, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIOEXT28, GPIO_PULL_DISABLE);
//mt_set_gpio_pull_select(GPIOEXT28, GPIO_PULL_UP);
msleep(100);
init = 1;
}
rf_ver0 = mt_get_gpio_in(GPIOEXT27);
rf_ver1 = mt_get_gpio_in(GPIOEXT28);
if(rf_ver0 == 0 && rf_ver1 == 0){
sprintf(messages, "%s", "3G");
}
else if(rf_ver0 == 1 && rf_ver1 == 0){
sprintf(messages, "%s", "LTE");
}
else if(rf_ver0 == 0 && rf_ver1 == 1){
sprintf(messages, "%s", "WIFI");
}
else if(rf_ver0 == 1 && rf_ver1 == 1){
sprintf(messages, "%s", "MV");
}
else
sprintf(messages, "%s", "N/A");
messages[RF_VER_SIZE-1] = 0x0;
nvs_read();
sprintf(nvs->rf_version, "%s", messages);
nvs_write();
if(off > 0){
*eof = 1;
return 0;
}
return sprintf(page, "%s\n", messages) + 1;
}
int waitATTN(int code, int time)
{
int trial_us=0;
while ((mt_get_gpio_in(GPIO_CTP_EINT_PIN) != 0) && (trial_us < (time * 1000))) {
udelay(1);
trial_us++;
}
if (mt_get_gpio_in(GPIO_CTP_EINT_PIN) != 0)
return -EBUSY;
else
return 1;
}
static int lcm_check_id(void)
{
mt_set_gpio_mode(97,0);
mt_set_gpio_dir(97,0);
mt_set_gpio_pull_enable(97,1);
mt_set_gpio_pull_select(97,1);
//MDELAY(10);
/// mt_set_gpio_out(97,1);
MDELAY(20);
mt_get_gpio_in(97);
MDELAY(80);
return mt_get_gpio_in(97);
}
static unsigned int lcm_compare_id()
{
#if 0
unsigned int id = 0, id2 = 0;
unsigned char buffer[2];
unsigned int data_array[16];
SET_RESET_PIN(1); //NOTE:should reset LCM firstly
MDELAY(10);
SET_RESET_PIN(0);
MDELAY(10);
SET_RESET_PIN(1);
MDELAY(120);
data_array[0]=0x00043902;
data_array[1]=0x6983FFB9;
dsi_set_cmdq(&data_array, 2, 1);
MDELAY(10);
data_array[0] = 0x00023700;// read id return two byte,version and id
dsi_set_cmdq(data_array, 1, 1);
MDELAY(10);
read_reg_v2(0xF4, buffer, 2);
id = buffer[0]; //we only need ID
id2= buffer[1]; //we test buffer 1
#endif
unsigned int id=0;
mt_set_gpio_mode(50,0); // gpio mode high
mt_set_gpio_pull_enable(50,0);
mt_set_gpio_dir(50,0); //input
//mt_set_gpio_pull_select(50, 1);
mt_set_gpio_mode(47,0); // gpio mode low
mt_set_gpio_pull_enable(47,0);
mt_set_gpio_dir(47,0);
//mt_set_gpio_pull_select(47, 1);
id = (mt_get_gpio_in(50) <<4) | mt_get_gpio_in(47);
#if defined(BUILD_UBOOT)
printf("%s, id1 = 0x%08x\n", __func__, id);
#endif
return (LCM_ID == id)?1:0;
}
static ssize_t psensor_status_read_proc(char *page, char **start, off_t off,
int count, int *eof, void *data){
static int init = 0;
int psensor_status = 0;
if(off > 0){
*eof = 1;
return 0;
}
if(!init){
mt_set_gpio_mode(GPIO38, GPIO_MODE_00);
mt_set_gpio_dir(GPIO38, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO38, GPIO_PULL_DISABLE);
msleep(100);
init = 1;
}
psensor_status = mt_get_gpio_in(GPIO38);
if(psensor_status)
sprintf(nvs->psensor_status, "%s", "1");
else
sprintf(nvs->psensor_status, "%s", "0");
nvs_write();
return sprintf(page, "%s\n", nvs->psensor_status) + 1;
}
static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
{
unsigned char input_value = 0xff;
unsigned long flags;
//unsigned int code;
spin_lock_irqsave(&bdata->lock, flags);
input_value = mt_get_gpio_in(bdata->button->gpio);
if( bdata->irq != M7X_HALL_IRQ_NUM) {
atomic_set(&bdata->key_pressed, (atomic_read(&bdata->key_pressed) == RELEASED)?PRESSED:RELEASED );
input_report_key(bdata->input, bdata->button->code, atomic_read(&bdata->key_pressed));
input_sync(bdata->input);
} else {
if( atomic_read(&bdata->key_pressed)==CLOSED ) {
//code = 0x15;
input_report_switch(bdata->input, bdata->button->code, RELEASED);
input_sync(bdata->input);
atomic_set(&bdata->key_pressed, REMOVED);
#ifdef KEY_HALL_DEBUG
key_hall_press = REMOVED;
#endif
} else {
//code = 0x15;
input_report_switch(bdata->input, bdata->button->code, PRESSED);
input_sync(bdata->input);
atomic_set(&bdata->key_pressed, CLOSED);
#ifdef KEY_HALL_DEBUG
key_hall_press = CLOSED;
#endif
}
}
spin_unlock_irqrestore(&bdata->lock, flags);
#ifdef MEIZU_TP_NOTIFIER
if(bdata->irq == M7X_HALL_IRQ_NUM)
gpio_key_notify(atomic_read(&bdata->key_pressed),NULL);
#endif
if( atomic_read(&bdata->key_pressed)==PRESSED ) {
schedule_delayed_work(&bdata->delayed_work, msecs_to_jiffies(bdata->timer_debounce));
} else {
/*
* cant use cancel_delayed_work_sync() in the context
*/
cancel_delayed_work(&bdata->delayed_work);
}
#ifdef KEYPAD_DEBUG
printk("[Hall] %s: %s--%s gpio_in:%d\n",
__func__,
bdata->button->desc,
(atomic_read(&bdata->key_pressed) == PRESSED)?"Pressed":"Released",
input_value);
#endif
mt_eint_unmask(bdata->button->irq);
}
static unsigned int lcm_compare_id(void)
{
unsigned int id = 0,ID_PIN =2;
send_ctrl_cmd(0xB9); // SET password
send_data_cmd(0xFF);
send_data_cmd(0x83);
send_data_cmd(0x69);
send_ctrl_cmd(0xC3);
send_data_cmd(0xFF);
send_ctrl_cmd(0xF4);
read_data_cmd();
id = read_data_cmd();
#if defined(BUILD_LK)
printf("xxxxx MYCAT hx8369_p908 READ ID = 0x%x\n", id);
#else
printk("xxxxx MYCAT hx8369_p908 READ ID = 0x%x\n", id);
#endif
mt_set_gpio_mode(GPIO_LCD_ID_PIN,0);
mt_set_gpio_dir(GPIO_LCD_ID_PIN,0);
mt_set_gpio_pull_enable(GPIO_LCD_ID_PIN,1);
mt_set_gpio_pull_select(GPIO_LCD_ID_PIN,1);
MDELAY(1);
ID_PIN=mt_get_gpio_in(GPIO_LCD_ID_PIN);
#if defined(BUILD_LK)
printf("xxxxx MYCAT ID_PIN = 0x%x\n", ID_PIN);
#else
printk("xxxxx MYCAT ID_PIN = 0x%x\n", ID_PIN);
#endif
// return ((LCM_ID == id)&&(ID_PIN==0))?1:0;
return (LCM_ID == id)?1:0;
}
static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
{
unsigned char pressed = RELEASED, state_prev = RELEASED, input_value = 0xff;
unsigned long flags;
spin_lock_irqsave(&bdata->lock, flags);
input_value = mt_get_gpio_in(bdata->button->gpio);
pressed = (input_value ? 1 : 0) ^ bdata->button->active_low;
state_prev = atomic_read(&bdata->key_pressed);
#ifdef KEYPAD_DEBUG
if(pressed == state_prev) {
printk("[Hall] %s: error, %s prev:%s gpio_in_now:%d\n",
__func__,
bdata->button->desc,
(state_prev == PRESSED)?"Pressed":"Released",
input_value);
}
#endif
atomic_set(&bdata->key_pressed, (pressed == PRESSED) ? PRESSED : RELEASED);
input_report_key(bdata->input, bdata->button->code, pressed);
input_sync(bdata->input);
spin_unlock_irqrestore(&bdata->lock, flags);
mt_eint_unmask(bdata->button->irq);
}
int swtp_mod_eint_init(void)
{
int init_value = 0;
unsigned int init_flag = CUST_EINTF_TRIGGER_HIGH;
mt_set_gpio_mode(SWTP_GPIO_EINT_PIN, SWTP_GPIO_EINT_MODE);
mt_set_gpio_dir(SWTP_GPIO_EINT_PIN, SWTP_GPIO_EINT_DIR);
mt_set_gpio_pull_enable(SWTP_GPIO_EINT_PIN, SWTP_GPIO_EINT_PULL);
init_value = mt_get_gpio_in(SWTP_GPIO_EINT_PIN);
if(init_value == SWTP_TRIGGERING) {
init_flag = SWTP_OPPOSE_EINT_TYPE; //CUST_EINTF_TRIGGER_LOW;
swtp_eint_state = EINT_PIN_PLUG_IN;
}
else {
init_flag = SWTP_EINT_TYPE; //CUST_EINTF_TRIGGER_HIGH;
swtp_eint_state = EINT_PIN_PLUG_OUT;
}
mt_eint_set_sens(SWTP_EINT_NUM, SWTP_SENSITIVE_TYPE);
mt_eint_set_hw_debounce(SWTP_EINT_NUM, SWTP_DEBOUNCE_CN);
mt_eint_registration(SWTP_EINT_NUM, init_flag, swtp_eint_handler, 0);
return 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 int get_lcd_id(void)
{
mt_set_gpio_mode(GPIO_LCD_ID_PIN,0);
mt_set_gpio_dir(GPIO_LCD_ID_PIN,0);
mt_set_gpio_pull_enable(GPIO_LCD_ID_PIN,1);
mt_set_gpio_pull_select(GPIO_LCD_ID_PIN,1);
MDELAY(1);
#if defined(BUILD_LK)
printf("wqcat %s, get_lcd_id=%d\n", __func__, mt_get_gpio_in(GPIO_LCD_ID_PIN));
#endif
#ifndef BUILD_LK
printk("wqcat %s, get_lcd_id=%d\n", __func__, mt_get_gpio_in(GPIO_LCD_ID_PIN));
#endif
return mt_get_gpio_in(GPIO_LCD_ID_PIN);
}
uint8_t GET_SDA(void)
{
unsigned int a;
//mt_set_gpio_dir(GPIO_SDA, GPIO_DIR_IN);
a=mt_get_gpio_in(GPIO_SDA);
return a;
}
static ssize_t gps_sku_read_proc(char *page, char **start, off_t off,
int count, int *eof, void *data){
static int init = 0;
int gps_sku = 0;
if(off > 0){
*eof = 1;
return 0;
}
if(!init){
mt_set_gpio_mode(GPIO74, GPIO_MODE_00);
mt_set_gpio_dir(GPIO74, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO74, GPIO_PULL_DISABLE);
msleep(100);
init = 1;
}
gps_sku = mt_get_gpio_in(GPIO74);
if(gps_sku)
sprintf(nvs->gps_sku, "%s", "520T+MT3332");
else
sprintf(nvs->gps_sku, "%s", "NH520");
nvs_write();
return sprintf(page, "%s\n", nvs->gps_sku) + 1;
}
static unsigned int lcm_compare_id(void)
{
int array[4];
char buffer[5];
char id_high=0;
char id_low=0;
int id=0;
int i;
int uiHighCnt=0, uiLowCnt=0;
mt_set_gpio_mode(GPIO21, GPIO_MODE_GPIO);
mt_set_gpio_dir(GPIO21, GPIO_DIR_IN);
for (i = 0; i < 6; i++)
{
if (mt_get_gpio_in(GPIO21)) //LCM ID Pin:119
{
uiHighCnt++;
}
else
{
uiLowCnt++;
}
}
if (uiHighCnt > uiLowCnt)//IPSÆÁ
{
return 1;
}
else//TNÆÁ
{
return 0;
}
}
static unsigned int lcm_compare_id(void)
{
int i;
#if defined(BUILD_LK)
upmu_set_rg_vgp2_vosel(5);
upmu_set_rg_vgp2_en(1);
upmu_set_rg_vgp3_vosel(3);
upmu_set_rg_vgp3_en(1);
#else
hwPowerOn(MT6323_POWER_LDO_VGP2, VOL_2800, "Lance_LCM");
hwPowerOn(MT6323_POWER_LDO_VGP3, VOL_1800, "Lance_LCM");
#endif
MDELAY(100);
mt_set_gpio_mode(GPIO_LCD_PIN_ID, GPIO_MODE_00);
mt_set_gpio_dir(GPIO_LCD_PIN_ID, GPIO_DIR_IN);
//mt_set_gpio_pull_enable(GPIO_LCD_PIN_ID, 1);
//mt_set_gpio_pull_select(GPIO_LCD_PIN_ID, GPIO_PULL_UP);
i=mt_get_gpio_in(GPIO_LCD_PIN_ID);
#ifdef BUILD_LK
printf("MYCAT NT35512 lk lcm_compare_id=%d\n",i);
#else
printk("MYCAT NT35512 kernel lcm_compare_id=%d\n",i);
#endif
if(i == 1)
return 1;
else
return 1;
}
static unsigned char LCDSPI_Read(char cmd)
{
char MB;
unsigned int i,j;
SET_LSCE_LOW;
UDELAY(10);
SET_LSCK_LOW;
SET_LSDA_LOW;
UDELAY(10);
SET_LSCK_HIGH;
UDELAY(100);
for (i = 0; i < 8; i++ )
{
SET_LSCK_LOW;
if (cmd & 0x80)
{
SET_LSDA_HIGH;
}
else
{
SET_LSDA_LOW;
}
UDELAY(100);
SET_LSCK_HIGH;
UDELAY(100);
cmd <<= 1;
}
UDELAY(20);
for(j=0;j<2;j++)
{
MB = 0x00;
for(i=0;i<8;i++)
{
SET_LSCK_LOW;
UDELAY(100);
SET_LSCK_HIGH;
if (1 == (mt_get_gpio_in(LSDI_GPIO_PIN))&0x1)
MB |= 1 << (7 - i);
UDELAY(100);
}
}
SET_LSCE_HIGH;
SET_LSCK_HIGH;
SET_LSDA_HIGH;
return MB;
}
static unsigned int lcm_compare_id(void)
{
unsigned int data_array[16];
unsigned int id=0;
unsigned char buff[3];
unsigned char id_04;
SET_RESET_PIN(1);
MDELAY(1);
SET_RESET_PIN(0);
MDELAY(10);
SET_RESET_PIN(1);
MDELAY(50);
data_array[0]=0x00043902;
data_array[1]=0x9483FFB9;
dsi_set_cmdq(&data_array,2,1);
MDELAY(10);
data_array[0]=0x13BA1502;
dsi_set_cmdq(&data_array,1,1);
MDELAY(10);
data_array[0] = 0x00033700;
dsi_set_cmdq(&data_array, 1, 1);
MDELAY(10);
read_reg_v2(0x04,buff, 3);
id_04 = buff[0];
mt_set_gpio_mode(142,0); // gpio mode high
mt_set_gpio_pull_enable(142,0);
mt_set_gpio_dir(142,0); //input
id = mt_get_gpio_in(142);//should be 0
#if defined(BUILD_LK)
printf(" BUILD_LK m_compare_id id_04 = %x,buff = %x,%x.%x-----------------\n", id_04,buff[0],buff[1],buff[2]);
printf("BUILD_LK cm_compare_id id = %x-----------------\n", id);
#elif defined(BUILD_UBOOT)
printf(" BUILD_UBOOT m_compare_id id_04 = %x,buff = %x,%x.%x-----------------\n", id_04,buff[0],buff[1],buff[2]);
printf("BUILD_UBOOT cm_compare_id id = %x-----------------\n", id);
#else
printk(" lcm_compare_id id_04 = %x,buff = %x,%x.%x-----------------\n", id_04,buff[0],buff[1],buff[2]);
printk("lcm_compare_id id = %x-----------------\n", id);
#endif
if((id_04 & 0xff) == 0x1C)
{
return 0;
}
else if(id == LCM_ID)
{
return 1;
}
else
{
return 0;
}
}
static unsigned int lcm_compare_id(void)
{
#if 0
unsigned int id=0;
unsigned char buffer[2];
unsigned int array[16];
SET_RESET_PIN(1);
SET_RESET_PIN(0);
MDELAY(1);
SET_RESET_PIN(1);
MDELAY(10);//Must over 6 ms
array[0]=0x00043902;
array[1]=0x9483FFB9;// page enable
dsi_set_cmdq(&array, 2, 1);
MDELAY(10);
array[0] = 0x00023700;// return byte number
dsi_set_cmdq(&array, 1, 1);
MDELAY(10);
read_reg_v2(0xF4, buffer, 2);
id = buffer[0];
#ifdef BUILD_LK
printf("HX8394D_dsi_truly %s, id = 0x%08x\n", __func__, id);
#else
printk("HX8394D_dsi_truly %s, id = 0x%08x\n", __func__, id);
#endif
return (LCM_ID_HX8394D == id)?1:0;
#else
unsigned int ret = 0;
ret = mt_get_gpio_in(GPIO17);
#if defined(BUILD_LK)
printf("%s, [jx]hx8394a GPIO17 = %d \n", __func__, ret);
printf("------------------lcm_compare_id\n");
#endif
if(ret == 1)
{
mt_set_gpio_out(GPIO126,1);
}
else{
mt_set_gpio_out(GPIO126,0);
}
//mt_set_gpio_mode(GPIO126, GPIO_MODE_00);
//mt_set_gpio_dir(GPIO126, GPIO_DIR_OUT);
//mt_set_gpio_out(GPIO126,1);
//return (ret == 1)?1:0;
return 0;
#endif
}
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);
}
}
int _wmt_detect_read_gpio_input (unsigned int id)
{
int retval = 0;
_wmt_detect_set_input_mode(id);
retval = mt_get_gpio_in(id);
WMT_DETECT_DBG_FUNC("WMT-DETECT: set GPIO%d to output 0 \n", id);
return retval;
}
int cm_get_assertlog_status(void)
{
int val;
mt_set_gpio_dir(GPIO_EXT_MD_DUMP, 0);
val = mt_get_gpio_in(GPIO_EXT_MD_DUMP);
EMD_MSG_INF("chr","cm_get_assertlog_status:GPIO_EXT_MD_EXP(in)=%d!\n",val);
return val;
}
static ssize_t ps_irq_gpio_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int gpio;
gpio = mt_get_gpio_in(GPIO_IR_EINT_PIN);
return sprintf(buf, "%d\n", gpio);
}
