Beispiel #1
0
static int max17040_get_property(struct power_supply *psy,
			    enum power_supply_property psp,
			    union power_supply_propval *val)
{
	dbg_func_in();
	switch (psp) {
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		if(max17040_data.i2c_state_vol)
		val->intval = max17040_data.prev_voltage*1000; //2011.05.16 leecy add for battery Info
		else
		val->intval = max17040_data.vcell*1000; //2011.05.16 leecy add for battery Info

		//pr_info("[SKY CHG] %s max17040_get_property= %d V\n",
		//			__func__,val->intval);		
		break;
	case POWER_SUPPLY_PROP_CAPACITY:
		if(max17040_data.i2c_state)
		val->intval = max17040_data.prev_soc;		
		else
		val->intval = max17040_data.soc;

		//pr_info("[SKY CHG] %s max17040_get_property= %d Pro\n",
		//			__func__,val->intval);
		break;
	default:
		return -EINVAL;
	}
	dbg_func_out();		
	return 0;
}
Beispiel #2
0
static int yas_acc_resume(struct i2c_client *client)
{
    struct yas_acc_private_data *data = i2c_get_clientdata(client);
    struct yas_acc_driver *driver = data->driver;
    int delay;

	dbg_func_in();
#ifdef POWER_ON_OFF
	geomagnetic_set_power(1);
#endif

#ifndef PANTECH_AVOID_DEADLOCK
    mutex_lock(&data->data_mutex);
#endif

	dbg("%s : data->suspend = %d / data->suspend_enable = %d / delay = %d\n", __func__, data->suspend, yas_acc_get_enable(driver), yas_acc_get_delay(driver));

    if (data->suspend == 1) {
        if (data->suspend_enable) {
            delay = yas_acc_get_delay(driver);
#ifndef PANTECH_AVOID_DEADLOCK
            schedule_delayed_work(&data->work, delay_to_jiffies(delay) + 1);
#endif
            yas_acc_set_enable(driver, 1);
        }
    }
    data->suspend = 0;

#ifndef PANTECH_AVOID_DEADLOCK
    mutex_unlock(&data->data_mutex);
#endif
	dbg_func_out();

    return 0;
}
static void sensor_set_enable(struct device *dev, int enable)
{
	struct input_dev *inputdev = to_input_dev(dev);
    struct sensor_data *sensordata = input_get_drvdata(inputdev);
	int delay = atomic_read(&sensordata->delay);

	dbg_func_in();

	mutex_lock(&sensordata->enable_mutex);

	if (enable) {                   /* enable if state will be changed */
		if (!atomic_cmpxchg(&sensordata->enable, 0, 1)) {
			sensordata->status = apds9900_control_enable(APDS9900_TYPE_PROXIMITY, true) ? 0 : 1;
			if(sensordata->status) {
				schedule_delayed_work(&sensordata->work, delay_to_jiffies(delay) + 1);
			}
		}
	} else {                        /* disable if state will be changed */
		if (atomic_cmpxchg(&sensordata->enable, 1, 0) && sensordata->status) {
			if(sensordata->status) {
				cancel_delayed_work_sync(&sensordata->work);
				sensordata->status = apds9900_control_enable(APDS9900_TYPE_PROXIMITY, false) ? 0 : 1;
			}
		}
	}
	atomic_set(&sensordata->enable, enable);

	mutex_unlock(&sensordata->enable_mutex);

	dbg_func_out();
}
Beispiel #4
0
static int yas_acc_set_enable(struct yas_acc_driver *driver, int enable)
{
    struct yas_acc_private_data *data = yas_acc_get_data();
    int delay = driver->get_delay();

	dbg_func_in();

	dbg("%s : enable=%d, delay=%d\n", __func__, enable, delay);

#ifndef PANTECH_AVOID_DEADLOCK
    if (yas_acc_ischg_enable(driver, enable)) {
#endif
        if (enable) {
            driver->set_enable(enable);
            schedule_delayed_work(&data->work, delay_to_jiffies(delay) + 1);
			dbg("%s : schedule_delayed_work(&data->work, %d)\n", __func__, delay);
        } else {
            cancel_delayed_work_sync(&data->work);
			dbg("%s : cancel_delayed_work_sync\n", __func__);
            driver->set_enable(enable);
        }
#ifndef PANTECH_AVOID_DEADLOCK
    }
#endif

	dbg_func_out();

    return 0;
}
static void sensor_work_func(struct work_struct *work)
{
	struct sensor_data *sensordata = container_of((struct delayed_work *)work, struct sensor_data, work);
	axes_t val;
	unsigned long delay;

	dbg_func_in();

	if(input_pdev == NULL) {
		cancel_delayed_work_sync(&sensordata->work);
	} else {
		sensor_measure(sensordata, &val);
		#if AT1_BDVER_GE(AT1_WS20)  //hhs veeapp read function add 20110316
        val_backup.x = val.x;
		val_backup.y = val.y;
		val_backup.z = val.z;
		#endif
		input_report_abs(input_pdev, ABS_X, (int)val.x);
		input_report_abs(input_pdev, ABS_Y, (int)val.y);
		input_report_abs(input_pdev, ABS_Z, (int)val.z);
		input_sync(input_pdev);

		mutex_lock(&sensordata->data_mutex);
		sensordata->lastval = val;
		mutex_unlock(&sensordata->data_mutex);

		delay = delay_to_jiffies(atomic_read(&sensordata->delay));
		schedule_delayed_work(&sensordata->work, delay);
	}

	dbg_func_out();
}
static int
geomagnetic_suspend(struct i2c_client *client, pm_message_t mesg)
{
    struct geomagnetic_data *data = i2c_get_clientdata(client);

	dbg_func_in();

	dbg("%s : data->enable = %d\n", __func__, atomic_read(&data->enable));

    if (atomic_read(&data->enable)) {
        dbg("%s : cancel_delayed_work_sync(&data->work);", __func__);
        cancel_delayed_work_sync(&data->work);
    }
#if DEBUG
    data->suspend = 1;
#endif

#ifdef POWER_ON_OFF //p12911 : ef33s sensor patch
	geomagnetic_set_power(0);
#endif

	dbg_func_out();

    return 0;
}
Beispiel #7
0
static int yas_acc_suspend(struct i2c_client *client, pm_message_t mesg)
{
    struct yas_acc_private_data *data = i2c_get_clientdata(client);
    struct yas_acc_driver *driver = data->driver;

	dbg_func_in();

	dbg("%s : data->suspend = %d / data->suspend_enable = %d\n", __func__, data->suspend, yas_acc_get_enable(driver));

#ifndef PANTECH_AVOID_DEADLOCK
    mutex_lock(&data->data_mutex);
#endif

    if (data->suspend == 0) {
        data->suspend_enable = yas_acc_get_enable(driver);
        if (data->suspend_enable) {
#ifndef PANTECH_AVOID_DEADLOCK
            cancel_delayed_work_sync(&data->work);
#endif
            yas_acc_set_enable(driver, 0);
        }
    }
    data->suspend = 1;
	
#ifndef PANTECH_AVOID_DEADLOCK
    mutex_unlock(&data->data_mutex);
#endif

#ifdef POWER_ON_OFF
	geomagnetic_set_power(0);
#endif
	dbg_func_out();

    return 0;
}
static void sensor_work_func(struct work_struct *work)
{
	struct sensor_data *sensordata = container_of((struct delayed_work *)work, struct sensor_data, work);
	axes_t val;
	unsigned long delay;

	dbg_func_in();

	if(input_pdev == NULL) {
		cancel_delayed_work_sync(&sensordata->work);
	} else {
		sensor_measure(sensordata, &val);

		input_report_abs(input_pdev, ABS_X, (int)val.x);
		input_report_abs(input_pdev, ABS_Y, (int)val.y);
		input_report_abs(input_pdev, ABS_Z, (int)val.z);
		input_sync(input_pdev);

		mutex_lock(&sensordata->data_mutex);
		sensordata->lastval = val;
		mutex_unlock(&sensordata->data_mutex);

		delay = delay_to_jiffies(atomic_read(&sensordata->delay));
		schedule_delayed_work(&sensordata->work, delay);
	}

	dbg_func_out();
}
Beispiel #9
0
static void max17040_get_vcell(void)
{
	u8 msb;
	u8 lsb;
	int avalue=0;
	int voltage=0;
	dbg_func_in();
	msb = max17040_read_reg(MAX17040_VCELL_MSB);
	lsb = max17040_read_reg(MAX17040_VCELL_LSB);

	//check i2c error
	if(msb<0 ||lsb <0)
	{
	max17040_data.i2c_state_vol =1;
	}
	else
	{
	max17040_data.i2c_state_vol =0;
	max17040_data.prev_voltage=max17040_data.vcell;
	}
	
	voltage=(msb<<4)|((lsb&0xf0)>>4);
	avalue=(voltage*125)/100;
//	sleep_dbg(" MSB [%d] : LSB [%d] : LOW VOLTAGE [%d] : VOLTAGE_NOW [%d]\n",msb,lsb,voltage,avalue);
	/* ps2 team shs : voltage changes but the event is not sent.
	//temp code
	if(avalue!=max17040_data.vcell)
	max17040_data.event=Events;
	*/
	mutex_lock(&max17040_data.data_mutex); 	
	max17040_data.vcell = avalue;
	mutex_unlock(&max17040_data.data_mutex);	
	dbg_func_out();	
}
static void sensor_set_enable(struct device *dev, int enable)
{
	struct input_dev *inputdev = to_input_dev(dev);
    struct sensor_data *sensordata = input_get_drvdata(inputdev);
	int delay = atomic_read(&sensordata->delay);

	dbg_func_in();

	mutex_lock(&sensordata->enable_mutex);

	if (enable) {                   /* enable if state will be changed */
		if (!atomic_cmpxchg(&sensordata->enable, 0, 1)) {
			l3g4200d_control_enable(1);
			schedule_delayed_work(&sensordata->work, delay_to_jiffies(delay) + 1);
		}
	} else {                        /* disable if state will be changed */
		if (atomic_cmpxchg(&sensordata->enable, 1, 0)) {
			cancel_delayed_work_sync(&sensordata->work);
			l3g4200d_control_enable(0);
		}
	}
	atomic_set(&sensordata->enable, enable);

	mutex_unlock(&sensordata->enable_mutex);

	dbg_func_out();
}
static int
geomagnetic_resume(struct i2c_client *client)
{
    struct geomagnetic_data *data = i2c_get_clientdata(client);
	dbg_func_in();

	dbg("%s : data->enable = %d\n", __func__, atomic_read(&data->enable));

#ifdef POWER_ON_OFF
	geomagnetic_set_power(1);
#endif

    if (atomic_read(&data->enable)) {
        schedule_delayed_work(&data->work, 0);
        dbg("%s : schedule_delayed_work(&data->work, 0);", __func__);
    }

#if DEBUG
    data->suspend = 0;
#endif

	dbg_func_out();

    return 0;
}
Beispiel #12
0
static int yas529_misc_release(struct inode *inode, struct file *file) 
{
	dbg_func_in();
	file->private_data = (void*)NULL;
	module_put(THIS_MODULE);
	dbg_func_out();
	return 0;
}
Beispiel #13
0
static irqreturn_t Earjack_Det_handler(int irq, void *dev_id)
{
	dbg_func_in();
	disable_irq_nosync(gpio_to_irq(EARJACK_DET));
	wake_lock(&earjack_wake_lock);
	schedule_delayed_work(&earjack_work, 10);    // after 100ms start function of earjack_detect_func
	dbg_func_out();
	return IRQ_HANDLED;
}
Beispiel #14
0
int max17040_get_voltage(void)
{
	dbg_func_in();
	if(max17040_data.i2c_state_vol)	
	return 	max17040_data.prev_voltage;
	else
	return max17040_data.vcell;
	dbg_func_out();
}
Beispiel #15
0
static ssize_t max17040_store_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	u8 scale = (u8)simple_strtoul(buf, NULL, 10);
	dbg_func_in();			
	dbg("max17040_store_flag => [%d]\n",scale);
	atomic_set(&max17040_data.set_test, scale);	
	dbg_func_out();					
	return count;
}
Beispiel #16
0
//ps2 team shs : depend on normal mode wake lock
void max17040_prevent_suspend(void)
{
	dbg_func_in();
	if(!max17040_wake_state)
		{
		wake_lock(&max17040_data.work_wake_lock);
		max17040_wake_state=1;
		}
	dbg_func_out();
}
Beispiel #17
0
static int max17040_resume(struct i2c_client *client)
{
	dbg_func_in();
	if (max17040_data.slow_poll) {
		schedule_delayed_work(&max17040_data.work, 0);		
		sleep_dbg("[RESUME] CONFIG FAST_POLL [The alarm is set for [%d] seconds]\n",FAST_POLL);	
	}
	dbg_func_out();
	return 0;
}
static int sensor_resume(struct platform_device *pdev)
{
	dbg_func_in();

    /* implement resume of the sensor */
    
	dbg_func_out();

    return 0;
}
static int sensor_suspend(struct platform_device *pdev, pm_message_t state)
{
	dbg_func_in();

    /* implement suspend of the sensor */

	dbg_func_out();

    return 0;
}
static ssize_t sensor_readabs_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	dbg_func_in();

	dbg("%s : enable = %d\n", __func__, val_backup.x);

	dbg_func_out();

    return sprintf(buf, "%d\n", val_backup.x);
}
Beispiel #21
0
static int __devinit yas529_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct yas529_data_type *dd;
	int rc;

	dbg_func_in();

	if(yas529_data)
	{
		dev_err(&client->dev, "yas529_i2c_probe error\n");
		rc = -EPERM;
		goto probe_exit;
	}

	dd = kzalloc (sizeof(struct yas529_data_type),GFP_KERNEL);
	if(!dd)
	{
		rc = -ENOMEM;
		goto probe_exit;
	}
	yas529_data = dd;
	i2c_set_clientdata(client, dd);
	dd->pClient = client;
	
	rc = misc_register(&yas529_misc_device);
	if (rc) 
	{
		printk(KERN_ERR "yas529 : misc_register failed.\n");
		goto probe_free_exit;
	}
	
	yas529_data->pClient->addr = YAS529_SLAVE_ADDR;
	
	dbg_func_out();
	return 0;
	
