コード例 #1
0
static void star_proxi_interrupt_handler(void *arg)
{
	//When VOUT terminal changes from H to L, enter the this function --> procedure 3
	s_proximity.MVO++; //Update the MVO value
	if( (s_proximity.MVO & 1) == 0 )
	{
		printk("Even Number INT, MVO = %d\n", s_proximity.MVO);
		s_proximity.MVO = 0;
	}
	else
	{
		printk("Odd Number INT, MVO = %d\n", s_proximity.MVO);
		s_proximity.MVO = 1;
	}

    NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_TRUE); //Procedure 4
	if(s_proximity.MVO == 1)
		star_proxi_write_reg(&s_proximity, 0x02, 0x00 );
	else
		star_proxi_write_reg(&s_proximity, 0x02, 0x20 );
	

	star_proxi_write_reg(&s_proximity, 0x06, 0x18 );

	#if STAR_PROX_DEBUG
	printk("PROX interrupt!!!\n");
	printk("PROX interrupt!!!\n");
	#endif
    schedule_work(&s_proximity.work);
   	NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_FALSE);
    NvOdmGpioInterruptDone(s_proximity.proxi_out_intr);
}
NvBool Synaptics_OneTouch_PowerOnOff (NvOdmOneTouchDeviceHandle hDevice, NvBool OnOff)
{
// 20101120 [email protected] power off when Onetouch close    
#if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F)
	NvOdmServicesPmuVddRailCapabilities vddrailcap;
	NvU32 settletime;

    Synaptics_OneTouch_Device* hTouch = (Synaptics_OneTouch_Device*)hDevice;

    hTouch->hPmu = NvOdmServicesPmuOpen();

	printk("[ONETOUCH] Synaptics_OneTouch_PowerOnOff\n");
	
    if (!hTouch->hPmu)
    {
		printk("[ONETOUCH] NvOdmServicesPmuOpen Error\n");
		return NV_FALSE;
    }
    
	NvOdmServicesPmuGetCapabilities( hTouch->hPmu, hTouch->VddId, &vddrailcap);

	printk("[ONETOUCH] power on[%d], vol[%d]\n", OnOff, vddrailcap.requestMilliVolts);
		
	if(OnOff)
	{
// 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [START]
#if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F)
		if(hGpioIntr_touch)
			NvOdmGpioInterruptMask(hGpioIntr_touch, NV_TRUE);
#endif
// 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [END]
			
	    NvOdmServicesPmuSetVoltage( hTouch->hPmu, hTouch->I2cVddId, NVODM_VOLTAGE_OFF, &settletime);
        NvOdmOsWaitUS(SYNAPTICS_POR_DELAY_MS*1000); // wait to settle power
		NvOdmServicesPmuSetVoltage( hTouch->hPmu, Max8907PmuSupply_LDO16, NVODM_VOLTAGE_OFF, &settletime);
		NvOdmOsWaitUS(SYNAPTICS_POR_DELAY_MS*2*1000); // wait to settle power

		NvOdmServicesPmuSetVoltage( hTouch->hPmu, Max8907PmuSupply_LDO16, MAX8907_REQUESTVOLTAGE_LDO16, &settletime);
		NvOdmServicesPmuSetVoltage( hTouch->hPmu, hTouch->I2cVddId, MAX8907_REQUESTVOLTAGE_LDO19, &settletime);

// 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [START]
#if defined(CONFIG_MACH_STAR_SKT_REV_E) || defined(CONFIG_MACH_STAR_SKT_REV_F)
		if(hGpioIntr_touch)
			NvOdmGpioInterruptMask(hGpioIntr_touch, NV_FALSE);
#endif
// 20101223 [email protected] [SU660] block touch interrupt when onetouch is on reset [END]
	}else
		NvOdmServicesPmuSetVoltage( hTouch->hPmu, Max8907PmuSupply_LDO16, NVODM_VOLTAGE_OFF, &settletime);

		NvOdmOsWaitUS(SYNAPTICS_POR_DELAY_MS*5*1000); // wait to settle power

    NvOdmServicesPmuClose(hTouch->hPmu);
#endif
    return NV_TRUE;
}
コード例 #3
0
static int proximity_resume(struct platform_device *pdev)
{
    if (!proxi_enabled)
        return 0;

    if (s_proximity.wakeup_while_sleep)
        NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_FALSE);

    if (hrtimer_try_to_cancel(&s_proximity.timer) == 0)
        hrtimer_start(&s_proximity.timer, ktime_set(0, s_proximity.delay), HRTIMER_MODE_REL);

    if (!s_proximity.wakeup_while_sleep)
        NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_TRUE);

    return 0;
}
コード例 #4
0
static void star_proxi_enable(ProximityDevice *data)
{
    if (proxi_enabled == true)
        return;

	
    //star_proxi_power_onoff(data, true);

    star_proxi_i2c_init_write();                 //Initail Operation, Procedure 1, see the 25page GP2AP datasheet

	s_proximity.MVO = 0;


    if (data->use_int_mode)
        NvOdmGpioInterruptMask(data->proxi_out_intr, NV_FALSE);//Interrupt Enable(NV_FALSE) Procedure 2
    else
        hrtimer_start(&data->timer, ktime_set(1, 0), HRTIMER_MODE_REL);

    proxi_enabled = true;

	atomic_set(&proxi_status, 1);

	input_report_abs(s_proximity.input_dev, ABS_DISTANCE, atomic_read(&proxi_status));
	input_sync(s_proximity.input_dev);
}
コード例 #5
0
static NvBool EETI_Resume(NvOdmTouchDeviceHandle hDevice) {
    EETI_TouchDevice* hTouch = (EETI_TouchDevice*)hDevice;

    if (hDevice == NULL) {
        return NV_FALSE;
    }
#if 0
    NvOdmGpioInterruptMask(hTouch->hGpioIntr, NV_TRUE);
    NvOdmGpioInterruptUnregister(hTouch->hGpio, hTouch->hPin, hTouch->hGpioIntr);
#endif
    NvOdmGpioConfig(hTouch->hGpio, hTouch->hPin, NvOdmGpioPinMode_Output);
    /* Send reset pulse to touch HW */
    NvOdmGpioSetState(hTouch->hGpio, hTouch->hPin, 1);
    NvOsWaitUS(50);
    NvOdmGpioSetState(hTouch->hGpio, hTouch->hPin, 0);
    NvOsSleepMS(50);       
    NvOdmGpioSetState(hTouch->hGpio, hTouch->hPin, 1);

    NvOdmGpioConfig(hTouch->hGpio, hTouch->hPin, NvOdmGpioPinMode_InputInterruptLow);
#if 0
    if (NvOdmGpioInterruptRegister(hTouch->hGpio, &hTouch->hGpioIntr,
                                   hTouch->hPin, NvOdmGpioPinMode_InputInterruptLow, EETI_GpioIsr,
                                   (void*)hTouch, EETI_DEBOUNCE_TIME_MS) == NV_FALSE) {
        return NV_FALSE;
    }
#endif
    return NV_TRUE;
}
コード例 #6
0
static void star_proxi_sleep_handler(void *arg)
{
    NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_FALSE);

    input_report_key(s_proximity.input_dev, KEY_POWER, 1);
    input_sync(s_proximity.input_dev);

    input_report_key(s_proximity.input_dev, KEY_POWER, 0);
    input_sync(s_proximity.input_dev);
}
コード例 #7
0
static int h2w_switch_resume(struct platform_device *pdev)
{
	struct h2w_switch_dev *hsdev;
	hsdev = (struct h2w_switch_dev *)platform_get_drvdata(pdev);
	if (hsdev != NULL) {
		queue_work(hsdev->workqueue, &hsdev->work);
		NvOdmGpioInterruptMask(hsdev->hp_det_irq, NV_FALSE);
	}
	return 0;
}
コード例 #8
0
static int h2w_switch_suspend(struct platform_device *pdev, pm_message_t state)
{
	struct h2w_switch_dev *hsdev;
	
	hsdev = (struct h2w_switch_dev *)platform_get_drvdata(pdev);
	if (hsdev != NULL) {
		NvOdmGpioInterruptMask(hsdev->hp_det_irq, NV_TRUE);
		cancel_work_sync(&hsdev->work);
	}
	return 0;
}
void Synaptics_OneTouch_InterruptMask(NvOdmOneTouchDeviceHandle hDevice, NvBool mask)
{
	/*
		If mask is NV_TRUE, then disable irq.
		If mask is NV_FALSE, then enable irq.
	*/
	Synaptics_OneTouch_Device* hTouch = (Synaptics_OneTouch_Device*)hDevice;
	
	if (hTouch->hGpioIntr)
	{
		NvOdmGpioInterruptMask(hTouch->hGpioIntr, mask);
		printk("[ONETOUCH] Synaptics_OneTouch_InterruptMask by %d\n", mask);
	}
}
コード例 #10
0
static int proximity_suspend(struct platform_device *pdev, pm_message_t state)
{
    if (!proxi_enabled)
        return 0;

    if (atomic_read(&proxi_status))
        return 0;

    if (hrtimer_try_to_cancel(&s_proximity.timer) > 0)
        hrtimer_cancel(&s_proximity.timer);

    if (s_proximity.wakeup_while_sleep)
        NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_TRUE);
    else
        star_proxi_disable(&s_proximity);

    return 0;
}
コード例 #11
0
static void star_proxi_disable(ProximityDevice *data)
{
    if (proxi_enabled == false)
        return;


    if (data->use_int_mode)
        NvOdmGpioInterruptMask(data->proxi_out_intr, NV_TRUE);//Interrupt Disable(NV_TRUE)
    else
        hrtimer_cancel(&data->timer);

    cancel_work_sync(&data->work);
	//go to shutdown
    star_proxi_write_reg(&s_proximity, 0x04, 0x02 );
    s_shutdown_mode = true;
    //star_proxi_power_onoff(data, false);

//	NvOdmGpioInterruptUnregister( s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, star_proxi_interrupt_handler);

    proxi_enabled = false;
}
コード例 #12
0
static int __init proximity_probe(struct platform_device *pdev)
{
    int i, ret = 0;
    NvU32 I2cInstance = 0;
    const NvOdmPeripheralConnectivity *pConnectivity = NULL;
    NvU32 port = 0, pin = 0;
    struct device *dev = &pdev->dev;
	unsigned int pinvalue;

	atomic_set(&proxi_status, 1);
    pConnectivity = NvOdmPeripheralGetGuid(PROXIMITY_GUID);

    for (i = 0; i < pConnectivity->NumAddress; i++)
    {
        switch (pConnectivity->AddressList[i].Interface)
        {
            case NvOdmIoModule_I2c:
                s_proximity.i2c_address = (pConnectivity->AddressList[i].Address << 1);
                I2cInstance = pConnectivity->AddressList[i].Instance;
                break;
            case NvOdmIoModule_Gpio:
                port = pConnectivity->AddressList[i].Instance;
                pin = pConnectivity->AddressList[i].Address;
                break;
            case NvOdmIoModule_Vdd:
                s_proximity.vddId = pConnectivity->AddressList[i].Address;
                break;
            default:
                break;
        }
    }

	s_proximity.MVO = 0;
	#if defined(CONFIG_MACH_STAR_MDM_C)
	port = 'r' - 'a';//'a' - 'a';
	pin = 2;//0;
	#elif defined (CONFIG_MACH_STAR_REV_F) || defined (CONFIG_MACH_STAR_TMUS)
	port = 'w'-'a';
	pin = 2;
	#else
	#error PROXI_OUT PIN not assigned
	#endif

    lprintk(D_PROXI, "[star Proximity] start!!!--------------------------------------------------------------------------\n");

    s_proximity.proxi_out_gpio = NvOdmGpioOpen();
    if (!s_proximity.proxi_out_gpio)
    {
        lprintk(D_PROXI, "[star Proximity] gpio open fail!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
        ret = -ENOSYS;
        goto err_open_gpio_fail;
    }

    s_proximity.proxi_out_gpio_pin = NvOdmGpioAcquirePinHandle(s_proximity.proxi_out_gpio, port, pin);
    if (!s_proximity.proxi_out_gpio_pin)
    {
        lprintk(D_PROXI, "[star Proximity] gpio pin acquire fail!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
        ret = -ENOSYS;
        goto err_open_gpio_pin_acquire_fail;
    }

//    NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1);
//    NvOdmGpioConfig(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputData);
	#if 1

    INIT_WORK(&s_proximity.work, star_proxi_workqueue_func);

    s_proximity.gen2_i2c = NvOdmI2cPinMuxOpen(NvOdmIoModule_I2c, 1, NvOdmI2cPinMap_Config2);
    if (!s_proximity.gen2_i2c)
    {
        lprintk(D_PROXI, "[star Proximity] i2c open fail!\n");
        ret = -ENOSYS;
        goto err_open_i2c_handle_fail;
    }


    s_proximity.use_int_mode = true;
	#if 0
    NvOdmGpioConfig(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_Output);
    NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1);
		NvOdmOsWaitUS(100000);//100ms
   	NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue);
	printk("interrupt pin level = %d\n----------------", pinvalue );
    NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x0);
		NvOdmOsWaitUS(100000);//100ms
   	NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue);
	printk("interrupt pin level = %d\n----------------", pinvalue );
    NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1);
		NvOdmOsWaitUS(100000);//100ms
   	NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue);
	printk("interrupt pin level = %d\n----------------", pinvalue );
    NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x0);
		NvOdmOsWaitUS(100000);//100ms
   	NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue);
	printk("interrupt pin level = %d\n----------------", pinvalue );
    NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1);
		NvOdmOsWaitUS(100000);//100ms
   	NvOdmGpioGetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, &pinvalue);
	printk("interrupt pin level = %d\n----------------", pinvalue );
	#endif	

	#if 0 
	while(1)
	{
    	NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x1);
		NvOdmOsWaitUS(100000);//100ms
    	NvOdmGpioSetState(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, 0x0);
		NvOdmOsWaitUS(100000);//100ms
	}
	#endif

    NvOdmGpioConfig(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputData);

    if (s_proximity.use_int_mode == true) {
        if (NvOdmGpioInterruptRegister(s_proximity.proxi_out_gpio, &s_proximity.proxi_out_intr,
            s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputInterruptLow, star_proxi_interrupt_handler, (void*)&s_proximity, 0) == NV_FALSE)
        {
            lprintk(D_PROXI, "[star Proximity] interrupt register fail!\n");
            ret = -ENOSYS;
            goto err_open_irq_handle_fail;
        }
    } else {
        if (NvOdmGpioInterruptRegister(s_proximity.proxi_out_gpio, &s_proximity.proxi_out_intr,
            s_proximity.proxi_out_gpio_pin, NvOdmGpioPinMode_InputInterruptFallingEdge, star_proxi_sleep_handler, (void*)&s_proximity, 0) == NV_FALSE)
        {
            lprintk(D_PROXI, "[star Proximity] interrupt register fail!\n");
            ret = -ENOSYS;
            goto err_open_irq_handle_fail;
        }

        hrtimer_init(&s_proximity.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
        s_proximity.timer.function = star_proxi_timer_func;
        s_proximity.delay = PROXI_DEFAULT_DELAY_NS;
    }


    NvOdmGpioInterruptMask(s_proximity.proxi_out_intr, NV_TRUE);

    s_proximity.input_dev = input_allocate_device();
    if (!s_proximity.input_dev) {
        lprintk(D_PROXI, "[star Proximity] input device alloc fail!\n");
        ret = -ENOMEM;
        goto err_alloc_input_device_fail;
    }

    set_bit(EV_KEY, s_proximity.input_dev->evbit);
    set_bit(KEY_POWER, s_proximity.input_dev->keybit);
    set_bit(EV_ABS, s_proximity.input_dev->evbit);
    input_set_abs_params(s_proximity.input_dev, ABS_DISTANCE, 0, 1, 0, 0);
    s_proximity.input_dev->name = "proximity";
    ret = input_register_device(s_proximity.input_dev);
    if (ret) {
        lprintk(D_PROXI, "[star Proximity] input device register fail!\n");
        ret = -ENOMEM;
        goto err_alloc_input_device_fail;
    }

    if ((ret = sysfs_create_group(&dev->kobj, &star_proxi_group))) {
        lprintk(D_PROXI, "[star Proximity] sysfs_create_group fail!\n");
        ret = -ENOMEM;
        goto err_sysfs_group_fail;
    }

//    star_proxi_power_onoff(&s_proximity, true);

    return 0;

err_sysfs_group_fail:
    input_unregister_device(s_proximity.input_dev);
err_alloc_input_device_fail:
    NvOdmGpioInterruptUnregister(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin,
        s_proximity.proxi_out_intr);
err_open_irq_handle_fail:
    NvOdmI2cClose(s_proximity.gen2_i2c); 
err_open_i2c_handle_fail:
    NvOdmGpioReleasePinHandle(s_proximity.proxi_out_gpio, s_proximity.proxi_out_gpio_pin);
err_open_gpio_pin_acquire_fail:
    NvOdmGpioClose(s_proximity.proxi_out_gpio);
err_open_gpio_fail:

    return ret;

#endif
}
コード例 #13
0
void NvOdmEcompasspioInterruptUnMask(NvOdmEcompassHandle hDevice){
	NvOdmGpioInterruptMask(hDevice->hGpioInterrupt, NV_FALSE);
}