コード例 #1
0
/* Function to manage power-on resume */
void tpd_resume(struct early_suspend *h) 
{

    tpd_hw_enable();

mdelay(200);
#if 0

	uint8_t bfffer[2] = {0x01,0x02};

	//if(tpd_debuglog==1) {
		//TPD_DMESG("[mtk-tpd] %s\n", __FUNCTION__); 
	//}
	
#ifdef TPD_HAVE_POWER_ON_OFF
	mt_set_gpio_mode(181, 1);
	mt_set_gpio_mode(182, 1);
	/*mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);*/

    tpd_hw_enable();
    
	tpd_i2c_master_send(i2c_client,bfffer,2);
	msleep(10);
#endif
	tpd_i2c_master_rs_send(i2c_client,bfffer,1<<8|1);
	bfffer[1] &= ~0x0E;
	bfffer[1] |= 0x02;
	tpd_i2c_master_send(i2c_client,bfffer,2);
	msleep(5);
#endif
	mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM); 
    tpd_halt = 0;
}
コード例 #2
0
ファイル: accfix.c プロジェクト: Demeterp/w732_accfix
static inline int accfix_setup_eint(void)
{
	
	/*configure to GPIO function, external interrupt*/
    ACCFIX_DEBUG("[accfix]accfix_setup_eint\n");
	
	mt_set_gpio_mode(GPIO_ACCDET_EINT_PIN, GPIO_ACCDET_EINT_PIN_M_EINT);
    mt_set_gpio_dir(GPIO_ACCDET_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_ACCDET_EINT_PIN, GPIO_PULL_ENABLE);
	#ifdef ACCFIX_EINT_HIGH_ACTIVE
	mt_set_gpio_pull_select(GPIO_ACCDET_EINT_PIN, GPIO_PULL_DOWN);
	#else
	mt_set_gpio_pull_select(GPIO_ACCDET_EINT_PIN, GPIO_PULL_UP);
	#endif
	
	
	/**
    mt65xx_eint_set_sens(CUST_EINT_ACCDET_NUM, CUST_EINT_ACCDET_SENSITIVE);
	#ifdef ACCFIX_EINT_HIGH_ACTIVE
	mt65xx_eint_set_polarity(CUST_EINT_ACCDET_NUM, 1);
	ACCFIX_DEBUG("[accfix]accfix_setup_eint active high \n");
	#else
	mt65xx_eint_set_polarity(CUST_EINT_ACCDET_NUM, 0);
	ACCFIX_DEBUG("[accfix]accfix_setup_eint active low\n");
	#endif
	**/
	mt65xx_eint_set_hw_debounce(CUST_EINT_ACCDET_NUM, CUST_EINT_ACCDET_DEBOUNCE_CN);
	mt65xx_eint_registration(CUST_EINT_ACCDET_NUM, CUST_EINT_ACCDET_DEBOUNCE_EN, CUST_EINT_ACCDET_POLARITY, accfix_eint_func, 0);
	mt65xx_eint_unmask(CUST_EINT_ACCDET_NUM);  

	
    return 0;
	
}
コード例 #3
0
void tpd_resume(struct early_suspend *h) 
{
	TPD_DEBUG("TP tpd_resume\n");
	if (ft5316_i2c_client == NULL)
		return;

	//    if (atomic_read( &g_pts->isp_opened ))
	//	return;

	TPD_DEBUG("[mtk-tpd] Resume++.\n");
	tinno_tp_power_on();
	int err = 0;
    	int i=0;
	for(i=0;i<5;i++){
	   err = tinno_check_focaltech();
	   if(err)
	        break;
	    tinno_tp_power_off();
	    tinno_tp_power_on();
	}
	if (err ==0)
	    TPD_DEBUG("tinno_init_panel ****************************************************power on failed.\n");

	tpd_init_skip = 1;
	tpd_status = 1;
	//Ivan 6573    MT6516_IRQUnmask(MT6516_TOUCH_IRQ_LINE); 
	mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);  
	TPD_DEBUG("[mtk-tpd] Resume--.\n");  
}
コード例 #4
0
static void tpd_resume(struct early_suspend *h)
{
	if ( g_pts ){
		CTP_DBG("TPD wake up\n");
		if (atomic_read(&g_pts->isp_opened)){
			CTP_DBG("isp is already opened.");
			return;
		}

#ifdef CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
		fts_5x06_hw_init();
#else //!CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
		mt_set_gpio_mode(GPIO_CTP_WAKE_PIN, GPIO_CTP_WAKE_PIN_M_GPIO);
		mt_set_gpio_dir(GPIO_CTP_WAKE_PIN, GPIO_DIR_OUT);
		mt_set_gpio_out(GPIO_CTP_WAKE_PIN, GPIO_OUT_ZERO);
		msleep(1);  
		mt_set_gpio_mode(GPIO_CTP_WAKE_PIN, GPIO_CTP_WAKE_PIN_M_GPIO);
		mt_set_gpio_dir(GPIO_CTP_WAKE_PIN, GPIO_DIR_OUT);
		mt_set_gpio_out(GPIO_CTP_WAKE_PIN, GPIO_OUT_ONE);
#endif//CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
		mutex_unlock(&g_pts->mutex);//Lock on suspend
		mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);  

		atomic_set( &g_pts->ts_sleepState, 0 );
        
        //LINE<JIRA_ID><DATE20130320><add charger flag>zenghaihui
        g_need_refresh_tp_flag = 1;
        
	}
 }
