static ssize_t touch_version_read(struct device *dev,
struct device_attribute *attr, char *buf)
{
char data[16],*write_val=0x40,ret;
int count,key_sensitivity;
char i;
ret = i2c_touchkey_write(devdata, &write_val, 1);
if (ret){
for(i=0;i<10;i++){
msleep(10);
ret = i2c_touchkey_write(devdata, &write_val, 1);
if(ret==0)
break;
}
printk("%s: touchkey i2c failed\n", __func__);
count = sprintf(buf, "%s\n", "PBA");
return count;
}
i2c_touchkey_read(devdata, KEYCODE_REG, data, 16);
count = sprintf(buf, "0x%x\n", data[1]);
printk("[touch key] firmware=0x%x,module=0x%x\n", data[1], data[2]);
return count;
}
static ssize_t touch_led_control(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
int ret;
if (strncmp(buf, "1", 1) == 0)
{
if (devdata_led->is_powering_on){
dev_err(dev, "%s: delay led on \n", __func__);
devdata_led->is_delay_led_on = true;
return size;
}
ret = i2c_touchkey_write(devdata_led, &devdata_led->backlight_on, 1);
printk("Touch Key led ON\n");
}
else
{
if (devdata_led->is_powering_on){
dev_err(dev, "%s: delay led off skip \n", __func__);
devdata_led->is_delay_led_on = false;
return size;
}
ret = i2c_touchkey_write(devdata_led, &devdata_led->backlight_off, 1);
printk("Touch Key led OFF\n");
}
if (ret)
dev_err(dev, "%s: touchkey led i2c failed\n", __func__);
return size;
}
static int melfas_touchkey_late_resume(struct early_suspend *h)
{
#ifdef TEST_JIG_MODE
unsigned char get_touch = 0x40;
#endif
set_touchkey_debug('R');
printk(KERN_DEBUG "[TouchKey] melfas_touchkey_late_resume\n");
/* enable ldo11 */
touchkey_ldo_on(1);
if (touchkey_enable < 0) {
printk(KERN_DEBUG "[TouchKey] ---%s---touchkey_enable: %d\n",
__func__, touchkey_enable);
return 0;
}
gpio_direction_output(_3_GPIO_TOUCH_EN, 1);
gpio_direction_output(_3_TOUCH_SDA_28V, 1);
gpio_direction_output(_3_TOUCH_SCL_28V, 1);
gpio_direction_output(_3_GPIO_TOUCH_INT, 1);
set_irq_type(IRQ_TOUCH_INT, IRQF_TRIGGER_FALLING);
s3c_gpio_cfgpin(_3_GPIO_TOUCH_INT, _3_GPIO_TOUCH_INT_AF);
s3c_gpio_setpull(_3_GPIO_TOUCH_INT, S3C_GPIO_PULL_NONE);
msleep(50);
touchkey_led_ldo_on(1);
#ifdef WHY_DO_WE_NEED_THIS
/* clear interrupt */
if (readl(gpio_pend_mask_mem) & (0x1 << 1)) {
writel(readl(gpio_pend_mask_mem) | (0x1 << 1),
gpio_pend_mask_mem);
}
#endif
enable_irq(IRQ_TOUCH_INT);
touchkey_enable = 1;
if (touchled_cmd_reversed) {
touchled_cmd_reversed = 0;
i2c_touchkey_write(&touchkey_led_status, 1);
printk("LED returned on\n");
}
#ifdef TEST_JIG_MODE
i2c_touchkey_write(&get_touch, 1);
#endif
return 0;
}
static int sec_touchkey_late_resume(struct early_suspend *h)
{
struct touchkey_i2c *tkey_i2c =
container_of(h, struct touchkey_i2c, early_suspend);
#ifdef TEST_JIG_MODE
unsigned char get_touch = 0x40;
#endif
set_touchkey_debug('R');
printk(KERN_DEBUG "[TouchKey] sec_touchkey_late_resume\n");
#if defined(CONFIG_S2VE_TOUCHKEY_REV05)
printk(KERN_ERR"sec_touchkey_late_resume++\n");
Touchkey_PowerOnOff(1);
gpio_set_value(TOUCHKEY_SDA, 0);
gpio_set_value(TOUCHKEY_SCL, 0);
touchkey_led_on(tkey_i2c, 1);
touchkey_suspended = 0;
#else
if (touchkey_enable < 0) {
printk(KERN_DEBUG "[TouchKey] ---%s---touchkey_enable: %d\n",
__func__, touchkey_enable);
return 0;
}
msleep(50);
touchkey_enable = 1;
#if defined(TK_HAS_AUTOCAL)
touchkey_autocalibration(tkey_i2c);
#endif
if (touchled_cmd_reversed) {
touchled_cmd_reversed = 0;
i2c_touchkey_write(tkey_i2c->client,
(u8 *) &touchkey_led_status, 1);
printk(KERN_DEBUG "[Touchkey] LED returned on\n");
}
#ifdef TEST_JIG_MODE
i2c_touchkey_write(tkey_i2c->client, &get_touch, 1);
#endif
enable_irq(tkey_i2c->irq);
#endif
return 0;
}
static ssize_t touch_led_control(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
u8 data;
u8 led_bright[2]= {LED_BRIGHT_BIT,LED_BRIGHT};
//data = 1 on, 0 off
sscanf(buf, "%hhu", &data);
led_onoff = (data == 0) ? 0 : 1;
data = (data == 0) ? 2 : 1;
if (!touchkey_enable)
return -1;
i2c_touchkey_write(led_bright, 2);
i2c_touchkey_write(&data, 1); // LED on(data=1) or off(data=2)
return size;
}
static ssize_t set_touchkey_autocal_testmode(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
int count = 0;
u8 set_data;
int on_off;
if (sscanf(buf, "%d\n", &on_off) == 1) {
printk(KERN_ERR "[TouchKey] Test Mode : %d \n", on_off);
if (on_off == 1) {
set_data = 0x40;
count = i2c_touchkey_write(&set_data, 1);
} else {
touchkey_ldo_on(0);
msleep(50);
touchkey_ldo_on(1);
msleep(50);
init_hw();
msleep(50);
touchkey_autocalibration();
}
} else {
printk(KERN_ERR "[TouchKey] set_touchkey_autocal_testmode Error\n");
}
return count;
}
static ssize_t touch_sensitivity_control(struct device *dev, struct
device_attribute *attr, const char *buf, size_t size)
{
unsigned char data = 0x40;
i2c_touchkey_write(&data, 1);
return size;
}
void touchkey_resume_func(struct work_struct *p)
{
// int err = 0;
// int rc = 0;
enable_irq(IRQ_TOUCHKEY_INT);
touchkey_enable = 1;
msleep(50);
#if defined (CONFIG_USA_MODEL_SGH_T989)||defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_I717)\
|| defined (CONFIG_USA_MODEL_SGH_T769) || defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_CAN_MODEL_SGH_I577R)\
|| defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_CAN_MODEL_SGH_I757M)
touchkey_auto_calibration(1/*on*/);
#elif defined (CONFIG_KOR_MODEL_SHV_E110S)
if (get_hw_rev() >= 0x02)
touchkey_auto_calibration(1/*on*/);
#elif defined (CONFIG_JPN_MODEL_SC_03D)
if (get_hw_rev() >= 0x02)
touchkey_auto_calibration(1/*on*/);
#endif
#if 0
{
// temporary code for touchkey led
int int_data = 0x10;
msleep(100);
printk("[TKEY] i2c_touchkey_write : key backligh on\n");
i2c_touchkey_write((u8*)&int_data, 1);
}
#endif
}
static ssize_t touch_led_control(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
unsigned char data;
if (sscanf(buf, "%d\n", &data) == 1) {
printk(KERN_DEBUG "touch_led_control: %d \n", data);
#ifdef CONFIG_KEYPAD_CYPRESS_TOUCH_USE_BLN
if ((touchkey_enable == 1)) {
if (data == 1)
set_backlight(BACKLIGHT_ON);
if (data == 2) {
/* only disable leds if no notification is enabled*/
if (BacklightNotification_ongoing)
set_backlight(BACKLIGHT_ON);
else
set_backlight(BACKLIGHT_OFF);
}
} else
printk(KERN_DEBUG "touchkey is not enabled.W\n");
#else
i2c_touchkey_write(&data, 1);
touchkey_led_status = data;
#endif
} else
printk("touch_led_control Error\n");
return size;
}
static ssize_t touchkey_back_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct touchkey_i2c *tkey_i2c = dev_get_drvdata(dev);
#if defined(CONFIG_MACH_Q1_BD) \
|| (defined(CONFIG_MACH_C1) && defined(CONFIG_TARGET_LOCALE_KOR))
u8 data[14] = { 0, };
int ret;
unsigned char data_sensitivity = 0x40;
i2c_touchkey_write(tkey_i2c->client, &data_sensitivity, 1);
mdelay(10);
ret = i2c_touchkey_read(tkey_i2c->client, KEYCODE_REG, data, 14);
printk(KERN_DEBUG "called %s data[11] =%d\n", __func__, data[11]);
back_sensitivity = data[11];
#else
u8 data[10];
int ret;
printk(KERN_DEBUG "called %s\n", __func__);
ret = i2c_touchkey_read(tkey_i2c->client, KEYCODE_REG, data, 10);
back_sensitivity = data[9];
#endif
return sprintf(buf, "%d\n", back_sensitivity);
}
static void notification_off(struct work_struct *notification_off_work)
{
int status;
/* do nothing if there is no active notification */
if (led_on != 1 || touchkey_enable != 1)
return;
/* we have timed out, turn the lights off */
/* disable the regulators */
touchkey_led_ldo_on(0); /* "touch_led" regulator */
touchkey_ldo_on(0); /* "touch" regulator */
/* turn off the backlight */
#ifdef CONFIG_TARGET_CM_KERNEL
status = 2; /* light off */
#else
status = 0; /* light off */
#endif
i2c_touchkey_write((u8 *)&status, 1);
touchkey_enable = 0;
#ifdef CONFIG_TARGET_CM_KERNEL
led_on = 0;
#else
led_on = -1;
#endif
/* we were using a wakelock, unlock it */
if (wake_lock_active(&led_wake_lock)) {
wake_unlock(&led_wake_lock);
}
return;
}
static void cypress_touchkey_early_resume(struct early_suspend *h)
{
struct cypress_touchkey_devdata *devdata =
container_of(h, struct cypress_touchkey_devdata, early_suspend);
printk("%s\n",__FUNCTION__);
u8 data[6];
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
#if 0
if (i2c_touchkey_write_byte(devdata, devdata->backlight_on)) {
devdata->is_dead = true;
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
dev_err(&devdata->client->dev, "%s: touch keypad not responding"
" to commands, disabling\n", __func__);
return;
}
#endif
devdata->is_dead = false;
enable_irq(devdata->client->irq);
devdata->is_powering_on = false;
msleep(50);
touchkey_auto_calibration(1/*on*/);
msleep(200);
if(touch_key_led_on_off== 1)
i2c_touchkey_write(devdata, &devdata->backlight_on, 1);
}
static ssize_t set_touchkey_autocal_testmode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct touchkey_i2c *tkey_i2c = dev_get_drvdata(dev);
int count = 0;
u8 set_data;
int on_off;
if (sscanf(buf, "%d\n", &on_off) == 1) {
printk(KERN_ERR "[TouchKey] Test Mode : %d\n", on_off);
if (on_off == 1) {
set_data = 0x40;
count = i2c_touchkey_write(tkey_i2c->client,
&set_data, 1);
} else {
// tkey_i2c->pdata->power_on(0);
touchkey_led_on(tkey_i2c, 0);
msleep(50);
// tkey_i2c->pdata->power_on(1);
touchkey_led_on(tkey_i2c, 1);
msleep(50);
#if defined(TK_HAS_AUTOCAL)
touchkey_autocalibration(tkey_i2c);
#endif
}
} else {
printk(KERN_ERR "[TouchKey] touch_led_brightness Error\n");
}
return count;
}
static void melfas_touchkey_early_resume(struct early_suspend *h)
{
set_touchkey_debug('R');
printk(KERN_DEBUG "[TKEY] melfas_touchkey_early_resume\n");
if (touchkey_enable < 0) {
printk("[TKEY] %s touchkey_enable: %d\n", __FUNCTION__, touchkey_enable);
return;
}
tkey_vdd_enable(1);
gpio_request(GPIO_TOUCHKEY_SCL, "TKEY_SCL");
gpio_direction_input(GPIO_TOUCHKEY_SCL);
gpio_request(GPIO_TOUCHKEY_SDA, "TKEY_SDA");
gpio_direction_input(GPIO_TOUCHKEY_SDA);
init_hw();
if(touchled_cmd_reversed) {
touchled_cmd_reversed = 0;
msleep(100);
if(!touchkey_enable )
touchkey_enable = 1;
i2c_touchkey_write(&touchkey_led_status, 1);
printk("[TKEY] LED RESERVED !! LED returned on touchkey_led_status = %d\n", touchkey_led_status);
}
if (get_hw_rev() >=0x02){
tkey_led_vdd_enable(1);
}
enable_irq(IRQ_TOUCHKEY_INT);
touchkey_enable = 1;
msleep(50);
touchkey_auto_calibration(1/*on*/);
}
void touchscreen_state_report(int state)
{
static const int ledCmd[] = {TK_CMD_LED_ON, TK_CMD_LED_OFF};
if (touch_led_disabled == 0) {
if (state == 1) {
if(touchkey_led_status == TK_CMD_LED_OFF) {
pr_debug("[Touchkey] %s: enable touchleds\n", __func__);
i2c_touchkey_write(tkey_i2c_local->client, (u8 *) &ledCmd[0], 1);
touchkey_led_status = TK_CMD_LED_ON;
} else {
if (timer_pending(&touch_led_timer) == 1) {
pr_debug("[Touchkey] %s: mod_timer\n", __func__);
mod_timer(&touch_led_timer, jiffies + (HZ * touch_led_timeout));
}
}
} else if (state == 0) {
if (timer_pending(&touch_led_timer) == 1) {
pr_debug("[Touchkey] %s: mod_timer\n", __func__);
mod_timer(&touch_led_timer, jiffies + (HZ * touch_led_timeout));
} else if (touchkey_led_status == TK_CMD_LED_ON){
pr_debug("[Touchkey] %s: add_timer\n", __func__);
touch_led_timer.expires = jiffies + (HZ * touch_led_timeout);
add_timer(&touch_led_timer);
}
}
}
}
static int __init touchkey_init(void)
{
int ret = 0;
int rc;
#ifdef TEST_JIG_MODE
unsigned char get_touch = 0x40;
#endif
printk(KERN_INFO "[TouchKey] %s\n", __func__ );
rc = gpio_request(TOUCHKEY_INT, "touchkey_int");
if (rc < 0) {
printk(KERN_ERR "unable to request GPIO pin %d\n", TOUCHKEY_INT);
}
gpio_direction_input(TOUCHKEY_INT);
gpio_direction_output( TOUCHKEY_SCL , 1 );
gpio_direction_output( TOUCHKEY_SDA , 1 );
ret = i2c_add_driver(&touchkey_i2c_driver);
if (ret)
{
printk(KERN_ERR "[TouchKey] registration failed, module not inserted.ret= %d\n", ret);
}
#ifdef TEST_JIG_MODE
i2c_touchkey_write(tkey_i2c->client, &get_touch, 1);
#endif
return ret;
}
static int __init touchkey_init(void)
{
int ret = 0;
#if defined(CONFIG_MACH_M0)
if (system_rev < TOUCHKEY_FW_UPDATEABLE_HW_REV) {
printk(KERN_DEBUG "[Touchkey] Doesn't support this board rev %d\n",
system_rev);
return 0;
}
#elif defined(CONFIG_MACH_C1)
if (system_rev < TOUCHKEY_FW_UPDATEABLE_HW_REV) {
printk(KERN_DEBUG "[Touchkey] Doesn't support this board rev %d\n",
system_rev);
return 0;
}
#endif
#ifdef TEST_JIG_MODE
unsigned char get_touch = 0x40;
#endif
ret = i2c_add_driver(&touchkey_i2c_driver);
if (ret) {
printk(KERN_ERR
"[TouchKey] registration failed, module not inserted.ret= %d\n",
ret);
}
#ifdef TEST_JIG_MODE
i2c_touchkey_write(tkey_i2c->client, &get_touch, 1);
#endif
return ret;
}
static void cypress_touchkey_early_resume(struct early_suspend *h)
{
struct cypress_touchkey_devdata *devdata =
container_of(h, struct cypress_touchkey_devdata, early_suspend);
msleep(1);
if(devdata->pdata->touchkey_onoff)
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
#if 0
if (i2c_touchkey_write_byte(devdata, devdata->backlight_on)) {
devdata->is_dead = true;
if(devdata->pdata->touchkey_onoff)
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
dev_err(&devdata->client->dev, "%s: touch keypad not responding"
" to commands, disabling\n", __func__);
return;
}
#endif
devdata->is_dead = false;
enable_irq(devdata->client->irq);
devdata->is_powering_on = false;
if (devdata->is_delay_led_on){
int ret;
msleep(30); // touch power on time
ret = i2c_touchkey_write(devdata, &devdata->backlight_on, 1);
dev_err(&devdata->client->dev,"%s: Touch Key led ON ret = %d\n",__func__, ret);
}
devdata->is_delay_led_on = false;
}
static ssize_t touch_sensitivity_control(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret;
unsigned char data = 0x40;
ret = i2c_touchkey_write(devdata, &data, 1);
return ret;
}
static ssize_t touch_sensitivity_control(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct touchkey_i2c *tkey_i2c = dev_get_drvdata(dev);
unsigned char data = 0x40;
i2c_touchkey_write(tkey_i2c->client, &data, 1);
return size;
}
static ssize_t touch_led_control(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
struct cypress_touchkey_devdata *devdata = dev_get_drvdata(dev);
int ret;
if (devdata && !devdata->is_powering_on) {
if (strncmp(buf, "1", 1) == 0)
ret = i2c_touchkey_write(devdata, &devdata->backlight_on, 1);
else
ret = i2c_touchkey_write(devdata, &devdata->backlight_off, 1);
if (ret)
dev_err(dev, "%s: touchkey led i2c failed\n", __func__);
}
return size;
}
static ssize_t touch_led_control(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
u8 data;
if(user_press_on)
return size;
sscanf(buf, "%hhu", &data);
i2c_touchkey_write(&data, 1); // LED on(data=1) or off(data=2)
return size;
}
static int sec_touchkey_late_resume(struct early_suspend *h)
{
struct touchkey_i2c *tkey_i2c =
container_of(h, struct touchkey_i2c, early_suspend);
#ifdef TEST_JIG_MODE
unsigned char get_touch = 0x40;
#endif
set_touchkey_debug('R');
pr_debug("[TouchKey] sec_touchkey_late_resume\n");
/* enable ldo11 */
tkey_i2c->pdata->power_on(1);
if (touchkey_enable < 0) {
pr_debug("[TouchKey] ---%s---touchkey_enable: %d\n",
__func__, touchkey_enable);
return 0;
}
msleep(50);
tkey_i2c->pdata->led_power_on(1);
touchkey_enable = 1;
#if defined(TK_HAS_AUTOCAL)
touchkey_autocalibration(tkey_i2c);
#endif
if (touchled_cmd_reversed) {
touchled_cmd_reversed = 0;
i2c_touchkey_write(tkey_i2c->client,
(u8 *) &touchkey_led_status, 1);
pr_debug("[Touchkey] LED returned on\n");
}
#ifdef TEST_JIG_MODE
i2c_touchkey_write(tkey_i2c->client, &get_touch, 1);
#endif
enable_irq(tkey_i2c->irq);
return 0;
}
static ssize_t touch_sensitivity_control(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct touchkey_i2c *tkey_i2c = dev_get_drvdata(dev);
unsigned char data = 0x40;
i2c_touchkey_write(tkey_i2c->client, &data, 1);
#if defined(CONFIG_MACH_SUPERIOR_KOR_SKT)
msleep(20);
#endif
return size;
}
static ssize_t touch_led_control(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
unsigned char data;
if(sscanf(buf, "%d\n", &data) == 1) {
printk("touch_led_control: %d \n", data);
i2c_touchkey_write(&data, 1);
}
else
printk("touch_led_control Error\n");
return size;
}
void touch_led_timedout_work(struct work_struct *work)
{
struct touchkey_i2c *tkey_i2c = container_of(work, struct touchkey_i2c, work);
static const int ledCmd[] = {TK_CMD_LED_ON, TK_CMD_LED_OFF};
if (touch_led_timeout != 0)
{
pr_debug("[Touchkey] %s: disabling touchled\n", __func__);
i2c_touchkey_write(tkey_i2c->client, (u8 *) &ledCmd[1], 1);
touchkey_led_status = TK_CMD_LED_OFF;
}
}
static int melfas_touchkey_late_resume(struct early_suspend *h)
{
set_touchkey_debug('R');
printk(KERN_DEBUG "[TouchKey] melfas_touchkey_late_resume\n");
/* enable ldo20 */
touchkey_ldo_on(1);
msleep(100);
#ifdef WHY_DO_WE_NEED_THIS
/* clear interrupt */
if (readl(gpio_pend_mask_mem) & (0x1 << 1)) {
writel(readl(gpio_pend_mask_mem) | (0x1 << 1),
gpio_pend_mask_mem);
}
#endif
touchkey_enable = 1;
enable_irq(IRQ_TOUCH_INT);
if(touchled_cmd_reversed) {
touchled_cmd_reversed = 0;
i2c_touchkey_write(&touchkey_led_status, 1);
printk("LED returned on..\n");
}
#if 1
msleep(100);
touchkey_autocalibration();
#endif
#ifdef TEST_JIG_MODE
i2c_touchkey_write(&get_touch, 1);
#endif
return 0;
}
static void melfas_touchkey_switch_early_resume(int FILP_STATE,int firmup_onoff){
unsigned char data1 = 0x01;
u8 led_bright[2]= {LED_BRIGHT_BIT,LED_BRIGHT};
printk(KERN_DEBUG "[TKEY] switch_early_resume +++\n");
mutex_lock(&melfas_tsk_lock);
if (((Flip_status == FLIP_OPEN) && (!firmup_onoff)) || touchkey_driver == NULL) {
printk(KERN_DEBUG "[TKEY] FLIP_OPEN ---\n");
goto end;
}
touchkey_pmic_control(1);
gpio_set_value(_3_TOUCH_SDA_28V, 1);
gpio_set_value(_3_TOUCH_SCL_28V, 1);
msleep(100);
#ifdef USE_IRQ_FREE
msleep(50);
printk("%s, %d\n",__func__, __LINE__);
err = request_threaded_irq(touchkey_driver->client->irq, NULL, touchkey_interrupt,
IRQF_DISABLED | IRQF_TRIGGER_LOW | IRQF_ONESHOT, "touchkey_int", NULL);
if (err) {
printk(KERN_ERR "%s Can't allocate irq .. %d\n", __FUNCTION__, err);
}
#endif
if(!firmup_onoff)
enable_irq(touchkey_driver->client->irq);
touchkey_enable = 1;
ssuepend =0;
if (led_onoff){
i2c_touchkey_write(led_bright, 2);
i2c_touchkey_write(&data1, 1);
}
end:
mutex_unlock(&melfas_tsk_lock);
printk(KERN_DEBUG "[TKEY] switch_early_resume---\n");
}
static ssize_t touch_led_control(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
u8 data = 0x10;
if (sscanf(buf, "%d\n", &data) == 1) {
if (!tempdata->is_powering_on) {
//printk(KERN_DEBUG "touch_led_control: %d \n", data);
i2c_touchkey_write(tempdata, &data, sizeof(u8));
}
} else
printk("touch_led_control Error\n");
return size;
}
static void melfas_touchkey_early_suspend(struct early_suspend *h)
{
unsigned char data = 0x02;
printk(KERN_ERR"[TKEY] early_suspend +++\n");
mutex_lock(&melfas_tsk_lock);
if(user_press_on == 1) {
input_report_key(touchkey_driver->input_dev, TOUCHKEY_KEYCODE_MENU, 0);
input_sync(touchkey_driver->input_dev);
printk("[TKEY] force release MENU\n");
}
else if(user_press_on == 2) {
input_report_key(touchkey_driver->input_dev, TOUCHKEY_KEYCODE_HOME, 0);
input_sync(touchkey_driver->input_dev);
printk("[TKEY] force release HOME\n");
}
else if(user_press_on == 3) {
input_report_key(touchkey_driver->input_dev, TOUCHKEY_KEYCODE_BACK, 0);
input_sync(touchkey_driver->input_dev);
printk("[TKEY] force release BACK\n");
}
user_press_on = 0;
if ((touchkey_enable == 0 && is_suspending == 1) || ssuepend == 1) {
printk(KERN_ERR"[TKEY] already suspend %d,%d,%d---\n",touchkey_enable,is_suspending,ssuepend);
is_suspending = 1;
goto end;
}
touchkey_enable = 0;
is_suspending = 1;
ssuepend = 0;
led_onoff =0;
if(touchkey_dead)
{
printk(KERN_ERR "touchkey died after ESD");
goto end;
}
i2c_touchkey_write(&data, 1); /*Key LED force off*/
disable_irq(touchkey_driver->client->irq);
gpio_set_value(_3_TOUCH_SDA_28V, 0);
gpio_set_value(_3_TOUCH_SCL_28V, 0);
touchkey_pmic_control(0);
msleep(30);
end:
mutex_unlock(&melfas_tsk_lock);
printk(KERN_ERR"[TKEY] early_suspend ---\n");
}