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 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*/);
}
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 int i2c_touchkey_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct device *dev = &client->dev;
struct input_dev *input_dev;
int err = 0;
int touch_auto_calibration_on_off = 0;
u8 data[6];
printk("[TKEY] melfas i2c_touchkey_probe\n");
touchkey_driver =
kzalloc(sizeof(struct i2c_touchkey_driver), GFP_KERNEL);
if (touchkey_driver == NULL) {
dev_err(dev, "failed to create our state\n");
return -ENOMEM;
}
touchkey_driver->client = client;
touchkey_driver->client->irq = IRQ_TOUCHKEY_INT;
strlcpy(touchkey_driver->client->name, "melfas-touchkey", I2C_NAME_SIZE);
// i2c_set_clientdata(client, state);
input_dev = input_allocate_device();
if (!input_dev)
return -ENOMEM;
touchkey_driver->input_dev = input_dev;
input_dev->name = DEVICE_NAME;
input_dev->phys = "melfas-touchkey/input0";
input_dev->id.bustype = BUS_HOST;
if(get_hw_rev() >= 0x02) {
touchkey_keycode[1] = KEY_MENU;
touchkey_keycode[2] = KEY_BACK;
} else {
touchkey_keycode[1] = KEY_MENU;
touchkey_keycode[2] = KEY_BACK;
}
set_bit(EV_SYN, input_dev->evbit);
set_bit(EV_LED, input_dev->evbit);
set_bit(LED_MISC, input_dev->ledbit);
set_bit(EV_KEY, input_dev->evbit);
set_bit(touchkey_keycode[1], input_dev->keybit);
set_bit(touchkey_keycode[2], input_dev->keybit);
set_bit(touchkey_keycode[3], input_dev->keybit);
set_bit(touchkey_keycode[4], input_dev->keybit);
err = input_register_device(input_dev);
if (err) {
input_free_device(input_dev);
return err;
}
// gpio_pend_mask_mem = ioremap(INT_PEND_BASE, 0x10); //temp ks
INIT_DELAYED_WORK(&touch_resume_work, touchkey_resume_func);
#ifdef CONFIG_HAS_EARLYSUSPEND
// touchkey_driver->early_suspend.level = EARLY_SUSPEND_LEVEL_STOP_DRAWING + 1;
touchkey_driver->early_suspend.suspend = melfas_touchkey_early_suspend;
touchkey_driver->early_suspend.resume = melfas_touchkey_early_resume;
register_early_suspend(&touchkey_driver->early_suspend);
#endif
touchkey_enable = 1;
err= request_threaded_irq( IRQ_TOUCHKEY_INT, NULL, touchkey_interrupt, IRQF_DISABLED , "touchkey_int", NULL);
if (err) {
printk(KERN_ERR "%s Can't allocate irq .. %d\n", __FUNCTION__, err);
return -EBUSY;
}
if (get_hw_rev() >=0x02) {
touchkey_auto_calibration(1/*on*/);
mdelay(30);
i2c_touchkey_read (0x00, data, 6);
touch_auto_calibration_on_off = (data[5] & 0x80)>>7;
printk("[TKEY] after touchkey_auto_calibration result = %d \n",touch_auto_calibration_on_off);
}
static int cypress_touchkey_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct device *dev = &client->dev;
struct input_dev *input_dev;
u8 data[6];
int err;
int cnt;
int touch_auto_calibration_on_off = 0;
#if defined(TOUCH_UPDATE)
int ret;
int retry = 10;
#endif
printk(" cypress_touchkey_probe\n");
gpio_set_value(TOUCHKEY_VDD_EN, 1);
msleep(5);
if (!dev->platform_data) {
dev_err(dev, "%s: Platform data is NULL\n", __func__);
return -EINVAL;
}
devdata = kzalloc(sizeof(*devdata), GFP_KERNEL);
if (devdata == NULL) {
dev_err(dev, "%s: failed to create our state\n", __func__);
return -ENODEV;
}
devdata->client = client;
i2c_set_clientdata(client, devdata);
devdata->pdata = client->dev.platform_data;
if (!devdata->pdata->keycode) {
dev_err(dev, "%s: Invalid platform data\n", __func__);
err = -EINVAL;
goto err_null_keycodes;
}
strlcpy(devdata->client->name, DEVICE_NAME, I2C_NAME_SIZE);
input_dev = input_allocate_device();
if (!input_dev) {
err = -ENOMEM;
goto err_input_alloc_dev;
}
devdata->input_dev = input_dev;
dev_set_drvdata(&input_dev->dev, devdata);
input_dev->name = "sec_touchkey";
input_dev->id.bustype = BUS_HOST;
for (cnt = 0; cnt < devdata->pdata->keycode_cnt; cnt++)
input_set_capability(input_dev, EV_KEY,
devdata->pdata->keycode[cnt]);
err = input_register_device(input_dev);
if (err)
goto err_input_reg_dev;
devdata->is_powering_on = true;
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
msleep(50);
err = i2c_master_recv(client, data, sizeof(data));
if (err < (int)sizeof(data)) {
printk(KERN_DEBUG"[Touchkey] i2c master recv error %d\n", err);
if (err >= 0)
err = -EIO;
dev_err(dev, "%s: error reading hardware version\n", __func__);
goto err_read;
}
dev_info(dev, "%s: hardware rev1 = %#02x, rev2 = %#02x\n", __func__,
data[1], data[2]);
devdata->backlight_on = BACKLIGHT_ON;
devdata->backlight_off = BACKLIGHT_OFF;
devdata->has_legacy_keycode = 1;
#if 0
err = i2c_touchkey_write_byte(devdata, devdata->backlight_on);
if (err) {
dev_err(dev, "%s: touch keypad backlight on failed\n",
__func__);
goto err_backlight_on;
}
#endif
set_irq_type((IRQ_EINT_GROUP18_BASE + 6), IRQ_TYPE_LEVEL_LOW); // IRQ_TYPE_EDGE_FALLING);
s3c_gpio_cfgpin(_3_GPIO_TOUCH_INT, S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(_3_GPIO_TOUCH_INT, S3C_GPIO_PULL_NONE);
if (request_threaded_irq(client->irq, touchkey_interrupt_handler,
touchkey_interrupt_thread, IRQF_TRIGGER_FALLING,
DEVICE_NAME, devdata)) {
dev_err(dev, "%s: Can't allocate irq.\n", __func__);
goto err_req_irq;
}
mdelay(50);
touchkey_auto_calibration(1);
mdelay(200);
i2c_touchkey_read (devdata,0x00, data, 6);
touch_auto_calibration_on_off = (data[5] & 0x80)>>7;
printk("touchkey_auto_calibration=%d,data=%x \n",touch_auto_calibration_on_off,data[5]);
#ifdef CONFIG_HAS_EARLYSUSPEND
devdata->early_suspend.suspend = cypress_touchkey_early_suspend;
devdata->early_suspend.resume = cypress_touchkey_early_resume;
#endif
register_early_suspend(&devdata->early_suspend);
devdata->is_powering_on = false;
#if defined(TOUCH_UPDATE)
ret = misc_register(&touchkey_update_device);
if (ret) {
printk("%s misc_register fail\n", __FUNCTION__);
goto err_misc_reg;
}
dev_set_drvdata(touchkey_update_device.this_device, devdata);
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touch_version) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touch_update) < 0) {
printk("%s device_create_file fail dev_attr_touch_update\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_update.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_brightness) < 0) {
printk("%s device_create_file fail dev_attr_touch_update\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_brightness.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device,
&dev_attr_enable_disable) < 0) {
printk("%s device_create_file fail dev_attr_touch_update\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_enable_disable.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_menu) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_home) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_back) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_search) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touch_sensitivity) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_idac0) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_idac1) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_idac2) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touchkey_idac3) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
touchkey_wq = create_singlethread_workqueue(DEVICE_NAME);
if (!touchkey_wq)
goto err_create_wq;
while (retry--) {
if (get_touchkey_firmware(data) == 0) //melfas need delay for multiple read
break;
}
printk("%s F/W version: 0x%x, Module version:0x%x\n", __FUNCTION__,
data[1], data[2]);
#endif
return 0;
err_create_wq:
#if defined(TOUCH_UPDATE)
misc_deregister(&touchkey_update_device);
#endif
err_misc_reg:
err_req_irq:
err_backlight_on:
err_read:
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
input_unregister_device(input_dev);
goto err_input_alloc_dev;
err_input_reg_dev:
input_free_device(input_dev);
err_input_alloc_dev:
err_null_keycodes:
kfree(devdata);
return err;
}