コード例 #5
0
int hdmi_drv_power_on(void)
{
    int ret = 0;
	HDMI_FUNC();
	mt65xx_eint_mask(CUST_EINT_MHL_NUM);

#if 1
	SiiMhlTxHwGpioResume();
	//pmic_config_interface(0x87,0x1,0x01,0x0);
/* Vanzo:lubaoquan on: Tue, 21 May 2013 22:35:29 +0800
 * TODO: replace this line with your comment
 */
	hwPowerOn(MT65XX_POWER_LDO_VGP5, VOL_1200, "HDMI");
// End of Vanzo: lubaoquan
#endif

	//msleep(100);
    SiiMhlTxHwReset(5,5);

	//xuecheng
	HalInstallCheckDeviceCB(SiiCheckDevice);
    HalAcquireIsrLock();
    siHdmiTx_VideoSel(HDMI_720P60);
    siHdmiTx_AudioSel(I2S_44);
    ret = SiiMhlTxInitialize(EVENT_POLL_INTERVAL_MS);
    HalReleaseIsrLock();
	mt65xx_eint_unmask(CUST_EINT_MHL_NUM);
    return ret;
}
コード例 #6
0
/* When I2C readings are failing too much, we delay the next reading by masking the IRQ */
static void
open_nfc_enable_irq(unsigned long arg) {
	ENTER();
	
//	enable_irq(arg);
  mt65xx_eint_unmask(CUST_EINT_NFC_NUM);
	
}
コード例 #7
0
ファイル: accfix.c プロジェクト: Demeterp/w732_accfix
void inline disable_accfix(void)
{
   // disable ACCDET unit
   ACCFIX_DEBUG("accfix: disable_accfix\n");
   pre_state_swctrl = INREG32(ACCDET_STATE_SWCTRL);
   OUTREG32(ACCDET_CTRL, ACCDET_DISABLE);
   OUTREG32(ACCDET_STATE_SWCTRL, 0);
   //unmask EINT
   mt65xx_eint_unmask(CUST_EINT_ACCDET_NUM);  
}
コード例 #8
0
static int touch_event_handler(void *unused) {
    struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
    struct touch_info cinfo, sinfo;
    int pending = 0;
    struct i2c_client * i2c_client  =  ft5316_i2c_client ;
    TPD_DEBUG("touch_event_handler\n");
	
    cinfo.pending=0;
    sched_setscheduler(current, SCHED_RR, &param);
    do {
//Ivan added for testing
		if (tpd_status == 1){
		    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM); // possibly to lose event?
         	 }
	        set_current_state(TASK_INTERRUPTIBLE);
	        if (!kthread_should_stop()) 
		{
	        //    TPD_DEBUG_CHECK_NO_RESPONSE;
	            do {
	                if(pending) wait_event_interruptible_timeout(waiter, tpd_flag!=0, HZ/10);
	                else wait_event_interruptible_timeout(waiter,tpd_flag!=0, HZ*2);
	            } while(0);
	            if(tpd_flag==0 && !pending) continue; // if timeout for no touch, then re-wait.
	            if(tpd_flag!=0 && pending>0)  pending=0;
	            tpd_flag=0;
	            TPD_DEBUG_SET_TIME;
	        }
	        set_current_state(TASK_RUNNING);
	        
	        if(!pending) if(tpd_gettouchinfo(&cinfo, &sinfo)) continue; 
	        if(pending>1) { pending--; continue; }
		//Ivan ++
		if (tpd_init_skip) {tpd_init_skip = 0; continue; }
		TPD_DEBUG("cinfo->count == %d!\n", cinfo.count);
		if(cinfo.count > 0)
		{
			int i;
			for ( i=0; i < cinfo.count; i++ )
			{
				TPD_DEBUG("cinfo->count == %d!\n", cinfo.count);
				TPD_DEBUG("Point ID == %d, x == %d , y == %d ,z ==%d\n!",cinfo.pt[i].id,cinfo.pt[i].x,cinfo.pt[i].y,cinfo.pt[i].z );
				tpd_down(cinfo.pt[i].x, cinfo.pt[i].y, cinfo.pt[i].id);
			}
			input_sync(tpd->dev);
		}
		else
		{
			TPD_DEBUG("TPD up x == %d , y == %d\n!",x_history[cinfo.count], y_history[cinfo.count]);
			tpd_up(x_history[cinfo.count], y_history[cinfo.count], 0);		
			input_sync(tpd->dev);
		}    
    } while (!kthread_should_stop());
    return 0;
}
コード例 #9
0
 static int touch_event_handler(void *para)
 {
 	int i;
	tinno_ts_point touch_point[TINNO_TOUCH_TRACK_IDS];
	struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
	tinno_ts_data *ts = (tinno_ts_data *)para;
	sched_setscheduler(current, SCHED_RR, &param);
	
	do {
		set_current_state(TASK_INTERRUPTIBLE); 
		wait_event_interruptible(waiter, tpd_flag!=0);
		tpd_flag = 0;
		memset(touch_point, FTS_INVALID_DATA, sizeof(touch_point));
		set_current_state(TASK_RUNNING);

            
            //LINE<JIRA_ID><DATE20130320><BUG_INFO>zenghaihui
            if(g_tp_charger_flag != g_pre_tp_charger_flag)
            {
                g_pre_tp_charger_flag = g_tp_charger_flag;
                g_need_refresh_tp_flag = 1;
            }

            if(g_need_refresh_tp_flag)
            {
                g_need_refresh_tp_flag = 0;
                fts_ft5316_switch_charger_status(g_tp_charger_flag);
            }
        
        
		if (!tpd_touchinfo(ts, &touch_point)) {

			if(ts->pcount > 0)
			{
				for ( i=0; i < ts->pcount; i++ )
				{
					tpd_down(ts, touch_point[i].x, touch_point[i].y, touch_point[i].pressure, touch_point[i].touch_id);//<20120714><for multi-touch id>wangyanhui
				}
				input_sync(tpd->dev);
			}
			else
			{
				tpd_up(ts, touch_point[0].x, touch_point[0].y, touch_point[0].pressure, touch_point[0].touch_id);
				input_sync(tpd->dev);
			}
            
            
		}
		
		mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM); 
	}while(!kthread_should_stop());
	mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM); 
	return 0;
 }
