drivers/input/touchscreen/ektf2127.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Driver for ELAN eKTF2127 i2c touchscreen controller
   4  *
   5  * For this driver the layout of the Chipone icn8318 i2c
   6  * touchscreencontroller is used.
   7  *
   8  * Author:
   9  * Michel Verlaan <michel.verl@gmail.com>
  10  * Siebren Vroegindeweij <siebren.vroegindeweij@hotmail.com>
  11  *
  12  * Original chipone_icn8318 driver:
  13  * Hans de Goede <hdegoede@redhat.com>
  14  */
  15
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/i2c.h>
  19 #include <linux/input.h>
  20 #include <linux/input/mt.h>
  21 #include <linux/input/touchscreen.h>
  22 #include <linux/module.h>
  23 #include <linux/of.h>
  24 #include <linux/delay.h>
  25
  26 /* Packet header defines (first byte of data send / received) */
  27 #define EKTF2127_NOISE                  0x40
  28 #define EKTF2127_RESPONSE               0x52
  29 #define EKTF2127_REQUEST                0x53
  30 #define EKTF2127_HELLO                  0x55
  31 #define EKTF2127_REPORT2                0x5a
  32 #define EKTF2127_REPORT                 0x5d
  33 #define EKTF2127_CALIB_DONE             0x66
  34
  35 /* Register defines (second byte of data send / received) */
  36 #define EKTF2127_ENV_NOISY              0x41
  37 #define EKTF2127_HEIGHT                 0x60
  38 #define EKTF2127_WIDTH                  0x63
  39
  40 /* 2 bytes header + 5 * 3 bytes coordinates + 3 bytes pressure info + footer */
  41 #define EKTF2127_TOUCH_REPORT_SIZE      21
  42 #define EKTF2127_MAX_TOUCHES            5
  43
  44 struct ektf2127_ts {
  45         struct i2c_client *client;
  46         struct input_dev *input;
  47         struct gpio_desc *power_gpios;
  48         struct touchscreen_properties prop;
  49 };
  50
  51 static void ektf2127_parse_coordinates(const u8 *buf, unsigned int touch_count,
  52                                        struct input_mt_pos *touches)
  53 {
  54         int index = 0;
  55         int i;
  56
  57         for (i = 0; i < touch_count; i++) {
  58                 index = 2 + i * 3;
  59
  60                 touches[i].x = (buf[index] & 0x0f);
  61                 touches[i].x <<= 8;
  62                 touches[i].x |= buf[index + 2];
  63
  64                 touches[i].y = (buf[index] & 0xf0);
  65                 touches[i].y <<= 4;
  66                 touches[i].y |= buf[index + 1];
  67         }
  68 }
  69
  70 static void ektf2127_report_event(struct ektf2127_ts *ts, const u8 *buf)
  71 {
  72         struct input_mt_pos touches[EKTF2127_MAX_TOUCHES];
  73         int slots[EKTF2127_MAX_TOUCHES];
  74         unsigned int touch_count, i;
  75
  76         touch_count = buf[1] & 0x07;
  77         if (touch_count > EKTF2127_MAX_TOUCHES) {
  78                 dev_err(&ts->client->dev,
  79                         "Too many touches %d > %d\n",
  80                         touch_count, EKTF2127_MAX_TOUCHES);
  81                 touch_count = EKTF2127_MAX_TOUCHES;
  82         }
  83
  84         ektf2127_parse_coordinates(buf, touch_count, touches);
  85         input_mt_assign_slots(ts->input, slots, touches,
  86                               touch_count, 0);
  87
  88         for (i = 0; i < touch_count; i++) {
  89                 input_mt_slot(ts->input, slots[i]);
  90                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
  91                 touchscreen_report_pos(ts->input, &ts->prop,
  92                                        touches[i].x, touches[i].y, true);
  93         }
  94
  95         input_mt_sync_frame(ts->input);
  96         input_sync(ts->input);
  97 }
  98
  99 static void ektf2127_report2_contact(struct ektf2127_ts *ts, int slot,
 100                                      const u8 *buf, bool active)
 101 {
 102         input_mt_slot(ts->input, slot);
 103         input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, active);
 104
 105         if (active) {
 106                 int x = (buf[0] & 0xf0) << 4 | buf[1];
 107                 int y = (buf[0] & 0x0f) << 8 | buf[2];
 108
 109                 touchscreen_report_pos(ts->input, &ts->prop, x, y, true);
 110         }
 111 }
 112
 113 static void ektf2127_report2_event(struct ektf2127_ts *ts, const u8 *buf)
 114 {
 115         ektf2127_report2_contact(ts, 0, &buf[1], !!(buf[7] & 2));
 116         ektf2127_report2_contact(ts, 1, &buf[4], !!(buf[7] & 4));
 117
 118         input_mt_sync_frame(ts->input);
 119         input_sync(ts->input);
 120 }
 121
 122 static irqreturn_t ektf2127_irq(int irq, void *dev_id)
 123 {
 124         struct ektf2127_ts *ts = dev_id;
 125         struct device *dev = &ts->client->dev;
 126         char buf[EKTF2127_TOUCH_REPORT_SIZE];
 127         int ret;
 128
 129         ret = i2c_master_recv(ts->client, buf, EKTF2127_TOUCH_REPORT_SIZE);
 130         if (ret != EKTF2127_TOUCH_REPORT_SIZE) {
 131                 dev_err(dev, "Error reading touch data: %d\n", ret);
 132                 goto out;
 133         }
 134
 135         switch (buf[0]) {
 136         case EKTF2127_REPORT:
 137                 ektf2127_report_event(ts, buf);
 138                 break;
 139
 140         case EKTF2127_REPORT2:
 141                 ektf2127_report2_event(ts, buf);
 142                 break;
 143
 144         case EKTF2127_NOISE:
 145                 if (buf[1] == EKTF2127_ENV_NOISY)
 146                         dev_dbg(dev, "Environment is electrically noisy\n");
 147                 break;
 148
 149         case EKTF2127_HELLO:
 150         case EKTF2127_CALIB_DONE:
 151                 break;
 152
 153         default:
 154                 dev_err(dev, "Unexpected packet header byte %#02x\n", buf[0]);
 155                 break;
 156         }
 157
 158 out:
 159         return IRQ_HANDLED;
 160 }
 161
 162 static int ektf2127_start(struct input_dev *dev)
 163 {
 164         struct ektf2127_ts *ts = input_get_drvdata(dev);
 165
 166         enable_irq(ts->client->irq);
 167         gpiod_set_value_cansleep(ts->power_gpios, 1);
 168
 169         return 0;
 170 }
 171
 172 static void ektf2127_stop(struct input_dev *dev)
 173 {
 174         struct ektf2127_ts *ts = input_get_drvdata(dev);
 175
 176         disable_irq(ts->client->irq);
 177         gpiod_set_value_cansleep(ts->power_gpios, 0);
 178 }
 179
 180 static int ektf2127_suspend(struct device *dev)
 181 {
 182         struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
 183
 184         mutex_lock(&ts->input->mutex);
 185         if (input_device_enabled(ts->input))
 186                 ektf2127_stop(ts->input);
 187         mutex_unlock(&ts->input->mutex);
 188
 189         return 0;
 190 }
 191
 192 static int ektf2127_resume(struct device *dev)
 193 {
 194         struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
 195
 196         mutex_lock(&ts->input->mutex);
 197         if (input_device_enabled(ts->input))
 198                 ektf2127_start(ts->input);
 199         mutex_unlock(&ts->input->mutex);
 200
 201         return 0;
 202 }
 203
 204 static DEFINE_SIMPLE_DEV_PM_OPS(ektf2127_pm_ops, ektf2127_suspend,
 205                                 ektf2127_resume);
 206
 207 static int ektf2127_query_dimension(struct i2c_client *client, bool width)
 208 {
 209         struct device *dev = &client->dev;
 210         const char *what = width ? "width" : "height";
 211         u8 what_code = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
 212         u8 buf[4];
 213         int ret;
 214         int error;
 215
 216         /* Request dimension */
 217         buf[0] = EKTF2127_REQUEST;
 218         buf[1] = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
 219         buf[2] = 0x00;
 220         buf[3] = 0x00;
 221         ret = i2c_master_send(client, buf, sizeof(buf));
 222         if (ret != sizeof(buf)) {
 223                 error = ret < 0 ? ret : -EIO;
 224                 dev_err(dev, "Failed to request %s: %d\n", what, error);
 225                 return error;
 226         }
 227
 228         msleep(20);
 229
 230         /* Read response */
 231         ret = i2c_master_recv(client, buf, sizeof(buf));
 232         if (ret != sizeof(buf)) {
 233                 error = ret < 0 ? ret : -EIO;
 234                 dev_err(dev, "Failed to receive %s data: %d\n", what, error);
 235                 return error;
 236         }
 237
 238         if (buf[0] != EKTF2127_RESPONSE || buf[1] != what_code) {
 239                 dev_err(dev, "Unexpected %s data: %#02x %#02x\n",
 240                         what, buf[0], buf[1]);
 241                 return -EIO;
 242         }
 243
 244         return (((buf[3] & 0xf0) << 4) | buf[2]) - 1;
 245 }
 246
 247 static int ektf2127_probe(struct i2c_client *client)
 248 {
 249         struct device *dev = &client->dev;
 250         struct ektf2127_ts *ts;
 251         struct input_dev *input;
 252         u8 buf[4];
 253         int max_x, max_y;
 254         int error;
 255
 256         if (!client->irq) {
 257                 dev_err(dev, "Error no irq specified\n");
 258                 return -EINVAL;
 259         }
 260
 261         ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
 262         if (!ts)
 263                 return -ENOMEM;
 264
 265         /* This requests the gpio *and* turns on the touchscreen controller */
 266         ts->power_gpios = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH);
 267         if (IS_ERR(ts->power_gpios))
 268                 return dev_err_probe(dev, PTR_ERR(ts->power_gpios), "Error getting power gpio\n");
 269
 270         input = devm_input_allocate_device(dev);
 271         if (!input)
 272                 return -ENOMEM;
 273
 274         input->name = client->name;
 275         input->id.bustype = BUS_I2C;
 276         input->open = ektf2127_start;
 277         input->close = ektf2127_stop;
 278
 279         ts->client = client;
 280
 281         /* Read hello (ignore result, depends on initial power state) */
 282         msleep(20);
 283         i2c_master_recv(ts->client, buf, sizeof(buf));
 284
 285         /* Read resolution from chip */
 286         max_x = ektf2127_query_dimension(client, true);
 287         if (max_x < 0)
 288                 return max_x;
 289
 290         max_y = ektf2127_query_dimension(client, false);
 291         if (max_y < 0)
 292                 return max_y;
 293
 294         input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
 295         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
 296         touchscreen_parse_properties(input, true, &ts->prop);
 297
 298         error = input_mt_init_slots(input, EKTF2127_MAX_TOUCHES,
 299                                     INPUT_MT_DIRECT |
 300                                         INPUT_MT_DROP_UNUSED |
 301                                         INPUT_MT_TRACK);
 302         if (error)
 303                 return error;
 304
 305         ts->input = input;
 306         input_set_drvdata(input, ts);
 307
 308         error = devm_request_threaded_irq(dev, client->irq,
 309                                           NULL, ektf2127_irq,
 310                                           IRQF_ONESHOT, client->name, ts);
 311         if (error) {
 312                 dev_err(dev, "Error requesting irq: %d\n", error);
 313                 return error;
 314         }
 315
 316         /* Stop device till opened */
 317         ektf2127_stop(ts->input);
 318
 319         error = input_register_device(input);
 320         if (error)
 321                 return error;
 322
 323         i2c_set_clientdata(client, ts);
 324
 325         return 0;
 326 }
 327
 328 #ifdef CONFIG_OF
 329 static const struct of_device_id ektf2127_of_match[] = {
 330         { .compatible = "elan,ektf2127" },
 331         { .compatible = "elan,ektf2132" },
 332         {}
 333 };
 334 MODULE_DEVICE_TABLE(of, ektf2127_of_match);
 335 #endif
 336
 337 static const struct i2c_device_id ektf2127_i2c_id[] = {
 338         { "ektf2127", 0 },
 339         { "ektf2132", 0 },
 340         {}
 341 };
 342 MODULE_DEVICE_TABLE(i2c, ektf2127_i2c_id);
 343
 344 static struct i2c_driver ektf2127_driver = {
 345         .driver = {
 346                 .name   = "elan_ektf2127",
 347                 .pm     = pm_sleep_ptr(&ektf2127_pm_ops),
 348                 .of_match_table = of_match_ptr(ektf2127_of_match),
 349         },
 350         .probe = ektf2127_probe,
 351         .id_table = ektf2127_i2c_id,
 352 };
 353 module_i2c_driver(ektf2127_driver);
 354
 355 MODULE_DESCRIPTION("ELAN eKTF2127/eKTF2132 I2C Touchscreen Driver");
 356 MODULE_AUTHOR("Michel Verlaan, Siebren Vroegindeweij");
 357 MODULE_LICENSE("GPL");