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 void cypress_touchkey_early_resume(struct early_suspend *h)
{
struct cypress_touchkey_devdata *devdata =
container_of(h, struct cypress_touchkey_devdata, early_suspend);
_pr_info("%s: resuming...\n", __FUNCTION__);
down(&enable_sem);
#if defined(CONFIG_S5PC110_DEMPSEY_BOARD)
touchkey_ldo_on(1);
#endif
//devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
turn_touchkey( devdata, true );
#if defined(CONFIG_S5PC110_VIBRANTPLUS_BOARD)
if (i2c_touchkey_write_byte(devdata, devdata->backlight_on)) {
devdata->is_dead = true;
//devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
turn_touchkey( devdata, false );
dev_err(&devdata->client->dev, "%s: touch keypad not responding"
" to commands, disabling\n", __func__);
up(&enable_sem);
return;
}
#endif
devdata->is_dead = false;
enable_irq(devdata->client->irq);
devdata->is_powering_on = false;
up(&enable_sem);
_pr_info("%s: resumed\n", __FUNCTION__);
}
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 void cypress_touchkey_early_resume(struct early_suspend *h)
{
struct cypress_touchkey_devdata *devdata =
container_of(h, struct cypress_touchkey_devdata, early_suspend);
// Avoid race condition with LED notification disable
down(&enable_sem);
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
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__);
up(&enable_sem);
return;
}
devdata->is_dead = false;
enable_irq(devdata->client->irq);
#ifdef CONFIG_SAMSUNG_FASCINATE
touch_key_set_int_flt(touch_int_flt_width);
#endif
devdata->is_powering_on = false;
devdata->is_sleeping = false;
up(&enable_sem);
bl_set_timeout();
}
static void cypress_touchkey_early_suspend(struct early_suspend *h)
{
struct cypress_touchkey_devdata *devdata =
container_of(h, struct cypress_touchkey_devdata, early_suspend);
#ifdef CONFIG_TOUCH_WAKE
i2c_touchkey_write_byte(devdata, devdata->backlight_off);
#else
devdata->is_powering_on = true;
if (unlikely(devdata->is_dead))
return;
disable_irq(devdata->client->irq);
#ifdef CONFIG_GENERIC_BLN
/*
* Disallow powering off the touchkey controller
* while a led notification is ongoing
*/
if(!bln_is_ongoing()) {
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
devdata->pdata->touchkey_sleep_onoff(TOUCHKEY_OFF);
}
#else
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
#endif
all_keys_up(devdata);
#endif
}
static void bl_off(struct work_struct *bl_off_work)
{
if (bln_devdata == NULL || unlikely(bln_devdata->is_dead) ||
bln_devdata->is_powering_on || bln_devdata->is_sleeping)
return;
i2c_touchkey_write_byte(bln_devdata, bln_devdata->backlight_off);
}
static void cypress_touchkey_early_resume(struct early_suspend *h)
{
struct cypress_touchkey_devdata *devdata =
container_of(h, struct cypress_touchkey_devdata, early_suspend);
#ifdef CONFIG_TOUCH_WAKE
i2c_touchkey_write_byte(devdata, devdata->backlight_on);
#else
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
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;
}
devdata->is_dead = false;
enable_irq(devdata->client->irq);
devdata->is_powering_on = false;
#endif
}
static void notify_led_on(void) {
if (unlikely(bl_devdata->is_dead))
return;
if (!bl_devdata->is_sleeping)
return;
if (bl_devdata->is_sleeping) {
bl_devdata->pdata->touchkey_sleep_onoff(TOUCHKEY_ON);
bl_devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
}
i2c_touchkey_write_byte(bl_devdata, bl_devdata->backlight_on);
bl_on = 1;
printk(KERN_DEBUG "%s: notification led enabled\n", __FUNCTION__);
}
static void cypress_touchwake_enable(void)
{
touchwakedevdata->pdata->touchkey_onoff(TOUCHKEY_ON);
if (i2c_touchkey_write_byte(touchwakedevdata, touchwakedevdata->backlight_on)) {
touchwakedevdata->is_dead = true;
touchwakedevdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
dev_err(&touchwakedevdata->client->dev, "%s: touch keypad not responding"
" to commands, disabling\n", __func__);
return;
}
touchwakedevdata->is_dead = false;
enable_irq(touchwakedevdata->client->irq);
touchwakedevdata->is_powering_on = false;
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);
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
devdata->is_sleeping = false;
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;
}
devdata->is_dead = false;
enable_irq(devdata->client->irq);
devdata->is_powering_on = false;
mod_timer(&bl_timer, jiffies + msecs_to_jiffies(BACKLIGHT_TIMEOUT));
}
static void notify_led_off(void) {
// Avoid race condition with touch key resume
down(&enable_sem);
if (unlikely(bl_devdata->is_dead) || !bl_on)
goto out;
if (bl_on && bl_timer.expires < jiffies) // Don't disable if there's a timer scheduled
i2c_touchkey_write_byte(bl_devdata, bl_devdata->backlight_off);
bl_devdata->pdata->touchkey_sleep_onoff(TOUCHKEY_OFF);
if (bl_devdata->is_sleeping)
bl_devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
bl_on = 0;
printk(KERN_DEBUG "%s: notification led disabled\n", __FUNCTION__);
out:
up(&enable_sem);
}
static int cypress_touchkey_open(struct input_dev *input_dev)
{
struct device *dev = &input_dev->dev;
struct cypress_touchkey_devdata *devdata = dev_get_drvdata(dev);
u8 data[3];
int ret;
ret = update_firmware(devdata);
if (ret)
goto done;
ret = i2c_master_recv(devdata->client, data, sizeof(data));
if (ret < sizeof(data)) {
if (ret >= 0)
ret = -EIO;
dev_err(dev, "%s: error reading hardware version\n", __func__);
goto done;
}
dev_info(dev, "%s: hardware rev1 = %#02x, rev2 = %#02x\n", __func__,
data[1], data[2]);
set_device_params(devdata, data);
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
ret = i2c_touchkey_write_byte(devdata, devdata->backlight_on);
if (ret) {
dev_err(dev, "%s: touch keypad backlight on failed\n",
__func__);
goto done;
}
done:
input_dev->open = NULL;
return 0;
}
static irqreturn_t touchkey_interrupt_handler(int irq, void *touchkey_devdata)
{
struct cypress_touchkey_devdata *devdata = touchkey_devdata;
#ifdef CONFIG_SAMSUNG_FASCINATE
int i = gpio_get_value(_3_GPIO_TOUCH_INT);
if ((i & 1) || devdata->is_powering_on) {
#else
if (devdata->is_powering_on) {
#endif
dev_dbg(&devdata->client->dev, "%s: ignoring spurious boot "
"interrupt\n", __func__);
return IRQ_HANDLED;
}
return IRQ_WAKE_THREAD;
}
static void notify_led_on(void) {
down(&enable_sem);
if (unlikely(bl_devdata->is_dead) || bl_on)
goto out;
if (bl_devdata->is_sleeping) {
bl_devdata->pdata->touchkey_sleep_onoff(TOUCHKEY_ON);
bl_devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
}
i2c_touchkey_write_byte(bl_devdata, bl_devdata->backlight_on);
bl_on = 1;
printk(KERN_DEBUG "%s: notification led enabled\n", __FUNCTION__);
out:
up(&enable_sem);
}
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;
}
static void enable_touchkey_backlights(void){
i2c_touchkey_write_byte(bln_devdata, bln_devdata->backlight_on);
}
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;
struct cypress_touchkey_devdata *devdata;
u8 data[3];
int err;
int cnt;
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 = DEVICE_NAME;
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]);
devdata->is_powering_on = true;
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
err = i2c_master_recv(client, data, sizeof(data));
if (err < sizeof(data)) {
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]);
if (data[1] != 0xa || data[2] < 0x9)
input_dev->open = cypress_touchkey_open;
err = input_register_device(input_dev);
if (err)
goto err_input_reg_dev;
set_device_params(devdata, data);
err = i2c_touchkey_write_byte(devdata, devdata->backlight_on);
if (err) {
dev_err(dev, "%s: touch keypad backlight on failed\n",
__func__);
/* The device may not be responding because of bad firmware
* Allow the firmware to be reflashed if it needs to be
*/
if (!input_dev->open)
goto err_backlight_on;
}
err = request_threaded_irq(client->irq, touchkey_interrupt_handler,
touchkey_interrupt_thread, IRQF_TRIGGER_FALLING,
DEVICE_NAME, devdata);
if (err) {
dev_err(dev, "%s: Can't allocate irq.\n", __func__);
goto err_req_irq;
}
#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;
#ifdef CONFIG_GENERIC_BLN
blndevdata = devdata;
register_bln_implementation(&cypress_touchkey_bln);
#endif
#ifdef CONFIG_BLD
blddevdata = devdata;
register_bld_implementation(&cypress_touchkey_bld);
#endif
#ifdef CONFIG_TOUCH_WAKE
touchwakedevdata = devdata;
register_touchwake_implementation(&cypress_touchwake);
#endif
return 0;
err_req_irq:
err_backlight_on:
input_unregister_device(input_dev);
goto touchkey_off;
err_input_reg_dev:
err_read:
input_free_device(input_dev);
touchkey_off:
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
err_input_alloc_dev:
err_null_keycodes:
kfree(devdata);
return err;
}
static int cypress_disable_touchkey_backlights(int led_mask)
{
return i2c_touchkey_write_byte(bln_devdata, bln_devdata->backlight_off);
}
static void cypress_touchkey_bld_enable(void)
{
i2c_touchkey_write_byte(blddevdata, blddevdata->backlight_on);
}
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;
struct cypress_touchkey_devdata *devdata;
u8 data[3];
int err;
int cnt;
#if defined(TOUCH_UPDATE)
int ret;
int retry = 10;
#endif
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 defined(TOUCH_UPDATE)
tempdata = devdata;
#endif
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 = DEVICE_NAME;
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);
err = i2c_master_recv(client, data, sizeof(data));
if (err < sizeof(data)) {
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;
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;
}
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;
}
#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__);
}
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);
}
touchkey_wq = create_singlethread_workqueue(DEVICE_NAME);
if (!touchkey_wq)
return -ENOMEM;
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
#ifdef CONFIG_GENERIC_BLN
bln_devdata = devdata;
#endif
return 0;
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;
}
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;
struct cypress_touchkey_devdata *devdata;
u8 data[3];
int err;
int cnt;
if (!dev->platform_data) {
dev_err(dev, "%s: Platform data is NULL\n", __func__);
return -EINVAL;
}
devdata = kzalloc(sizeof(*devdata), GFP_KERNEL);
devdata_led = devdata;
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 = DEVICE_NAME;
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->is_delay_led_on = false;
if(devdata->pdata->touchkey_onoff)
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
err = i2c_master_recv(client, data, sizeof(data));
if (err < sizeof(data)) {
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]);
if (data[1] < 0xc4 && (data[1] >= 0x8 ||
(data[1] == 0x8 && data[2] >= 0x9))) {
devdata->backlight_on = BACKLIGHT_ON;
devdata->backlight_off = BACKLIGHT_OFF;
} else {
devdata->backlight_on = OLD_BACKLIGHT_ON;
devdata->backlight_off = OLD_BACKLIGHT_OFF;
}
/* devdata->has_legacy_keycode = data[1] >= 0xc4 || data[1] < 0x9 || */
/* (data[1] == 0x9 && data[2] < 0x9); */
devdata->has_legacy_keycode = 1;
if (sec_class == NULL)
sec_class = class_create(THIS_MODULE, "sec");
if (IS_ERR(sec_class))
pr_err("Failed to create class(sec)!\n");
ts_key_dev = device_create(sec_class, NULL, 0, NULL, "t_key");
if (IS_ERR(ts_key_dev))
pr_err("Failed to create device(ts)!\n");
if (device_create_file(ts_key_dev, &dev_attr_brightness) < 0)
pr_err("Failed to create device file for Touch key!\n");
if (device_create_file(ts_key_dev, &dev_attr_enable_disable) < 0)
pr_err("Failed to create device file for Touch key_enable_disable!\n");
#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
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;
}
#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;
return 0;
err_req_irq:
err_backlight_on:
err_read:
if(devdata->pdata->touchkey_onoff)
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;
}
static void disable_touchkey_backlights(void)
{
if ( bln_devdata->touchkey_is_on )
i2c_touchkey_write_byte(bln_devdata, bln_devdata->backlight_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;
struct cypress_touchkey_devdata *devdata;
u8 data[3];
int err;
int cnt;
#if defined(TOUCH_UPDATE)
int ret;
int retry = 10;
#endif
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 = DEVICE_NAME;
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);
turn_touchkey( devdata, true );
err = i2c_master_recv(client, data, sizeof(data));
if (err < sizeof(data)) {
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
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;
}
#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);
}
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]);
#if defined CONFIG_S5PC110_DEMPSEY_BOARD
// Firmware check & Update
if((data[1] < 0x21)){
touchkey_update_status=1;
while (retry--) {
if (ISSP_main() == 0) {
printk(KERN_ERR"[TOUCHKEY]Touchkey_update succeeded\n");
touchkey_update_status=0;
break;
}
printk(KERN_ERR"touchkey_update failed... retry...\n");
}
if (retry <= 0) {
// disable ldo11
touchkey_ldo_on(0);
touchkey_update_status=-1;
msleep(300);
}
init_hw(); //after update, re initalize.
}
#endif
#endif
#ifdef CONFIG_KEYPAD_CYPRESS_TOUCH_BLN
_pr_info3("%s misc_register(%s)\n", __FUNCTION__, backlightnotification_device.name);
err = misc_register(&backlightnotification_device);
if (err) {
pr_err("%s misc_register(%s) fail\n", __FUNCTION__, backlightnotification_device.name);
} else {
/*
* keep a reference to the devdata,
* misc driver does not give access to it (or i missed that somewhere)
*/
bln_devdata = devdata;
/* add the backlightnotification attributes */
if (sysfs_create_group(&backlightnotification_device.this_device->kobj, &bln_interface_attributes_group) < 0)
{
pr_err("%s sysfs_create_group fail\n", __FUNCTION__);
pr_err("Failed to create sysfs group for device (%s)!\n", backlightnotification_device.name);
}
}
#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);
turn_touchkey( devdata, false );
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;
}
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;
struct cypress_touchkey_devdata *devdata;
u8 data[3];
int err;
int cnt;
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 = DEVICE_NAME;
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->is_sleeping = false;
devdata->pdata->touchkey_onoff(TOUCHKEY_ON);
err = i2c_master_recv(client, data, sizeof(data));
if (err < sizeof(data)) {
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 = OLD_BACKLIGHT_ON;
devdata->backlight_off = OLD_BACKLIGHT_OFF;
devdata->has_legacy_keycode = 1;
err = i2c_touchkey_write_byte(devdata, devdata->backlight_off);
if (err) {
dev_err(dev, "%s: touch keypad backlight on failed\n",
__func__);
goto err_backlight_off;
}
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;
}
#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 (misc_register(&bl_led_device))
printk("%s misc_register(%s) failed\n", __FUNCTION__, bl_led_device.name);
else
bl_devdata = devdata;
if (sysfs_create_group(&bl_led_device.this_device->kobj, &bl_led_group) < 0)
pr_err("failed to create sysfs group for device %s\n", bl_led_device.name);
}