コード例 #10
0
ファイル: oem.c プロジェクト: benoitm974/cink-peax
void oem_gpio_irq_unmask(int gpio)
{
    int irq;

    irq = oem_gpio_to_irq(gpio);
    if(irq < 0){
        return ;
    }

    mt65xx_eint_unmask(irq);
}
コード例 #11
0
ファイル: pixcir168_driver.c プロジェクト: wufuyue/TCL_S820
static int tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {             
    int err = 0;// ret = -1;
    
    #ifdef TPD_NO_GPIO
    u16 temp;
    temp = *(volatile u16 *) TPD_RESET_PIN_ADDR;
    temp = temp | 0x40;
    *(volatile u16 *) TPD_RESET_PIN_ADDR = temp;
    #endif
    i2c_client = client;
    
    printk("MediaTek touch panel i2c probe\n");
    
    #ifndef TPD_NO_GPIO 

    mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
    mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);  
    msleep(10);  
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
   
    mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
    mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
    mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
    #endif 

    msleep(50);

    I2CDMABuf_va = (u8 *)dma_alloc_coherent(NULL, 4096, &I2CDMABuf_pa, GFP_KERNEL);
    if(!I2CDMABuf_va)
    {
        printk("Allocate Touch DMA I2C Buffer failed!\n");
        return -1;
    }
	
    thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
    if (IS_ERR(thread)) { 
        err = PTR_ERR(thread);
        TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", err);
    }
    
    tpd_load_status = 1;
    
    mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
    mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
    mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);
    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
    
    printk("MediaTek touch panel i2c probe success\n");
    
    return 0;
}
コード例 #12
0
ファイル: hall.c プロジェクト: georgewhite5/dhow
static void hall_init_hw(void)
{
	mt_set_gpio_mode(GPIO_MHALL_EINT_PIN, GPIO_MHALL_EINT_PIN_M_EINT);
	mt_set_gpio_dir(GPIO_MHALL_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_MHALL_EINT_PIN, GPIO_PULL_DISABLE); 
	mt_set_gpio_ies(GPIO_MHALL_EINT_PIN, GPIO_IES_ENABLE);

    	mt65xx_eint_set_sens(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_SENSITIVE);
	mt65xx_eint_set_polarity(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_POLARITY);
	mt65xx_eint_set_hw_debounce(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_DEBOUNCE_CN);
	mt65xx_eint_registration(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_DEBOUNCE_EN, CUST_EINT_MHALL_POLARITY, hall_cover_eint_handler, 0);
	mt65xx_eint_unmask(CUST_EINT_MHALL_NUM);  

}
コード例 #13
0
ファイル: pixcir168_driver.c プロジェクト: wufuyue/TCL_S820
//void tpd_resume(struct i2c_client *client)
static void tpd_resume( struct early_suspend *h )
{   
    int ret = 0;
    unsigned char Wrbuf[2] = {0x14, 0x00};
    
    i2c_client->addr = ( i2c_client->addr & I2C_MASK_FLAG ) | I2C_ENEXT_FLAG;
    ret = i2c_master_send(i2c_client, Wrbuf, 2);
    if(ret != sizeof(Wrbuf))
    {
        TPD_DEBUG("[mtk-tpd] i2c write communcate error during resume: 0x%x\n", ret);
    }
    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM); 
    tpd_halt = 0;
}
コード例 #14
0
static ssize_t pn544_dev_write(struct file *filp, const char __user *buf, size_t count, loff_t *offset)
{
	struct pn544_dev *pn544_dev;
	int ret, i;
	char tmp[MAX_BUFFER_SIZE];

	pn544_dev = filp->private_data;

	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;

	if (copy_from_user(tmp, buf, count)) {
		pr_err("pn544 %s : failed to copy from user space\n", __func__);
		return -EFAULT;
	}

	printk("pn544 copy from user:"******" %02X", tmp[i]);
	}
	printk("\n");
    
	if (pn544_dev->irq_enabled) {
        	mt65xx_eint_mask(EINT_NUM);
		pn544_dev->irq_enabled = false;
        	printk("pn544 write mask eint\n");
	}

	printk("pn544 %s : writing %zu bytes.\n", __func__, count);
	/* Write data */
	ret = i2c_master_send(pn544_dev->client, tmp, count);
	if (ret != count) {
		pr_err("pn544 %s : i2c_master_send returned %d\n", __func__, ret);
		ret = -EIO;
	}
	printk("pn544 PC->IFD:");
	for(i = 0; i < count; i++) {
		printk(" %02X", tmp[i]);
	}
	printk("\n");
	
	if (!pn544_dev->irq_enabled) {
        	mt65xx_eint_unmask(EINT_NUM);
		pn544_dev->irq_enabled = true;
        	printk("pn544 write unmask eint\n");
	}

	return ret;
}
コード例 #15
0
void mt8193_nlh_impl(void)
{
    u32 u4Data;
    u8 bData, bData1;
	u8 bMask;
	
    //read register and then assert which interrupt occured
    mt8193_i2c_read(0x1508, &u4Data);
	mt8193_i2c_write(0x1504, 0xffffffff);
	
    MT8193_DRV_LOG("0x1508 = 0x%08x\n",  u4Data);
	
	if(u4Data&0x20)
    {
      MT8193_CEC_LOG("cec interrupt\n");
      
      if(mt8193_cec_on==1)
      {
        if(mt8193_cec_isrprocess(mt8193_rxcecmode))
       	{
		   vNotifyAppHdmiState(HDMI_PLUG_IN_CEC);
	    }
      }
    }
	
	if(u4Data&0x4)
	{
	 bCheckHDCPStatus(0xfb);
	 bData=bReadGRLInt();
	
	 if(bData&INT_HDCP)
	 {
  	  MT8193_HDCP_LOG("hdcp interrupt\n");
  	  bClearGRLInt(INT_HDCP);
  	

	 }
	 else if(bData&INT_MDI)
	 {
 	   MT8193_PLUG_LOG("hdmi interrupt\n");
	   bClearGRLInt(INT_MDI);
	   bMask = bReadHdmiIntMask();
	   //vWriteHdmiIntMask((0xfd));//INT mask MDI
	 }
    }
	mt65xx_eint_unmask(CUST_EINT_EINT_HDMI_HPD_NUM);
}
コード例 #16
0
/*
 * register irq handler
 * parmaters pass by inno_core
 * @handler		-	if101 irq handler function pointer
 * @irq_type	-	if101 irq type (falling edge detect or rising)
 */
