static void sensor_irq_do_work(struct work_struct *work)
{
    struct ltr558_info *lpi = lp_info;

    uint8_t status = 0;
    int als_ps_status;
    int interrupt, newdata;

    als_ps_status = ltr558_i2c_read_reg(LTR558_ALS_PS_STATUS);
    interrupt = als_ps_status & 10;
    newdata = als_ps_status & 5;

    switch (interrupt){
                case 2:
                        // PS interrupt
                        if ((newdata == 1) | (newdata == 5)){
                          
                         //wake_up_interruptible(&ps_waitqueue);
                            report_psensor_input_event(lpi);
                        }
                        break;

                case 8:
                        // ALS interrupt
                        if ((newdata == 4) | (newdata == 5)){
                        //wake_up_interruptible(&als_waitqueue);
                            report_lsensor_input_event(lpi);
                        }
                        break;

                case 10:
                        // Both interrupt
                        if ((newdata == 1) | (newdata == 5)){
                            report_psensor_input_event(lpi);
                        }
                        //wake_up_interruptible(&als_waitqueue);
                        if((newdata == 4) | (newdata == 5)){
                            report_lsensor_input_event(lpi);
                        }
                        break;
        }
#if 0
    /*check ALS or PS*/
    ltr558_i2c_read(LTR558_ALS_PS_STATUS,&status);

    D("[ltr558] intr status[0x%x]\n",status);
    if(status & 0x02)/*ps trigger interrupt*/
    {
        report_psensor_input_event(lpi);
    }
#endif

}
示例#2
0
static void polling_do_work(struct work_struct *w)
{
	struct al3006_info *lpi = lp_info;

	/*D("lpi->ps_enable = %d\n", lpi->ps_enable);*/
	if (!lpi->ps_enable && !lpi->als_enable)
		return;

    if(lpi->ps_enable)
    	report_psensor_input_event(lpi);
    if(lpi->als_enable)
    	report_lsensor_input_event(lpi);

    queue_delayed_work(lpi->lp_wq, &polling_work,
		msecs_to_jiffies(POLLING_DELAY));
}
示例#3
0
static void sensor_irq_do_work(struct work_struct *work)
{
    struct al3006_info *lpi = lp_info;

    uint8_t status = 0;

    /*check ALS or PS*/
    al3006_i2c_read(0x03,&status); /*read interrupt status register*/

    D("[AL3006] intr status[0x%x]\n",status);
    if(status & 0x02)/*ps trigger interrupt*/
    {
        report_psensor_input_event(lpi);
    }

    //enable_irq(lpi->irq);
}
static int psensor_enable(struct ltr558_info *lpi)
{
    int ret = 0;
    int error;
	  int setgain;

	  D("[LTR558] %s by pid[%d] thread [%s]\n", __func__,current->pid,current->comm);
	  /* dummy report */
	  input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, -1);
	  input_sync(lpi->ps_input_dev);

    switch (lpi->gainrange) {
		    case PS_RANGE1:
			      setgain = MODE_PS_ON_Gain1;
			      break;

		    case PS_RANGE2:
			      setgain = MODE_PS_ON_Gain2;
			      break;

		    case PS_RANGE4:
			      setgain = MODE_PS_ON_Gain4;
			      break;

		    case PS_RANGE8:
			      setgain = MODE_PS_ON_Gain8;
			      break;

		    default:
			      setgain = MODE_PS_ON_Gain1;
			      break;
    }

	  error = ltr558_i2c_write_reg(LTR558_PS_CONTR, setgain);

  
	  msleep(15);
	  report_psensor_input_event(lpi);
    lpi->ps_enable = 1;

  //if(!lpi->als_enable)
	 // queue_delayed_work(lpi->lp_wq, &polling_work,msecs_to_jiffies(POLLING_DELAY));

	  return ret;
}
示例#5
0
static int psensor_enable(struct al3006_info *lpi)
{
	int ret = 0;

	D("[AL3006] %s by pid[%d] thread [%s]\n", __func__,current->pid,current->comm);
#if 0
	if (lpi->ps_enable) {
		D("[AL3006] %s: already enabled\n", __func__);
		return 0;
	}
#endif
	/* dummy report */
	input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, -1);
	input_sync(lpi->ps_input_dev);

#if 0
    if(lpi->als_enable)
        al3006_i2c_write(0x00,0x02); // both enable ps and als
    else
#endif
        al3006_i2c_write(0x00,0x01); // only enable ps

	msleep(15);
	report_psensor_input_event(lpi);

    lpi->ps_enable = 1;
#if 0    
    if(!lpi->ps_irq_flag){
        enable_irq(lpi->irq);
        lpi->ps_irq_flag = 1;
    }
#endif
    //if(!lpi->als_enable)
	queue_delayed_work(lpi->lp_wq, &polling_work,
		msecs_to_jiffies(POLLING_DELAY));

	return ret;
}