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 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;
}
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;
}
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;
}
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();
}
//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();
}
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 void __exit sensor_exit(void)
{
dbg_func_in();
platform_driver_unregister(&sensor_driver);
platform_device_unregister(sensor_pdev);
dbg_func_out();
}
static void enable_irq_detect(void)
{
dbg_func_in();
if(irq_state == 1) {
enable_irq(gpio_to_irq(EARJACK_DET));
irq_state = 0;
}else{
printk("[EARJACK] Already enable irq\n");
}
}
static void disable_irq_detect(void)
{
dbg_func_in();
if(irq_state == 0) {
disable_irq_nosync(gpio_to_irq(EARJACK_DET));
irq_state = 1;
}else{
printk("[EARJACK] Already disable irq\n");
}
}
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);
}
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();
}
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();
}
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();
}
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();
}
// 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;
}
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);
}
static int sensor_get_enable(struct device *dev)
{
struct input_dev *inputdev = to_input_dev(dev);
struct sensor_data *sensordata = input_get_drvdata(inputdev);
int enable;
dbg_func_in();
enable = atomic_read(&sensordata->enable);
dbg_func_out();
return enable;
}
static ssize_t sensor_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
unsigned long enable = simple_strtoul(buf, NULL, 10);
dbg_func_in();
if ((enable == 0) || (enable == 1)) {
sensor_set_enable(dev, enable);
}
dbg_func_out();
return count;
}
static int sensor_get_delay(struct device *dev)
{
struct input_dev *inputdev = to_input_dev(dev);
struct sensor_data *sensordata = input_get_drvdata(inputdev);
int delay;
dbg_func_in();
delay = atomic_read(&sensordata->delay);
dbg_func_out();
return delay;
}
static irqreturn_t Remotekey_Det_handler(int irq, void *dev_id) // isr_Remotekey_Det_handler
{
dbg_func_in();
// if 3pole headset, return.
if(!earjack->mic_on) {
return IRQ_HANDLED;
}
// disable_irq, wake_lock
disable_irq_nosync(gpio_to_irq(REMOTEKEY_DET));
wake_lock(&remotekey_wake_lock);
schedule_delayed_work(&remotekey_work, 0);
dbg_func_out();
return IRQ_HANDLED;
}
static int
geomagnetic_enable(struct geomagnetic_data *data)
{
dbg_func_in();
if (!atomic_cmpxchg(&data->enable, 0, 1)) {
dbg("%s : schedule_delayed_work(&data->work, 0);", __func__);
schedule_delayed_work(&data->work, 0);
}
dbg_func_out();
return 0;
}
static int
geomagnetic_disable(struct geomagnetic_data *data)
{
dbg_func_in();
if (atomic_cmpxchg(&data->enable, 1, 0)) {
dbg("%s : cancel_delayed_work_sync(&data->work);", __func__);
cancel_delayed_work_sync(&data->work);
}
dbg_func_out();
return 0;
}
static int yas529_i2c_remove(struct i2c_client *client)
{
struct yas529_data_type *dd;
dbg_func_in();
misc_deregister(&yas529_misc_device);
dd = i2c_get_clientdata(client);
kfree(dd);
i2c_set_clientdata(client, NULL);
dbg_func_out();
return 0;
}
void max17040_batt_late_resume(struct early_suspend *h)
{
dbg_func_in();
/* We might be on a slow sample cycle. If we're
* resuming we should resample the battery state
* if it's been over a minute since we last did
* so, and move back to sampling every minute until
* we suspend again.
*/
if (max17040_data.slow_poll) {
max17040_program_alarm_set(&max17040_data, FAST_POLL);
max17040_data.slow_poll = Early_resume;
sleep_dbg("CONFIG FAST_POLL [The alarm is set for [%d] seconds]\n",FAST_POLL);
}
dbg_func_out();
}
static int __init yas529_driver_init(void)
{
int rc; /* initialized below */
dbg_func_in();
rc = i2c_add_driver(&yas529_i2c_driver);
if (rc)
{
printk(KERN_ERR "yas529 : i2c_add_driver failed(rc=%d).\n", rc);
return rc;
}
dbg_func_out();
return rc;
}
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);
/* 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);
//Factory cable debug
#ifdef CONFIG_SKY_SMB136S_CHARGER
//printk("Max17040_data.vcell = %d\n", max17040_data.vcell);
if(pm8058_chg_nobattery_factory_cable())
max17040_data.vcell = 4100;
#endif
dbg_func_out();
}
static int sensor_resume(struct platform_device *pdev)
{/*
struct input_dev *inputdev = to_input_dev(&pdev->dev);
struct sensor_data *sensordata = input_get_drvdata(inputdev);
int enable = atomic_read(&sensordata->enable);
int delay = atomic_read(&sensordata->delay);
*/
dbg_func_in();
/*
if (enable && (!sensordata->status)) {
schedule_delayed_work(&sensordata->work, delay_to_jiffies(delay) + 1);
sensordata->status = 1;
}
*/
dbg_func_out();
return 0;
}