int inno_irq_setup(void (*interrupthandler)(void ))
{
	mt_set_gpio_mode(GPIO_CMMB_EINT_PIN, GPIO_CMMB_EINT_PIN_M_EINT);                 //set to eint MODE for enable eint function
	mt_set_gpio_dir(GPIO_CMMB_EINT_PIN, GPIO_DIR_IN); 
#if 1
	mt_set_gpio_pull_enable(GPIO_CMMB_EINT_PIN, 1);
	mt_set_gpio_pull_select(GPIO_CMMB_EINT_PIN,  1);
#endif
	inno_msg("CMMB GPIO EINT PIN mode:num:%d, %d, dir:%d,pullen:%d,pullup%d",GPIO_CMMB_EINT_PIN,mt_get_gpio_mode(GPIO_CMMB_EINT_PIN),
			mt_get_gpio_dir(GPIO_CMMB_EINT_PIN),mt_get_gpio_pull_enable(GPIO_CMMB_EINT_PIN),mt_get_gpio_pull_select(GPIO_CMMB_EINT_PIN));    

	mt65xx_eint_set_sens(CUST_EINT_CMMB_NUM, CUST_EINT_EDGE_SENSITIVE);
	mt65xx_eint_registration(CUST_EINT_CMMB_NUM, CUST_EINT_DEBOUNCE_DISABLE, CUST_EINT_POLARITY_LOW, interrupthandler, 0);         // 0:auto mask is no
	mt65xx_eint_unmask(CUST_EINT_CMMB_NUM);   
	//    mt65xx_eint_mask(CUST_EINT_CMMB_NUM);   
	return 0;
}
コード例 #17
0
static int mt8193_init(void)
{        
    MT8193_DRV_FUNC();
    memset((void*)&r_hdmi_timer, 0, sizeof(r_hdmi_timer));
    r_hdmi_timer.expires  = jiffies + 1000/(1000/HZ);   // wait 1s to stable
    r_hdmi_timer.function = hdmi_poll_isr;     
    r_hdmi_timer.data     = 0;
    init_timer(&r_hdmi_timer);
    add_timer(&r_hdmi_timer);

	memset((void*)&r_cec_timer, 0, sizeof(r_cec_timer));
    r_cec_timer.expires  = jiffies + 1000/(1000/HZ);   // wait 1s to stable
    r_cec_timer.function = cec_poll_isr;     
    r_cec_timer.data     = 0;
    init_timer(&r_cec_timer);
    add_timer(&r_cec_timer);
	
    init_waitqueue_head(&hdmi_timer_wq);
    hdmi_timer_task = kthread_create(hdmi_timer_kthread, NULL, "hdmi_timer_kthread"); 
    wake_up_process(hdmi_timer_task);

    init_waitqueue_head(&cec_timer_wq);
    cec_timer_task = kthread_create(cec_timer_kthread, NULL, "cec_timer_kthread"); 
    wake_up_process(cec_timer_task);

    init_waitqueue_head(&mt8193_nlh_wq);
    mt8193_nlh_task = kthread_create(mt8193_nlh_kthread, NULL, "mt8193_nlh_kthread"); 
    wake_up_process(mt8193_nlh_task);

    #if defined(CONFIG_HAS_EARLYSUSPEND)
    register_early_suspend(&mt8193_hdmi_early_suspend_desc);
    #endif

	mt_set_gpio_mode(GPIO_HDMI_EINT_PIN, GPIO_MODE_01);
    mt_set_gpio_dir(GPIO_HDMI_EINT_PIN, GPIO_DIR_IN);
    mt_set_gpio_pull_enable(GPIO_HDMI_EINT_PIN, true);
    mt_set_gpio_pull_select(GPIO_HDMI_EINT_PIN,  GPIO_PULL_UP);

    mt65xx_eint_set_sens(CUST_EINT_EINT_HDMI_HPD_NUM, CUST_EINT_EDGE_SENSITIVE);
    mt65xx_eint_registration(CUST_EINT_EINT_HDMI_HPD_NUM, 0, CUST_EINT_POLARITY_LOW, &_mt8193_irq_handler, 0);

    mt65xx_eint_unmask(CUST_EINT_EINT_HDMI_HPD_NUM);  
	
    return 0;
}
コード例 #18
0
void hdmi_drv_power_on(void)
{
	HDMI_FUNC();
	mt65xx_eint_mask(CUST_EINT_HDMI_HPD_NUM);
	SiiMhlTxHwGpioResume();
	pmic_config_interface(0x87,0x1,0x01,0x0);
	//msleep(100);
    SiiMhlTxHwReset(50,200);

	//xuecheng
	HalInstallCheckDeviceCB(SiiCheckDevice);
    HalAcquireIsrLock();
    siHdmiTx_VideoSel(HDMI_720P60);
    siHdmiTx_AudioSel(I2S_44);
    SiiMhlTxInitialize(EVENT_POLL_INTERVAL_MS);
    HalReleaseIsrLock();
	mt65xx_eint_unmask(CUST_EINT_HDMI_HPD_NUM);
}
コード例 #19
0
static int mhl_irq_kthread(void *data)
{
	struct sched_param param = { .sched_priority = RTPM_PRIO_SCRN_UPDATE };
	sched_setscheduler(current, SCHED_RR, &param);
    
    for( ;; ) {
        wait_event_interruptible(mhl_irq_wq, atomic_read(&mhl_irq_event));
		printk("mhl_irq_kthread, mhl irq received\n");
        //hdmi_update_impl();

		atomic_set(&mhl_irq_event, 0);
        SiiMhlTxDeviceIsr();
        if (kthread_should_stop())
            break;
		mt65xx_eint_unmask(CUST_EINT_MHL_NUM);
    }

    return 0;
}
コード例 #20
0
/* Function to manage power-on resume */
void tpd_resume(struct early_suspend *h) 
{
    char buffer[8];
	if(tpd_debuglog==1) {
		TPD_DMESG("[mtk-tpd] %s\n", __FUNCTION__); 
	}
   // msleep(100);
#ifdef TPD_POWER_SOURCE_CUSTOM
   hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
#endif
#ifdef TPD_POWER_SOURCE_1800
   hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
#endif
#ifdef GPIO_CTP_EN_PIN
    mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
    mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
#endif
    msleep(1);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
    msleep(1);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);    
    msleep(100);
    buffer[0] =  0x00;
    buffer[1] =  0x03;
    i2c_master_send(i2c_client,buffer,2);
    msleep(50);
    buffer[0] =  0x00;
    buffer[1] =  0x05;
    i2c_master_send(i2c_client,buffer,2);
    //status = i2c_master_recv(i2c_client, buffer, 3);
    msleep(50);
    buffer[0] =  0x00;
    buffer[1] =  0x21;
    buffer[2] =  0x07;
    buffer[3] =  0x01;
    buffer[4] =  0x00;
    i2c_master_send(i2c_client,buffer,5);
    msleep(50);

    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM); 
    tpd_halt = 0;
}
コード例 #21
0
static void kpd_slide_handler(unsigned long data)
{
	bool slid;
	u8 old_state = kpd_slide_state;

	kpd_slide_state = !kpd_slide_state;
	slid = (kpd_slide_state == !!KPD_SLIDE_POLARITY);
	/* for SW_LID, 1: lid open => slid, 0: lid shut => closed */
	input_report_switch(kpd_input_dev, SW_LID, slid);
	input_sync(kpd_input_dev);
	kpd_print("report QWERTY = %s\n", slid ? "slid" : "closed");

	if (old_state)
		mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 0);
	else
		mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 1);
	/* for detecting the return to old_state */
	mt65xx_eint_set_polarity(KPD_SLIDE_EINT, old_state);
	mt65xx_eint_unmask(KPD_SLIDE_EINT);
}
コード例 #22
0
INT32 wmt_plat_wifi_eint_ctrl(ENUM_PIN_STATE state)
{
#if 0 /*def GPIO_WIFI_EINT_PIN*/
    switch(state)
    {
        case PIN_STA_INIT:
            mt_set_gpio_pull_enable(GPIO_WIFI_EINT_PIN, GPIO_PULL_DISABLE);
            mt_set_gpio_dir(GPIO_WIFI_EINT_PIN, GPIO_DIR_OUT);
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_MODE_GPIO);
            mt_set_gpio_out(GPIO_WIFI_EINT_PIN, GPIO_OUT_ONE);
            break;
        case PIN_STA_MUX:
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_WIFI_EINT_PIN_M_GPIO);
            mt_set_gpio_pull_enable(GPIO_WIFI_EINT_PIN, GPIO_PULL_ENABLE);
            mt_set_gpio_pull_select(GPIO_WIFI_EINT_PIN, GPIO_PULL_UP);
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_WIFI_EINT_PIN_M_EINT);

            break;
        case PIN_STA_EINT_EN:
            mt65xx_eint_unmask(CUST_EINT_WIFI_NUM);
            break;
        case PIN_STA_EINT_DIS:
            mt65xx_eint_mask(CUST_EINT_WIFI_NUM);
            break;
        case PIN_STA_IN_L:
        case PIN_STA_DEINIT:
            /*set to gpio input low, pull down enable*/
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_COMBO_BGF_EINT_PIN_M_GPIO);
            mt_set_gpio_dir(GPIO_WIFI_EINT_PIN, GPIO_DIR_IN);
            mt_set_gpio_pull_select(GPIO_WIFI_EINT_PIN, GPIO_PULL_DOWN);
            mt_set_gpio_pull_enable(GPIO_WIFI_EINT_PIN, GPIO_PULL_ENABLE);
            break;
        default:
            WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on WIFI EINT\n", state);
            break;
    }
