static ssize_t touch_autocal_testmode(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
struct cypress_touchkey_info *info = dev_get_drvdata(dev);
int count = 0;
int on_off;
if (sscanf(buf, "%2d\n", &on_off) == 1) {
printk(KERN_ERR "[TouchKey] Test Mode : %d\n", on_off);
if (on_off == 1) {
count = i2c_smbus_write_byte_data(info->client,
CYPRESS_GEN, CYPRESS_DATA_UPDATE);
}
} else {
if (info->pdata->gpio_led_en) {
cypress_touchkey_con_hw(info, false);
msleep(50);
cypress_touchkey_con_hw(info, true);
msleep(50);
}
cypress_touchkey_auto_cal(info);
}
return count;
}
static ssize_t touch_autocal_testmode(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
int count = 0;
int on_off;
if (sscanf(buf, "%d\n", &on_off) == 1) {
printk(KERN_DEBUG "[TouchKey] Test Mode : %d \n", on_off);
if (on_off == 1) {
count = i2c_smbus_write_byte_data(info->client,
CYPRESS_GEN, CYPRESS_DATA_UPDATE);
} else {
cypress_touchkey_con_hw(info, false);
msleep(50);
cypress_touchkey_con_hw(info, true);
msleep(150);
cypress_touchkey_auto_cal(info);
}
} else
printk(KERN_DEBUG "[TouchKey] touch_led_brightness Error\n");
return count;
}
static void touch_FW_update_func(struct work_struct *work)
{
int count = 0;
int retry = NUM_OF_RETRY_UPDATE;
u8 data;
touchkey_update_status = 1;
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_DEBUG "[TouchKey] %s start... !\n", __func__);
#else
;
#endif
disable_irq(info->irq);
while (retry--) {
if (ISSP_main() == 0) {
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_DEBUG "[TOUCHKEY] Update success!\n");
#else
;
#endif
cypress_touchkey_con_hw(info, true);
msleep(200);
enable_irq(info->irq);
data = i2c_smbus_read_byte_data(info->client, CYPRESS_FW_VER);
info->fw_ver = data;
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_DEBUG "[TouchKey] %s : FW Ver 0x%02x\n", __func__,
data);
#else
;
#endif
cypress_thd_change(vbus_state);
cypress_touchkey_auto_cal(info);
touchkey_update_status = 0;
count = i2c_smbus_write_byte_data(info->client,
CYPRESS_GEN, CYPRESS_DATA_UPDATE);
return;
}
cypress_touchkey_con_hw(info, false);
msleep(300);
cypress_touchkey_con_hw(info, true);
msleep(200);
}
touchkey_update_status = -1;
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_DEBUG "[TOUCHKEY]Touchkey_update fail\n");
#else
;
#endif
return;
}
static int touch_FW_update(void)
{
int count = 0;
int retry = NUM_OF_RETRY_UPDATE;
touchkey_update_status = 1;
while (retry--) {
printk(KERN_DEBUG "[TOUCHKEY] Updating... !\n");
msleep(300);
if (ISSP_main() == 0) {
printk(KERN_DEBUG "[TOUCHKEY] Update success!\n");
touchkey_update_status = 0;
count = 1;
break;
}
printk(KERN_DEBUG "[TOUCHKEY] Touchkey_update failed... retry...\n");
}
if (retry <= 0) {
cypress_touchkey_con_hw(info, false);
count = 0;
printk(KERN_DEBUG "[TOUCHKEY]Touchkey_update fail\n");
touchkey_update_status = -1;
msleep(300);
}
msleep(500);
return count;
}
static int cypress_touchkey_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct cypress_touchkey_info *info = i2c_get_clientdata(client);
int ret = 0;
cypress_power_onoff(info, 1);
if (info->pdata->gpio_led_en)
cypress_touchkey_con_hw(info, true);
msleep(50);
cypress_touchkey_auto_cal(info);
if (touchled_cmd_reversed) {
touchled_cmd_reversed = 0;
i2c_smbus_write_byte_data(info->client,
CYPRESS_GEN, touchkey_led_status);
printk(KERN_DEBUG "LED returned on\n");
}
enable_irq(info->irq);
info->is_powering_on = false;
return ret;
}
static int cypress_touchkey_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct cypress_touchkey_info *info = i2c_get_clientdata(client);
int ret = 0;
FUNC_CALLED;
disable_irq(info->irq);
cypress_touchkey_con_hw(info, false);
return ret;
}
static int cypress_touchkey_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct cypress_touchkey_info *info = i2c_get_clientdata(client);
int ret = 0;
info->is_powering_on = true;
disable_irq(info->irq);
if (info->pdata->gpio_led_en)
cypress_touchkey_con_hw(info, false);
cypress_power_onoff(info, 0);
return ret;
}
static ssize_t touch_update_write(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct cypress_touchkey_info *info = dev_get_drvdata(dev);
int count = 0;
int retry = NUM_OF_RETRY_UPDATE;
char buff[16] = {0};
u8 data;
info->touchkey_update_status = 1;
dev_err(dev, "[TOUCHKEY] touch_update_write!\n");
disable_irq(info->irq);
while (retry--) {
if (ISSP_main() == 0) {
dev_err(&info->client->dev,
"[TOUCHKEY] Update success!\n");
msleep(50);
cypress_touchkey_auto_cal(info);
info->touchkey_update_status = 0;
count = 1;
enable_irq(info->irq);
break;
}
dev_err(&info->client->dev,
"[TOUCHKEY] Touchkey_update failed... retry...\n");
}
if (retry <= 0) {
if (info->pdata->gpio_led_en)
cypress_touchkey_con_hw(info, false);
msleep(300);
count = 0;
dev_err(&info->client->dev, "[TOUCHKEY]Touchkey_update fail\n");
info->touchkey_update_status = -1;
return count;
}
msleep(500);
data = i2c_smbus_read_byte_data(info->client, CYPRESS_FW_VER);
count = snprintf(buff, sizeof(buff), "0x%02x\n", data);
dev_err(&info->client->dev,
"[TouchKey] %s : FW Ver 0x%02x\n", __func__, data);
return count;
}
static int cypress_touchkey_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct cypress_touchkey_info *info = i2c_get_clientdata(client);
int ret = 0;
cypress_touchkey_con_hw(info, true);
msleep(110);
cypress_thd_change(vbus_state);
cypress_touchkey_auto_cal(info);
FUNC_CALLED;
enable_irq(info->irq);
return ret;
}
/*
static int cypress_touchkey_led_on(struct cypress_touchkey_info *info)
{
u8 buf = CYPRESS_LED_ON;
int ret;
ret = i2c_smbus_write_byte_data(info->client, CYPRESS_GEN, buf);
return ret;
}
static int cypress_touchkey_led_off(struct cypress_touchkey_info *info)
{
u8 buf = CYPRESS_LED_OFF;
int ret;
ret = i2c_smbus_write_byte_data(info->client, CYPRESS_GEN, buf);
return ret;
}
*/
static int __devinit cypress_touchkey_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct input_dev *input_dev;
int ret = 0;
int i;
u8 buf[2] = {0,};
#ifdef TOUCHKEY_UPDATE_ONBOOT
u8 mod_ver;
u8 fw_ver;
#endif
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
return -EIO;
info = kzalloc(sizeof(struct cypress_touchkey_info), GFP_KERNEL);
if (!info) {
dev_err(&client->dev, "fail to memory allocation.\n");
goto err_mem_alloc;
}
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&client->dev, "fail to allocate input device.\n");
goto err_input_dev_alloc;
}
info->client = client;
info->input_dev = input_dev;
info->pdata = client->dev.platform_data;
info->irq = client->irq;
memcpy(info->keycode, cypress_touchkey_keycode, ARRAY_SIZE(cypress_touchkey_keycode));
snprintf(info->phys, sizeof(info->phys), "%s/input0", dev_name(&client->dev));
input_dev->name = "sec_touchkey";
input_dev->phys = info->phys;
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
set_bit(EV_SYN, input_dev->evbit);
set_bit(EV_KEY, input_dev->evbit);
set_bit(EV_LED, input_dev->evbit);
set_bit(LED_MISC, input_dev->ledbit);
for (i = 0; i < ARRAY_SIZE(info->keycode); i++) {
set_bit(info->keycode[i], input_dev->keybit);
}
input_set_drvdata(input_dev, info);
ret = input_register_device(input_dev);
if (ret) {
dev_err(&client->dev, "failed to register input dev (%d).\n",
ret);
goto err_reg_input_dev;
}
do_gettimeofday(&info->start);
i2c_set_clientdata(client, info);
cypress_touchkey_con_hw(info, true);
#ifdef TOUCHKEY_UPDATE_ONBOOT
if (system_rev >= JANICE_R0_3) {
mod_ver = JANICE_TOUCHKEY_HW03_MOD_VER;
fw_ver = JANICE_TOUCHKEY_M_04_FW_VER;
} else {
mod_ver = JANICE_TOUCHKEY_HW02_MOD_VER;
fw_ver = JANICE_TOUCHKEY_M_03_FW_VER;
}
#endif
ret = i2c_smbus_read_i2c_block_data(info->client, CYPRESS_FW_VER,
ARRAY_SIZE(buf), buf);
if (ret != ARRAY_SIZE(buf))
dev_err(&client->dev, "failed to check FW ver.\n");
else {
info->fw_ver = buf[0];
info->mod_ver = buf[1];
#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
printk(KERN_DEBUG "[TouchKey] %s : Mod Ver 0x%02x\n", __func__,
info->mod_ver);
printk(KERN_DEBUG "[TouchKey] FW mod 0x%02x\n",
info->fw_ver);
#endif
#ifdef TOUCHKEY_UPDATE_ONBOOT
if ((info->mod_ver == mod_ver) && (info->fw_ver < fw_ver))
touch_FW_update();
#endif
}
cypress_thd_change(vbus_state);
cypress_touchkey_auto_cal(info);
#ifdef CONFIG_HAS_EARLYSUSPEND
info->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
info->early_suspend.suspend = cypress_touchkey_early_suspend;
info->early_suspend.resume = cypress_touchkey_late_resume;
register_early_suspend(&info->early_suspend);
#endif /* CONFIG_HAS_EARLYSUSPEND */
info->key_wq = create_singlethread_workqueue("cypress_key_wq");
INIT_WORK(&info->key_work, cypress_touchkey_work);
touchkey_wq = create_singlethread_workqueue("cypress_tsk_update_wq");
#ifdef CONFIG_LEDS_CLASS
mutex_init(&info->touchkey_mutex);
info->led_wq = create_singlethread_workqueue("cypress_touchkey");
INIT_WORK(&info->led_work, cypress_touchkey_led_work);
info->leds.name = TOUCHKEY_BACKLIGHT;
info->leds.brightness = LED_FULL;
info->leds.max_brightness = LED_FULL;
info->leds.brightness_set = cypress_touchkey_brightness_set;
info->current_status = 1;
ret = led_classdev_register(&client->dev, &info->leds);
if (ret) {
goto err_req_irq;
}
#endif
ret = request_threaded_irq(client->irq, NULL, cypress_touchkey_interrupt,
IRQF_TRIGGER_RISING, client->dev.driver->name, info);
if (ret < 0) {
dev_err(&client->dev, "Failed to request IRQ %d (err: %d).\n", client->irq, ret);
goto err_req_irq;
}
FUNC_CALLED;
return 0;
err_req_irq:
#ifdef CONFIG_LEDS_CLASS
destroy_workqueue(info->led_wq);
#endif
destroy_workqueue(info->key_wq);
destroy_workqueue(touchkey_wq);
input_unregister_device(input_dev);
input_dev = NULL;
err_reg_input_dev:
err_input_dev_alloc:
input_free_device(input_dev);
kfree(info);
err_mem_alloc:
return ret;
}
static int __devinit cypress_touchkey_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct cypress_touchkey_platform_data *pdata =
client->dev.platform_data;
struct cypress_touchkey_info *info;
struct input_dev *input_dev;
int ret = 0;
int i;
// int retry = NUM_OF_RETRY_UPDATE;
int ic_fw_ver;
int error;
struct device *sec_touchkey;
printk("[TKEY] %s _ %d\n",__func__,__LINE__);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
return -EIO;
#ifdef CONFIG_OF
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct cypress_touchkey_platform_data),
GFP_KERNEL);
if (!pdata) {
dev_info(&client->dev, "Failed to allocate memory\n");
return -ENOMEM;
}
error = cypress_parse_dt(&client->dev, pdata);
if (error)
return error;
} else
pdata = client->dev.platform_data;
cypress_request_gpio(pdata);
#endif
info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info) {
dev_err(&client->dev, "fail to memory allocation.\n");
goto err_mem_alloc;
}
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&client->dev, "fail to allocate input device.\n");
goto err_input_dev_alloc;
}
client->irq = gpio_to_irq(pdata->gpio_int);
info->client = client;
info->input_dev = input_dev;
info->pdata = pdata;
info->irq = client->irq;
info->touchkey_update_status = 0;
input_dev->name = "sec_touchkey";
input_dev->phys = info->phys;
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
info->is_powering_on = true;
cypress_power_onoff(info, 1);
msleep(50);
set_bit(EV_SYN, input_dev->evbit);
set_bit(EV_KEY, input_dev->evbit);
set_bit(EV_LED, input_dev->evbit);
set_bit(LED_MISC, input_dev->ledbit);
atomic_set(&info->keypad_enable, 1);
for (i = 0; i < pdata->keycodes_size; i++) {
info->keycode[i] = pdata->touchkey_keycode[i];
set_bit(info->keycode[i], input_dev->keybit);
}
input_set_drvdata(input_dev, info);
mutex_init(&info->touchkey_mutex);
ret = input_register_device(input_dev);
if (ret) {
dev_err(&client->dev, "[TOUCHKEY] failed to register input dev (%d).\n",
ret);
goto err_reg_input_dev;
}
i2c_set_clientdata(client, info);
if (info->pdata->gpio_led_en) {
ret = gpio_request(info->pdata->gpio_led_en,
"gpio_touchkey_led");
if (ret < 0) {
dev_err(&client->dev,
"gpio_touchkey_led gpio_request is failed\n");
goto err_gpio_request;
}
gpio_tlmm_config(GPIO_CFG(info->pdata->gpio_led_en, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), 1);
cypress_touchkey_con_hw(info, true);
}
#ifdef USE_OPEN_CLOSE
input_dev->open = cypress_input_open;
input_dev->close = cypress_input_close;
#endif
dev_info(&info->client->dev, "gpio_to_irq IRQ %d\n",
client->irq);
ret = request_threaded_irq(client->irq, NULL,
cypress_touchkey_interrupt,
IRQF_TRIGGER_FALLING, client->dev.driver->name, info);
if (ret < 0) {
dev_err(&client->dev, "Failed to request IRQ %d (err: %d).\n",
client->irq, ret);
goto err_req_irq;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
info->early_suspend.suspend = cypress_touchkey_early_suspend;
info->early_suspend.resume = cypress_touchkey_late_resume;
register_early_suspend(&info->early_suspend);
#endif /* CONFIG_HAS_EARLYSUSPEND */
info->led_wq = create_singlethread_workqueue("cypress_touchkey");
INIT_WORK(&info->led_work, cypress_touchkey_led_work);
info->leds.name = TOUCHKEY_BACKLIGHT;
info->leds.brightness = LED_FULL;
info->leds.max_brightness = LED_FULL;
info->leds.brightness_set = cypress_touchkey_brightness_set;
ret = led_classdev_register(&client->dev, &info->leds);
if (ret)
goto err_req_irq;
#if defined(CONFIG_LCD_CONNECTION_CHECK) //for SMD test
if (is_lcd_attached() == 0) {
disable_irq(client->irq);
printk("[TSK] %s : is_lcd_attached()=0 \n",__func__);
}
else{
#endif
msleep(20);
ic_fw_ver = i2c_smbus_read_byte_data(client, CYPRESS_FW_VER);
dev_err(&client->dev, "Touchkey FW Version: 0x%02x\n", ic_fw_ver);
#if defined(CONFIG_MACH_M2_ATT) || defined(CONFIG_MACH_M2_DCM) \
|| defined(CONFIG_MACH_M2_SKT) || defined(CONFIG_MACH_M2_KDI)
dev_err(&client->dev, "Touchkey FW Version: 0x%02x, system_rev: %x\n",
ic_fw_ver, system_rev);
if (0 /* ic_fw_ver < BIN_FW_VERSION */) {
dev_err(&client->dev, "[TOUCHKEY] touchkey_update Start!!\n");
disable_irq(client->irq);
while (retry--) {
if (ISSP_main() == 0) {
dev_err(&client->dev, "[TOUCHKEY] Update success!\n");
enable_irq(client->irq);
break;
}
dev_err(&client->dev,
"[TOUCHKEY] Touchkey_update failed... retry...\n");
}
if (retry <= 0) {
if (info->pdata->gpio_led_en)
cypress_touchkey_con_hw(info, false);
msleep(300);
dev_err(&client->dev, "[TOUCHKEY]Touchkey_update fail\n");
}
msleep(500);
ic_fw_ver = i2c_smbus_read_byte_data(info->client,
CYPRESS_FW_VER);
dev_err(&client->dev,
"[TouchKey] %s : FW Ver 0x%02x\n", __func__, ic_fw_ver);
} else {
dev_err(&client->dev, "[TouchKey] FW update does not need!\n");
}
#endif
cypress_touchkey_auto_cal(info);
#if defined(CONFIG_LCD_CONNECTION_CHECK) //for SMD test
}
#endif
sec_touchkey = device_create(sec_class, NULL, 0, NULL, "sec_touchkey");
if (IS_ERR(sec_touchkey)) {
pr_err("Failed to create device(sec_touchkey)!\n");
goto err_sysfs;
}
dev_set_drvdata(sec_touchkey, info);
if (device_create_file(sec_touchkey,
&dev_attr_keypad_enable) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_keypad_enable.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_firm_update_status) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_firm_update.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_firm_update) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_firm_update.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_firm_version_panel) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_firm_version_panel.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_firm_version_phone) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_firm_version_phone.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_brightness) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_brightness.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touch_sensitivity) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_sensitivity.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_menu) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_menu.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_back) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_back.attr.name);
goto err_sysfs;
}
#ifdef HOME_KEY_USE
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_home) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_home.attr.name);
goto err_sysfs;
}
#endif
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_raw_data0) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_raw_data0.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_raw_data1) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_raw_data1.attr.name);
goto err_sysfs;
}
#ifdef HOME_KEY_USE
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_raw_data2) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_raw_data2.attr.name);
goto err_sysfs;
}
#endif
if (device_create_file(sec_touchkey, &dev_attr_touchkey_idac0) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_idac0.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey, &dev_attr_touchkey_idac1) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_idac1.attr.name);
goto err_sysfs;
}
#ifdef HOME_KEY_USE
if (device_create_file(sec_touchkey, &dev_attr_touchkey_idac2) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_idac2.attr.name);
goto err_sysfs;
}
#endif
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_threshold) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_threshold.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_autocal_start) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_touchkey_autocal_start.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_autocal_enable) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_autocal_enable.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_autocal_stat) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_autocal_stat.attr.name);
goto err_sysfs;
}
if (device_create_file(sec_touchkey,
&dev_attr_touchkey_brightness_level) < 0) {
printk(KERN_ERR "Failed to create device file(%s)!\n",
dev_attr_touchkey_brightness_level.attr.name);
goto err_sysfs;
}
info->is_powering_on = false;
return 0;
err_req_irq:
err_gpio_request:
input_unregister_device(input_dev);
err_reg_input_dev:
input_free_device(input_dev);
input_dev = NULL;
mutex_destroy(&info->touchkey_mutex);
err_input_dev_alloc:
kfree(info);
err_sysfs:
return -ENXIO;
err_mem_alloc:
return ret;
}