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; }