#else
    WMT_INFO_FUNC("WMT-PLAT:WIFI EINT is controlled by MSDC driver \n");
#endif
    return 0;
}
コード例 #23
0
ファイル: hall.c プロジェクト: georgewhite5/dhow
static void hall_eint_work_callback(struct work_struct *work)
{
	bool cover;
	u8 old_state = hall_cover_state;
	
	mt65xx_eint_mask(CUST_EINT_MHALL_NUM);
	DOCK_DEBUG("[hall] hall_cover_state = %d\n", hall_cover_state );
        hall_cover_state = !mt_get_gpio_in(GPIO_MHALL_EINT_PIN);
	if ( old_state ==  hall_cover_state )
	{
		DOCK_ERR("[hall] no hall state changed!!!\n");
		//mt65xx_eint_unmask(CUST_EINT_MHALL_NUM);
		//return;
	}
	switch_set_state((struct switch_dev *)&hall_data, hall_cover_state);

	//input_report_switch(kpd_input_dev, SW_LID, hall_cover_state);
	//input_sync(kpd_input_dev);
	mt65xx_eint_set_polarity(CUST_EINT_MHALL_NUM, !old_state);
	mt65xx_eint_unmask(CUST_EINT_MHALL_NUM);
}
コード例 #24
0
long
open_nfc_custom_ioctl_connect(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct open_nfc_custom_device *p_device = filp->private_data;
	int             retval = 0;

	ENTER();
	
	if (!p_device) {
		printk("open_nfc_custom_ioctl_connect: Internal error p_device is missing\n");
		return -ENODEV;
	}

	mutex_lock(&p_device->mutex);

	if (p_device->state != CUSTOM_CONFIGURED) {
		printk("CONNECT called while device was not configured / already connected\n");
		retval = -EALREADY;
		goto end;
	}

	p_device->state = CUSTOM_READY;

	/* start collecting the received messages */
	p_device->rx_listener = 1;

#ifndef WAKE_AND_PURGE_I2C_ON_LOAD
//	enable_irq(p_device->irqout);
  mt65xx_eint_unmask(CUST_EINT_NFC_NUM);
#endif /* WAKE_AND_PURGE_I2C_ON_LOAD */
       
      end:
	mutex_unlock(&p_device->mutex);

	return retval;
}
コード例 #25
0
static ssize_t pn544_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset)
{
	struct pn544_dev *pn544_dev = filp->private_data;
	int ret,i;
	char tmp[MAX_BUFFER_SIZE];

	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;

	printk("pn544 %s : reading %zu bytes.\n", __func__, count);

	mutex_lock(&pn544_dev->read_mutex);

	if (!mt_get_gpio_in(IRQ_PIN)) {
        
		printk("pn544 read no event\n");
		
		if (filp->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			goto fail;
		}
		
		printk("pn544 read wait event\n");
		
		pn544_dev->irq_enabled = true;
		mt65xx_eint_unmask(EINT_NUM);
		ret = wait_event_interruptible(pn544_dev->read_wq, mt_get_gpio_in(IRQ_PIN));

		pn544_disable_irq(pn544_dev);

		if (ret) {
			printk("pn544 read wait event error\n");
			goto fail;
		}
	}

	/* Read data */
	ret = i2c_master_recv(pn544_dev->client, tmp, count);
	mutex_unlock(&pn544_dev->read_mutex);

	if (ret < 0) {
		pr_err("pn544 %s: i2c_master_recv returned %d\n", __func__, ret);
		return ret;
	}
	if (ret > count) {
		pr_err("pn544 %s: received too many bytes from i2c (%d)\n", __func__, ret);
		return -EIO;
	}
	
	if (copy_to_user(buf, tmp, ret)) {
		pr_warning("pn544 %s : failed to copy to user space\n", __func__);
		return -EFAULT;
	}

	printk("pn544 IFD->PC:");
	for(i = 0; i < ret; i++) {
		printk(" %02X", tmp[i]);
	}
	printk("\n");

	return ret;

fail:
	mutex_unlock(&pn544_dev->read_mutex);
	return ret;
}
コード例 #26
0
void cm_enable_ext_md_wakeup_irq(void)
{
	mt65xx_eint_unmask(CUST_EINT_DT_EXT_MD_WK_UP_NUM);
}
コード例 #27
0
static int tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {             
    int err = 0;
    char buffer[2];
    int status=0;
    i2c_client = client;    
    TPD_DMESG("[mtk-tpd], cy8ctma300 tpd_i2c_probe ++++\n");
    #ifdef TPD_NO_GPIO
    u32 temp;
    
    temp = *(volatile u32 *) TPD_GPIO_GPO_ADDR;
    //temp = temp | 0x40;
    temp = temp |(1<<16) ;
    temp = temp |(1<<17);
    //temp = (temp | 1<<16);
    //mt65xx_reg_sync_write(TPD_GPIO_GPO_ADDR, temp);
    //*(volatile u32 *) TPD_GPIO_GPO_ADDR = temp;
    printk("TPD_GPIO_GPO_ADDR:0x%x\n", *(volatile u32 *) TPD_GPIO_GPO_ADDR);
	
    temp = *(volatile u32 *) TPD_GPIO_OE_ADDR;
    //temp = temp | 0x40;
    temp = temp |(1<<16) ;
    temp = temp |(1<<17);
	//temp = (temp | 1<<16) ;
	//mt65xx_reg_sync_write(TPD_GPIO_OE_ADDR, temp);
   // *(volatile u32 *) TPD_GPIO_OE_ADDR = temp;
    printk("TPD_GPIO_OE_ADDR:0x%x\n", *(volatile u32 *) TPD_GPIO_OE_ADDR);
    #endif
    
    #ifndef TPD_NO_GPIO 
    mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
    mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);  
    msleep(10);  
    mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
    mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
    
 //   mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
 //   mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
 //   mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
 //   msleep(10);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
    msleep(1);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
    
    mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
    mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
    mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
    #endif 

    msleep(50);
   // buffer[0]=0x00;
   // i2c_client->ext_flag = I2C_WR_FLAG;
   // status=i2c_master_send(i2c_client ,buffer, 0x101);
   TPD_DMESG("1...........\n");
    status = i2c_smbus_read_i2c_block_data(i2c_client, 0x00, 1, &(buffer[0]));
    if(status<0) 
    {
            TPD_DMESG("fwq read error\n");
		TPD_DMESG("[mtk-tpd], cy8ctma300 tpd_i2c_probe failed!!\n");
		status = i2c_smbus_read_i2c_block_data(i2c_client, 0x00, 1, &(buffer[0]));
		if(status<0) {
			TPD_DMESG("[mtk-tpd], cy8ctma300 tpd_i2c_probe retry failed!!\n");
			return status;
		}
    }
    TPD_DMESG("fwq buffer=%x \n",buffer[0]);

    TPD_DMESG("[mtk-tpd], cy8ctma300 tpd_i2c_probe success!!\n");		
    tpd_load_status = 1;
        
    if ((buffer[0] & 0x70) != 0x00) 
    {
        buffer[0] = 0x00; // switch to operation mode
       	
        i2c_smbus_write_i2c_block_data(i2c_client, 0x00, 1, &(buffer[0]));
        if(status < 0)
	 {
	    TPD_DMESG("fwq write error\n");
	 }
        msleep(50);
    }

    thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
    if (IS_ERR(thread)) { 
        err = PTR_ERR(thread);
        TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", err);
    }    
