drivers/input/touchscreen/ili210x.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/module.h>
   3 #include <linux/i2c.h>
   4 #include <linux/interrupt.h>
   5 #include <linux/slab.h>
   6 #include <linux/input.h>
   7 #include <linux/input/mt.h>
   8 #include <linux/input/touchscreen.h>
   9 #include <linux/delay.h>
  10 #include <linux/workqueue.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/of_device.h>
  13 #include <asm/unaligned.h>
  14
  15 #define ILI210X_TOUCHES         2
  16 #define ILI251X_TOUCHES         10
  17 #define DEFAULT_POLL_PERIOD     20
  18
  19 /* Touchscreen commands */
  20 #define REG_TOUCHDATA           0x10
  21 #define REG_PANEL_INFO          0x20
  22 #define REG_FIRMWARE_VERSION    0x40
  23 #define REG_CALIBRATE           0xcc
  24
  25 struct firmware_version {
  26         u8 id;
  27         u8 major;
  28         u8 minor;
  29 } __packed;
  30
  31 enum ili2xxx_model {
  32         MODEL_ILI210X,
  33         MODEL_ILI251X,
  34 };
  35
  36 struct ili210x {
  37         struct i2c_client *client;
  38         struct input_dev *input;
  39         unsigned int poll_period;
  40         struct delayed_work dwork;
  41         struct gpio_desc *reset_gpio;
  42         struct touchscreen_properties prop;
  43         enum ili2xxx_model model;
  44         unsigned int max_touches;
  45 };
  46
  47 static int ili210x_read_reg(struct i2c_client *client, u8 reg, void *buf,
  48                             size_t len)
  49 {
  50         struct ili210x *priv = i2c_get_clientdata(client);
  51         struct i2c_msg msg[2] = {
  52                 {
  53                         .addr   = client->addr,
  54                         .flags  = 0,
  55                         .len    = 1,
  56                         .buf    = &reg,
  57                 },
  58                 {
  59                         .addr   = client->addr,
  60                         .flags  = I2C_M_RD,
  61                         .len    = len,
  62                         .buf    = buf,
  63                 }
  64         };
  65
  66         if (priv->model == MODEL_ILI251X) {
  67                 if (i2c_transfer(client->adapter, msg, 1) != 1) {
  68                         dev_err(&client->dev, "i2c transfer failed\n");
  69                         return -EIO;
  70                 }
  71
  72                 usleep_range(5000, 5500);
  73
  74                 if (i2c_transfer(client->adapter, msg + 1, 1) != 1) {
  75                         dev_err(&client->dev, "i2c transfer failed\n");
  76                         return -EIO;
  77                 }
  78         } else {
  79                 if (i2c_transfer(client->adapter, msg, 2) != 2) {
  80                         dev_err(&client->dev, "i2c transfer failed\n");
  81                         return -EIO;
  82                 }
  83         }
  84
  85         return 0;
  86 }
  87
  88 static int ili210x_read(struct i2c_client *client, void *buf, size_t len)
  89 {
  90         struct i2c_msg msg = {
  91                 .addr   = client->addr,
  92                 .flags  = I2C_M_RD,
  93                 .len    = len,
  94                 .buf    = buf,
  95         };
  96
  97         if (i2c_transfer(client->adapter, &msg, 1) != 1) {
  98                 dev_err(&client->dev, "i2c transfer failed\n");
  99                 return -EIO;
 100         }
 101
 102         return 0;
 103 }
 104
 105 static bool ili210x_touchdata_to_coords(struct ili210x *priv, u8 *touchdata,
 106                                         unsigned int finger,
 107                                         unsigned int *x, unsigned int *y)
 108 {
 109         if (finger >= ILI210X_TOUCHES)
 110                 return false;
 111
 112         if (touchdata[0] & BIT(finger))
 113                 return false;
 114
 115         *x = get_unaligned_be16(touchdata + 1 + (finger * 4) + 0);
 116         *y = get_unaligned_be16(touchdata + 1 + (finger * 4) + 2);
 117
 118         return true;
 119 }
 120
 121 static bool ili251x_touchdata_to_coords(struct ili210x *priv, u8 *touchdata,
 122                                         unsigned int finger,
 123                                         unsigned int *x, unsigned int *y)
 124 {
 125         if (finger >= ILI251X_TOUCHES)
 126                 return false;
 127
 128         *x = get_unaligned_be16(touchdata + 1 + (finger * 5) + 0);
 129         if (!(*x & BIT(15)))    /* Touch indication */
 130                 return false;
 131
 132         *x &= 0x3fff;
 133         *y = get_unaligned_be16(touchdata + 1 + (finger * 5) + 2);
 134
 135         return true;
 136 }
 137
 138 static bool ili210x_report_events(struct ili210x *priv, u8 *touchdata)
 139 {
 140         struct input_dev *input = priv->input;
 141         int i;
 142         bool contact = false, touch = false;
 143         unsigned int x = 0, y = 0;
 144
 145         for (i = 0; i < priv->max_touches; i++) {
 146                 if (priv->model == MODEL_ILI210X) {
 147                         touch = ili210x_touchdata_to_coords(priv, touchdata,
 148                                                             i, &x, &y);
 149                 } else if (priv->model == MODEL_ILI251X) {
 150                         touch = ili251x_touchdata_to_coords(priv, touchdata,
 151                                                             i, &x, &y);
 152                         if (touch)
 153                                 contact = true;
 154                 }
 155
 156                 input_mt_slot(input, i);
 157                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
 158                 if (!touch)
 159                         continue;
 160                 touchscreen_report_pos(input, &priv->prop, x, y,
 161                                        true);
 162         }
 163
 164         input_mt_report_pointer_emulation(input, false);
 165         input_sync(input);
 166
 167         if (priv->model == MODEL_ILI210X)
 168                 contact = touchdata[0] & 0xf3;
 169
 170         return contact;
 171 }
 172
 173 static void ili210x_work(struct work_struct *work)
 174 {
 175         struct ili210x *priv = container_of(work, struct ili210x,
 176                                             dwork.work);
 177         struct i2c_client *client = priv->client;
 178         u8 touchdata[64] = { 0 };
 179         bool touch;
 180         int error = -EINVAL;
 181
 182         if (priv->model == MODEL_ILI210X) {
 183                 error = ili210x_read_reg(client, REG_TOUCHDATA,
 184                                          touchdata, sizeof(touchdata));
 185         } else if (priv->model == MODEL_ILI251X) {
 186                 error = ili210x_read_reg(client, REG_TOUCHDATA,
 187                                          touchdata, 31);
 188                 if (!error && touchdata[0] == 2)
 189                         error = ili210x_read(client, &touchdata[31], 20);
 190         }
 191
 192         if (error) {
 193                 dev_err(&client->dev,
 194                         "Unable to get touchdata, err = %d\n", error);
 195                 return;
 196         }
 197
 198         touch = ili210x_report_events(priv, touchdata);
 199
 200         if (touch)
 201                 schedule_delayed_work(&priv->dwork,
 202                                       msecs_to_jiffies(priv->poll_period));
 203 }
 204
 205 static irqreturn_t ili210x_irq(int irq, void *irq_data)
 206 {
 207         struct ili210x *priv = irq_data;
 208
 209         schedule_delayed_work(&priv->dwork, 0);
 210
 211         return IRQ_HANDLED;
 212 }
 213
 214 static ssize_t ili210x_calibrate(struct device *dev,
 215                                  struct device_attribute *attr,
 216                                  const char *buf, size_t count)
 217 {
 218         struct i2c_client *client = to_i2c_client(dev);
 219         struct ili210x *priv = i2c_get_clientdata(client);
 220         unsigned long calibrate;
 221         int rc;
 222         u8 cmd = REG_CALIBRATE;
 223
 224         if (kstrtoul(buf, 10, &calibrate))
 225                 return -EINVAL;
 226
 227         if (calibrate > 1)
 228                 return -EINVAL;
 229
 230         if (calibrate) {
 231                 rc = i2c_master_send(priv->client, &cmd, sizeof(cmd));
 232                 if (rc != sizeof(cmd))
 233                         return -EIO;
 234         }
 235
 236         return count;
 237 }
 238 static DEVICE_ATTR(calibrate, S_IWUSR, NULL, ili210x_calibrate);
 239
 240 static struct attribute *ili210x_attributes[] = {
 241         &dev_attr_calibrate.attr,
 242         NULL,
 243 };
 244
 245 static const struct attribute_group ili210x_attr_group = {
 246         .attrs = ili210x_attributes,
 247 };
 248
 249 static void ili210x_power_down(void *data)
 250 {
 251         struct gpio_desc *reset_gpio = data;
 252
 253         gpiod_set_value_cansleep(reset_gpio, 1);
 254 }
 255
 256 static void ili210x_cancel_work(void *data)
 257 {
 258         struct ili210x *priv = data;
 259
 260         cancel_delayed_work_sync(&priv->dwork);
 261 }
 262
 263 static int ili210x_i2c_probe(struct i2c_client *client,
 264                                        const struct i2c_device_id *id)
 265 {
 266         struct device *dev = &client->dev;
 267         struct ili210x *priv;
 268         struct gpio_desc *reset_gpio;
 269         struct input_dev *input;
 270         struct firmware_version firmware;
 271         enum ili2xxx_model model;
 272         int error;
 273
 274         model = (enum ili2xxx_model)id->driver_data;
 275
 276         dev_dbg(dev, "Probing for ILI210X I2C Touschreen driver");
 277
 278         if (client->irq <= 0) {
 279                 dev_err(dev, "No IRQ!\n");
 280                 return -EINVAL;
 281         }
 282
 283         reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
 284         if (IS_ERR(reset_gpio))
 285                 return PTR_ERR(reset_gpio);
 286
 287         if (reset_gpio) {
 288                 error = devm_add_action_or_reset(dev, ili210x_power_down,
 289                                                  reset_gpio);
 290                 if (error)
 291                         return error;
 292
 293                 usleep_range(50, 100);
 294                 gpiod_set_value_cansleep(reset_gpio, 0);
 295                 msleep(100);
 296         }
 297
 298         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 299         if (!priv)
 300                 return -ENOMEM;
 301
 302         input = devm_input_allocate_device(dev);
 303         if (!input)
 304                 return -ENOMEM;
 305
 306         priv->client = client;
 307         priv->input = input;
 308         priv->poll_period = DEFAULT_POLL_PERIOD;
 309         INIT_DELAYED_WORK(&priv->dwork, ili210x_work);
 310         priv->reset_gpio = reset_gpio;
 311         priv->model = model;
 312         if (model == MODEL_ILI210X)
 313                 priv->max_touches = ILI210X_TOUCHES;
 314         if (model == MODEL_ILI251X)
 315                 priv->max_touches = ILI251X_TOUCHES;
 316
 317         i2c_set_clientdata(client, priv);
 318
 319         /* Get firmware version */
 320         error = ili210x_read_reg(client, REG_FIRMWARE_VERSION,
 321                                  &firmware, sizeof(firmware));
 322         if (error) {
 323                 dev_err(dev, "Failed to get firmware version, err: %d\n",
 324                         error);
 325                 return error;
 326         }
 327
 328         /* Setup input device */
 329         input->name = "ILI210x Touchscreen";
 330         input->id.bustype = BUS_I2C;
 331         input->dev.parent = dev;
 332
 333         /* Multi touch */
 334         input_set_abs_params(input, ABS_MT_POSITION_X, 0, 0xffff, 0, 0);
 335         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, 0xffff, 0, 0);
 336         touchscreen_parse_properties(input, true, &priv->prop);
 337         input_mt_init_slots(input, priv->max_touches, INPUT_MT_DIRECT);
 338
 339         error = devm_add_action(dev, ili210x_cancel_work, priv);
 340         if (error)
 341                 return error;
 342
 343         error = devm_request_irq(dev, client->irq, ili210x_irq, 0,
 344                                  client->name, priv);
 345         if (error) {
 346                 dev_err(dev, "Unable to request touchscreen IRQ, err: %d\n",
 347                         error);
 348                 return error;
 349         }
 350
 351         error = devm_device_add_group(dev, &ili210x_attr_group);
 352         if (error) {
 353                 dev_err(dev, "Unable to create sysfs attributes, err: %d\n",
 354                         error);
 355                 return error;
 356         }
 357
 358         error = input_register_device(priv->input);
 359         if (error) {
 360                 dev_err(dev, "Cannot register input device, err: %d\n", error);
 361                 return error;
 362         }
 363
 364         device_init_wakeup(dev, 1);
 365
 366         dev_dbg(dev,
 367                 "ILI210x initialized (IRQ: %d), firmware version %d.%d.%d",
 368                 client->irq, firmware.id, firmware.major, firmware.minor);
 369
 370         return 0;
 371 }
 372
 373 static int __maybe_unused ili210x_i2c_suspend(struct device *dev)
 374 {
 375         struct i2c_client *client = to_i2c_client(dev);
 376
 377         if (device_may_wakeup(&client->dev))
 378                 enable_irq_wake(client->irq);
 379
 380         return 0;
 381 }
 382
 383 static int __maybe_unused ili210x_i2c_resume(struct device *dev)
 384 {
 385         struct i2c_client *client = to_i2c_client(dev);
 386
 387         if (device_may_wakeup(&client->dev))
 388                 disable_irq_wake(client->irq);
 389
 390         return 0;
 391 }
 392
 393 static SIMPLE_DEV_PM_OPS(ili210x_i2c_pm,
 394                          ili210x_i2c_suspend, ili210x_i2c_resume);
 395
 396 static const struct i2c_device_id ili210x_i2c_id[] = {
 397         { "ili210x", MODEL_ILI210X },
 398         { "ili251x", MODEL_ILI251X },
 399         { }
 400 };
 401 MODULE_DEVICE_TABLE(i2c, ili210x_i2c_id);
 402
 403 static const struct of_device_id ili210x_dt_ids[] = {
 404         { .compatible = "ilitek,ili210x", .data = (void *)MODEL_ILI210X },
 405         { .compatible = "ilitek,ili251x", .data = (void *)MODEL_ILI251X },
 406         { },
 407 };
 408 MODULE_DEVICE_TABLE(of, ili210x_dt_ids);
 409
 410 static struct i2c_driver ili210x_ts_driver = {
 411         .driver = {
 412                 .name = "ili210x_i2c",
 413                 .pm = &ili210x_i2c_pm,
 414                 .of_match_table = ili210x_dt_ids,
 415         },
 416         .id_table = ili210x_i2c_id,
 417         .probe = ili210x_i2c_probe,
 418 };
 419
 420 module_i2c_driver(ili210x_ts_driver);
 421
 422 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
 423 MODULE_DESCRIPTION("ILI210X I2C Touchscreen Driver");
 424 MODULE_LICENSE("GPL");