diff options
Diffstat (limited to 'drivers/input/touchscreen/egalax_ts.c')
-rw-r--r-- | drivers/input/touchscreen/egalax_ts.c | 310 |
1 files changed, 185 insertions, 125 deletions
diff --git a/drivers/input/touchscreen/egalax_ts.c b/drivers/input/touchscreen/egalax_ts.c index 0b6cde77c421..da3aeab2270f 100644 --- a/drivers/input/touchscreen/egalax_ts.c +++ b/drivers/input/touchscreen/egalax_ts.c @@ -1,7 +1,7 @@ /* * Driver for EETI eGalax Multiple Touch Controller * - * Copyright (C) 2011 Freescale Semiconductor, Inc. + * Copyright (C) 2012-2013 Freescale Semiconductor, Inc. All Rights Reserved. * * based on max11801_ts.c * @@ -21,8 +21,7 @@ */ /* EETI eGalax serial touch screen controller is a I2C based multiple - * touch screen controller, it can supports 5 pointer multiple - * touch. */ + * touch screen controller, it supports 5 point multiple touch. */ /* TODO: - auto idle mode support @@ -39,17 +38,26 @@ #include <linux/delay.h> #include <linux/slab.h> #include <linux/bitops.h> +#include <linux/input/mt.h> +#include <linux/earlysuspend.h> -#define REPORT_MODE_SINGLE 0x1 +/* Mouse Mode: some panel may configure the controller to mouse mode, + * which can only report one point at a given time. + * This driver will ignore events in this mode. + */ +#define REPORT_MODE_MOUSE 0x1 +/* Vendor Mode: this mode is used to transfer some vendor specific + * messages. + * This driver will ignore events in this mode. + */ #define REPORT_MODE_VENDOR 0x3 +/* Multiple Touch Mode */ #define REPORT_MODE_MTTOUCH 0x4 -#define MAX_SUPPORT_POINTS 5 +#define MAX_SUPPORT_POINTS 2 -#define EVENT_MODE 0 -#define EVENT_STATUS 1 #define EVENT_VALID_OFFSET 7 -#define EVENT_VAILD_MASK (0x1 << EVENT_VALID_OFFSET) +#define EVENT_VALID_MASK (0x1 << EVENT_VALID_OFFSET) #define EVENT_ID_OFFSET 2 #define EVENT_ID_MASK (0xf << EVENT_ID_OFFSET) #define EVENT_IN_RANGE (0x1 << 1) @@ -57,149 +65,145 @@ #define MAX_I2C_DATA_LEN 10 -struct egalax_pointer { - bool valid; - bool status; - u16 x; - u16 y; +#define EGALAX_MAX_X 32760 +#define EGALAX_MAX_Y 32760 +#define EGALAX_MAX_Z 2048 +#define EGALAX_MAX_TRIES 100 + +struct finger_info { + s16 x; + s16 y; + s16 z; }; struct egalax_ts { struct i2c_client *client; struct input_dev *input_dev; - struct egalax_pointer events[MAX_SUPPORT_POINTS]; +#ifdef CONFIG_EARLYSUSPEND + struct early_suspend es_handler; +#endif + u32 finger_mask; + int touch_no_wake; + struct finger_info fingers[MAX_SUPPORT_POINTS]; }; +static void report_input_data(struct egalax_ts *data) +{ + int i; + int num_fingers_down; + + num_fingers_down = 0; + for (i = 0; i < MAX_SUPPORT_POINTS; i++) { + if (data->fingers[i].z == -1) + continue; + + input_report_abs(data->input_dev, ABS_MT_POSITION_X, + data->fingers[i].x); + input_report_abs(data->input_dev, ABS_MT_POSITION_Y, + data->fingers[i].y); + input_report_abs(data->input_dev, ABS_MT_PRESSURE, + data->fingers[i].z); + input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, 1); + input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, i); + input_mt_sync(data->input_dev); + num_fingers_down++; + } + data->finger_mask = 0; + + if (num_fingers_down == 0) + input_mt_sync(data->input_dev); + input_sync(data->input_dev); +} + static irqreturn_t egalax_ts_interrupt(int irq, void *dev_id) { struct egalax_ts *data = dev_id; - struct input_dev *input_dev = data->input_dev; struct i2c_client *client = data->client; - struct egalax_pointer *events = data->events; u8 buf[MAX_I2C_DATA_LEN]; - int i, id, ret, x, y; + int id, ret, x, y, z; + int tries = 0; bool down, valid; u8 state; -retry: - ret = i2c_master_recv(client, buf, MAX_I2C_DATA_LEN); - if (ret == -EAGAIN) - goto retry; + memset(buf, 0, MAX_I2C_DATA_LEN); + do { + ret = i2c_master_recv(client, buf, MAX_I2C_DATA_LEN); + } while (ret == -EAGAIN && tries++ < EGALAX_MAX_TRIES); if (ret < 0) return IRQ_HANDLED; - dev_dbg(&client->dev, "recv ret:%d", ret); - for (i = 0; i < MAX_I2C_DATA_LEN; i++) - dev_dbg(&client->dev, " %x ", buf[i]); - - if (buf[0] != REPORT_MODE_VENDOR - && buf[0] != REPORT_MODE_SINGLE - && buf[0] != REPORT_MODE_MTTOUCH) { - /* invalid point */ - return IRQ_HANDLED; - } - - if (buf[0] == REPORT_MODE_VENDOR) { - dev_dbg(&client->dev, "vendor message, ignored\n"); + if (buf[0] != REPORT_MODE_MTTOUCH) { + /* ignore mouse events and vendor events */ return IRQ_HANDLED; } state = buf[1]; x = (buf[3] << 8) | buf[2]; y = (buf[5] << 8) | buf[4]; + z = (buf[7] << 8) | buf[6]; - /* Currently, the panel Freescale using on SMD board _NOT_ - * support single pointer mode. All event are going to - * multiple pointer mode. Add single pointer mode according - * to EETI eGalax I2C programming manual. - */ - if (buf[0] == REPORT_MODE_SINGLE) { - input_report_abs(input_dev, ABS_X, x); - input_report_abs(input_dev, ABS_Y, y); - input_report_key(input_dev, BTN_TOUCH, !!state); - input_sync(input_dev); - return IRQ_HANDLED; - } - - /* deal with multiple touch */ - valid = state & EVENT_VAILD_MASK; + valid = state & EVENT_VALID_MASK; id = (state & EVENT_ID_MASK) >> EVENT_ID_OFFSET; down = state & EVENT_DOWN_UP; - if (!valid || id > MAX_SUPPORT_POINTS) { + if (!valid || id >= MAX_SUPPORT_POINTS) { dev_dbg(&client->dev, "point invalid\n"); return IRQ_HANDLED; } - if (down) { - /* should also report old pointers */ - events[id].valid = valid; - events[id].status = down; - events[id].x = x; - events[id].y = y; - -#ifdef CONFIG_TOUCHSCREEN_EGALAX_SINGLE_TOUCH - input_report_abs(input_dev, ABS_X, x); - input_report_abs(input_dev, ABS_Y, y); - input_event(data->input_dev, EV_KEY, BTN_TOUCH, 1); - input_report_abs(input_dev, ABS_PRESSURE, 1); -#else - for (i = 0; i < MAX_SUPPORT_POINTS; i++) { - if (!events[i].valid) - continue; - dev_dbg(&client->dev, "report id:%d valid:%d x:%d y:%d", - i, valid, x, y); - - input_report_abs(input_dev, - ABS_MT_TRACKING_ID, i); - input_report_abs(input_dev, - ABS_MT_TOUCH_MAJOR, 1); - input_report_abs(input_dev, - ABS_MT_POSITION_X, events[i].x); - input_report_abs(input_dev, - ABS_MT_POSITION_Y, events[i].y); - input_mt_sync(input_dev); - } -#endif + if (data->finger_mask & (1U << id)) + report_input_data(data); + + if (!down) { + data->fingers[id].z = -1; + data->finger_mask |= 1U << id; } else { - dev_dbg(&client->dev, "release id:%d\n", id); - events[id].valid = 0; - events[id].status = 0; -#ifdef CONFIG_TOUCHSCREEN_EGALAX_SINGLE_TOUCH - input_report_key(input_dev, BTN_TOUCH, 0); - input_report_abs(input_dev, ABS_PRESSURE, 0); -#else - input_report_abs(input_dev, ABS_MT_TRACKING_ID, id); - input_event(input_dev, EV_ABS, ABS_MT_TOUCH_MAJOR, 0); - input_mt_sync(input_dev); -#endif + data->fingers[id].x = x; + data->fingers[id].y = y; + data->fingers[id].z = z; + data->finger_mask |= 1U << id; } - input_sync(input_dev); + dev_dbg(&client->dev, "%s id:%d x:%d y:%d z:%d\n", + (down ? "down" : "up"), id, x, y, z); + + if (data->finger_mask) + report_input_data(data); + return IRQ_HANDLED; } +/* wake up controller by an falling edge of interrupt gpio. */ static int egalax_wake_up_device(struct i2c_client *client) { int gpio = irq_to_gpio(client->irq); - int ret; + u8 buf[MAX_I2C_DATA_LEN]; + int ret, tries = 0; ret = gpio_request(gpio, "egalax_irq"); if (ret < 0) { - dev_err(&client->dev, "request gpio failed:%d\n", ret); + dev_err(&client->dev, "request gpio failed," + "cannot wake up controller:%d\n", ret); return ret; } - /* wake up controller via an falling edge on IRQ. */ - gpio_direction_output(gpio, 0); + /* wake up controller via an falling edge on IRQ gpio. */ + gpio_direction_output(gpio, 1); + gpio_set_value(gpio, 0); gpio_set_value(gpio, 1); /* controller should be waken up, return irq. */ gpio_direction_input(gpio); gpio_free(gpio); + + /* If the touch controller has some data pending, read it */ + /* or the INT line will remian low */ + while ((gpio_get_value(gpio) == 0) && (tries++ < EGALAX_MAX_TRIES)) + i2c_master_recv(client, buf, MAX_I2C_DATA_LEN); + return 0; } -static int egalax_7200_firmware_version(struct i2c_client *client) +static int egalax_firmware_version(struct i2c_client *client) { static const u8 cmd[MAX_I2C_DATA_LEN] = { 0x03, 0x03, 0xa, 0x01, 0x41 }; int ret; @@ -209,6 +213,9 @@ static int egalax_7200_firmware_version(struct i2c_client *client) return 0; } +static void egalax_early_suspend(struct early_suspend *h); +static void egalax_later_resume(struct early_suspend *h); + static int __devinit egalax_ts_probe(struct i2c_client *client, const struct i2c_device_id *id) { @@ -231,8 +238,17 @@ static int __devinit egalax_ts_probe(struct i2c_client *client, data->client = client; data->input_dev = input_dev; - egalax_wake_up_device(client); - ret = egalax_7200_firmware_version(client); + /* controller may be in sleep, wake it up. */ + if (egalax_wake_up_device(client) != 0) { + dev_info(&client->dev, "Failed to wake up, disable suspend," + " otherwise it can not wake up\n"); + data->touch_no_wake = true; + } + msleep(10); + /* the controller needs some time to wakeup, otherwise the + * following firmware version read will be failed. + */ + ret = egalax_firmware_version(client); if (ret < 0) { dev_err(&client->dev, "egalax_ts: failed to read firmware version\n"); @@ -241,36 +257,26 @@ static int __devinit egalax_ts_probe(struct i2c_client *client, } input_dev->name = "eGalax Touch Screen"; - input_dev->phys = "I2C", input_dev->id.bustype = BUS_I2C; - input_dev->id.vendor = 0x0EEF; - input_dev->id.product = 0x0020; - input_dev->id.version = 0x0001; input_dev->dev.parent = &client->dev; __set_bit(EV_ABS, input_dev->evbit); - __set_bit(EV_KEY, input_dev->evbit); - __set_bit(BTN_TOUCH, input_dev->keybit); - __set_bit(ABS_X, input_dev->absbit); - __set_bit(ABS_Y, input_dev->absbit); - __set_bit(ABS_PRESSURE, input_dev->absbit); - input_set_abs_params(input_dev, ABS_X, 0, 32767, 0, 0); - input_set_abs_params(input_dev, ABS_Y, 0, 32767, 0, 0); - input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1, 0, 0); - -#ifndef CONFIG_TOUCHSCREEN_EGALAX_SINGLE_TOUCH - input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, 32767, 0, 0); - input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, 32767, 0, 0); - input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); - input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0); + + input_set_abs_params(input_dev, + ABS_MT_POSITION_X, 0, EGALAX_MAX_X, 0, 0); + input_set_abs_params(input_dev, + ABS_MT_POSITION_Y, 0, EGALAX_MAX_Y, 0, 0); + input_set_abs_params(input_dev, + ABS_MT_PRESSURE, 0, EGALAX_MAX_Z, 0, 0); + input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 1, 0, 0); input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, - MAX_SUPPORT_POINTS, 0, 0); -#endif + MAX_SUPPORT_POINTS-1, 0, 0); + input_set_drvdata(input_dev, data); ret = request_threaded_irq(client->irq, NULL, egalax_ts_interrupt, - IRQF_TRIGGER_LOW | IRQF_ONESHOT, - "egalax_ts", data); + IRQF_TRIGGER_LOW | IRQF_ONESHOT, + "egalax_ts", data); if (ret < 0) { dev_err(&client->dev, "Failed to register interrupt\n"); goto err_free_dev; @@ -280,6 +286,19 @@ static int __devinit egalax_ts_probe(struct i2c_client *client, if (ret < 0) goto err_free_irq; i2c_set_clientdata(client, data); + +#ifdef CONFIG_EARLYSUSPEND + /* Not register earlysuspend if not way to wake device. */ + if (data->touch_no_wake == false) { + /* register this client's earlysuspend */ + data->es_handler.level = EARLY_SUSPEND_LEVEL_DISABLE_FB; + data->es_handler.suspend = egalax_early_suspend; + data->es_handler.resume = egalax_later_resume; + data->es_handler.data = (void *)client; + register_early_suspend(&data->es_handler); + } +#endif + return 0; err_free_irq: @@ -295,10 +314,12 @@ err_free_data: static __devexit int egalax_ts_remove(struct i2c_client *client) { struct egalax_ts *data = i2c_get_clientdata(client); - +#ifdef CONFIG_EARLYSUSPEND + unregister_early_suspend(&data->es_handler); +#endif free_irq(client->irq, data); - input_unregister_device(data->input_dev); input_free_device(data->input_dev); + input_unregister_device(data->input_dev); kfree(data); return 0; @@ -317,14 +338,25 @@ static int egalax_ts_suspend(struct device *dev) u8 suspend_cmd[MAX_I2C_DATA_LEN] = {0x3, 0x6, 0xa, 0x3, 0x36, 0x3f, 0x2, 0, 0, 0}; struct i2c_client *client = to_i2c_client(dev); - ret = i2c_master_send(client, suspend_cmd, - MAX_I2C_DATA_LEN); + struct egalax_ts *data = i2c_get_clientdata(client); + + /* If can not wake up, not suspend. */ + if (data->touch_no_wake) { + dev_info(&client->dev, "not suspend because unable to wake up device\n"); + return 0; + } + ret = i2c_master_send(client, suspend_cmd, MAX_I2C_DATA_LEN); return ret > 0 ? 0 : ret; } static int egalax_ts_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); + struct egalax_ts *data = i2c_get_clientdata(client); + + /* If not wake up, don't needs resume. */ + if (data->touch_no_wake) + return 0; return egalax_wake_up_device(client); } #endif @@ -333,13 +365,41 @@ static SIMPLE_DEV_PM_OPS(egalax_ts_pm_ops, egalax_ts_suspend, egalax_ts_resume); static struct i2c_driver egalax_ts_driver = { .driver = { .name = "egalax_ts", +#ifndef CONFIG_HAS_EARLYSUSPEND .pm = &egalax_ts_pm_ops, +#endif }, .id_table = egalax_ts_id, .probe = egalax_ts_probe, .remove = __devexit_p(egalax_ts_remove), }; +#ifdef CONFIG_HAS_EARLYSUSPEND +static void egalax_early_suspend(struct early_suspend *h) +{ + u8 suspend_cmd[MAX_I2C_DATA_LEN] = {0x3, 0x6, 0xa, 0x3, 0x36, + 0x3f, 0x2, 0, 0, 0}; + + if (h->data == NULL) + return; + i2c_master_send((struct i2c_client *)h->data, + suspend_cmd, MAX_I2C_DATA_LEN); +} + +static void egalax_later_resume(struct early_suspend *h) +{ + if (h->data) + egalax_wake_up_device((struct i2c_client *)h->data); +} +#else +static void egalax_early_suspend(struct early_suspend *h) +{ +} +static void egalax_later_resume(struct early_suspend *h) +{ +} +#endif + static int __init egalax_ts_init(void) { return i2c_add_driver(&egalax_ts_driver); |