#ifndef POLL_MODE //mt6575t fpga debug 0: enable polling mode
    mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
    mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
    mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);
    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
    TPD_DMESG("EINT num=%d\n",CUST_EINT_TOUCH_PANEL_NUM);
#endif 
	TPD_DMESG("[mtk-tpd], cy8ctma300 tpd_i2c_probe ----\n");

    return 0;
}
コード例 #28
0
ファイル: board.c プロジェクト: SiddheshK15/s9086b_wet_kk
static void mtk_wcn_cmb_sdio_enable_eirq(void)
{
    mt65xx_eint_unmask(mtk_wcn_cmb_sdio_eint_num);/* CUST_EINT_WIFI_NUM */
}
コード例 #29
0
static int gt927_diffdata_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    int driving_num = 0;
    int sensing_num = 0;
    int i;
    char *ptr = page;
    u8 *buf;
    mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
    driving_num += (config[27 + GTP_ADDR_LENGTH] & 0x1F);
    driving_num += (config[28 + GTP_ADDR_LENGTH] & 0x1F);
    sensing_num += (config[29 + GTP_ADDR_LENGTH] & 0x0F);
    sensing_num += (config[29 + GTP_ADDR_LENGTH] & 0xF0) >> 4;
    GTP_INFO("TPD driving_num %d", driving_num);
    GTP_INFO("TPD sensing_num %d", sensing_num);
    buf = (u8 *)kzalloc(driving_num * sensing_num, GFP_KERNEL);

    //0x8040 write 1 for rawdata/diff access
    buf[0] = 1;
    i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);

    // wait for normal INT finished
    while (tpd_flag == 1)
    {
        msleep(20);
    }

    msleep(100);

    //check for raw data ready
    i2c_read_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);

    while (buf[0] == 0)
    {
        //wait for data ready
        GTP_INFO("Wati for raw data");
        i2c_read_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);
        GTP_INFO("0x814E : %2X", buf[0]);
        buf[0] &=  0x80;
        msleep(5);
    }

    i2c_read_bytes(i2c_client_point, GTP_DIFFDATA_REG, buf, driving_num * sensing_num);

    for (i = 0 ; i < driving_num * sensing_num; i = i + 1)
    {
        ptr += sprintf(ptr, "%d\t", buf[i]);

        if ((i % (sensing_num)) == (sensing_num - 1))
            ptr += sprintf(ptr, "\n");
    }

    //clear data ready status
    buf[0] = 0;
    i2c_write_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);

    //0x8040 write 0 for leaving rawdata/diff access mode
    buf[0] = 0;
    i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);

    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
    kfree(buf);
    *eof = 1;
    return (ptr - page);
}
コード例 #30
0
static int tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) 
{
	int err = 0;
	TPD_DEBUG("ft5316 tpd_i2c_probe\n");
	if (ft5316_i2c_client != NULL)
	return 1;

	ft5316_i2c_client = client;
	TPD_DEBUG("ft5316_i2c_client addr ==== %X \n", ft5316_i2c_client->addr);
	tinno_tp_power_off();
	tinno_tp_power_on();

	int i = 0;
	while(i++ <5){
		err=tinno_ts_get_fw_version();
		TPD_DEBUG("Product  version ==== %X \n", panel_version);
		if(err > 0)
			break;
		else
			continue;
	}
	if ( err < 0 ){
	    TPD_DEBUG("Product  version %X is invalid.\n", panel_version);
	    goto err_detect_failed;
	}

	tpd_load_status = 1;
	
	  

    /* added in android 2.2, for configuring EINT2 */
    mt_set_gpio_mode(TPIO_EINT, GPIO_CTP_EINT_PIN_M_EINT);
    mt_set_gpio_pull_enable(TPIO_EINT, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(TPIO_EINT,GPIO_PULL_UP);
    mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
    mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
    mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);    
    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);

    mutex_init(&tp_mutex);	
#ifdef CONFIG_TOUCHSCREEN_FT5X05_SUPPORT_ISP
	magnum_fts_isp_register(ft5316_i2c_client);

#endif/*CONFIG_TOUCHSCREEN_FT5X05_SUPPORT_ISP*/
    tpd_status = 1;
  thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
	    if (IS_ERR(thread)) { 
	        err = PTR_ERR(thread);
	        TPD_DEBUG(TPD_DEVICE " failed to create kernel thread: %d\n", err);
    }

    //edit by Magnum 2012-12-25
#ifdef  TP_AUTO_UPGRADE
		focaltech_auto_upgrade();
#endif

    TPD_DEBUG("tpd_i2c_probe OK\n");	
   
    return 0;

err_detect_failed:
    TPD_DEBUG("tpd_i2c_probe ERROR\n");
    ft5316_i2c_client = NULL;
    tinno_tp_power_off();
   return 1;
}