probe_free_exit:
	yas529_data = NULL;
	i2c_set_clientdata(client, NULL);
probe_exit:
	dbg_func_out();
	return rc;
}
Beispiel #22
0
static void __exit sensor_exit(void)
{
	dbg_func_in();

    platform_driver_unregister(&sensor_driver);
    platform_device_unregister(sensor_pdev);

	dbg_func_out();

}
Beispiel #23
0
static void max17040_quick_get_soc(void)
{
	u8 msb=0;
	u8 lsb=0;
	int avalue=0;
	//unsigned long quick_soc;
	int i=0;
	bool completed = false;
	dbg_func_in();

	while (!completed) {

	msb = max17040_read_reg(MAX17040_SOC_MSB);
	lsb = max17040_read_reg(MAX17040_SOC_LSB);
	if(msb < 0 || lsb < 0)
	{
		for(i=0;i<MAX_READ;i++)
		{
			msb = max17040_read_reg(MAX17040_SOC_MSB);
			lsb = max17040_read_reg(MAX17040_SOC_LSB);
			if(msb < 0 || lsb <0)
			{
				continue;
			}
			else
			break;
		}
	}
	/*//description
	read i2c data [msb=20,lsb=10]
	avalue=20*1000+(10*1000)/256
	*/
	avalue=SKY_MULT_1000(msb)+(SKY_MULT_1000(lsb)/SKY_SOC_LSB);	
	//Ajdusted soc%=(SOC%-EMPTY)/(FULL-EMPTY)*100
	//logic code	
	sleep_dbg("MAX17040_QUICK Adjusted SOC MSB [%d] : LSB [%d] : Adjusted SOC [%d] :Try Count [%d]\n",msb,lsb,avalue,i);
	
	if(i>=MAX_READ-1 || msb < 0 || lsb <0 ) { //Battery Bug Fixing Coded by Illustrious by Proto
		printk("Re-running to check Battery SoC!!!\n");
		i = 0;
		continue;			
	} else {
		mutex_lock(&max17040_data.data_mutex); 	
		max17040_data.quick_data.soc_msb=msb;	
		max17040_data.quick_data.soc_lsb=lsb;
		max17040_data.quick_data.quick_soc=avalue;
		mutex_unlock(&max17040_data.data_mutex);
		completed = true;
		break;
	}

	}	

	dbg_func_out();	
}
Beispiel #24
0
void max17040_allow_suspend(void)
{

	dbg_func_in();
	if(max17040_wake_state)
		{
		wake_unlock(&max17040_data.work_wake_lock);
		max17040_wake_state=0;		
		}
	dbg_func_out();
}
Beispiel #25
0
static void max17040_program_alarm_set(struct max17040_chip *di, int seconds)
{
	ktime_t low_interval = ktime_set(seconds - 10, 0);
	ktime_t slack = ktime_set(20, 0);
	ktime_t next;
	ktime_t finish;	
	dbg_func_in();
	next = ktime_add(di->last_poll, low_interval);
	finish=ktime_add(next, slack);
	alarm_start_range(&di->alarm, next, finish);
	dbg_func_out();	
}
Beispiel #26
0
static int yas529_misc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	unsigned long reg;
	int rc = 0;

	dbg_func_in();

	dbg("ioctl cmd = %d / arg = %d\n", cmd, arg);

	switch (cmd)
	{
		case 0x706:
			yas529_data->pClient->addr = arg;
			dbg_func_out();
			return 0;
	}

	dbg_func_out();
	return 0;
}
Beispiel #27
0
static void max_battery_alarm_callback(struct alarm *alarm)
{

	struct max17040_chip *di =
		container_of(alarm, struct max17040_chip, alarm);
	dbg_func_in();
	sleep_dbg("MAX17040_ALARM_CALLBACK CALL.\n");					
	/*enable wake_lock*/
	max17040_prevent_suspend();
	/*schdule workqueue*/
	queue_work(di->monitor_wqueue, &di->monitor_work);
	dbg_func_out();	
}
Beispiel #28
0
static int __init sensor_init(void)
{
	dbg_func_in();

    sensor_pdev = platform_device_register_simple(SENSOR_INPUTDEV_NAME, 0, NULL, 0);
    if (IS_ERR(sensor_pdev)) {
        return -1;
    }

	dbg_func_out();
	
    return platform_driver_register(&sensor_driver);
}
Beispiel #29
0
// Remove Driver
static int __devexit pantech_earjack_remove(struct platform_device *pdev)
{
	struct pantech_earjack *earjack = platform_get_drvdata(pdev);

	dbg_func_in();
	input_unregister_device(earjack->ipdev);
	switch_dev_unregister(&earjack->sdev);
	kfree(earjack);
	wake_lock_destroy(&earjack_wake_lock);
	wake_lock_destroy(&remotekey_wake_lock);
	dbg_func_out();
	return 0;
}
Beispiel #30
0
static int adc_value_to_key(void)  // detect key sensing                                 
{
	int nAdcValue = 0;
	int i;
	dbg_func_in();
	check_analog_mpp(CHANNEL_ADC_HDSET,&nAdcValue);             // read analog input mpp_3    
	dbg("analog intput mpp_03 value : %d\n", nAdcValue);
	for( i = 1; i< ARR_SIZE( remotekey_type); i++ ) {
		if( nAdcValue >= remotekey_type[i].min && nAdcValue <= remotekey_type[i].max ) {
			// Check if car_kit
			earjack->car_kit = 0;
			if(i == ARR_SIZE(remotekey_type)-1 )
				earjack->car_kit = 1;
			// Return key index
			dbg_func_out();  	
			return i;
		}
	}
	// No Key, return 0
	dbg_func_out();  	
	return 0;
}