drivers/input/touchscreen/cy8ctmg110_ts.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for cypress touch screen controller
   4  *
   5  * Copyright (c) 2009 Aava Mobile
   6  *
   7  * Some cleanups by Alan Cox <alan@linux.intel.com>
   8  */
   9
  10 #include <linux/i2c.h>
  11 #include <linux/input.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/gpio/consumer.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17 #include <asm/byteorder.h>
  18
  19 #define CY8CTMG110_DRIVER_NAME      "cy8ctmg110"
  20
  21 /* Touch coordinates */
  22 #define CY8CTMG110_X_MIN                0
  23 #define CY8CTMG110_Y_MIN                0
  24 #define CY8CTMG110_X_MAX                759
  25 #define CY8CTMG110_Y_MAX                465
  26
  27
  28 /* cy8ctmg110 register definitions */
  29 #define CY8CTMG110_TOUCH_WAKEUP_TIME    0
  30 #define CY8CTMG110_TOUCH_SLEEP_TIME     2
  31 #define CY8CTMG110_TOUCH_X1             3
  32 #define CY8CTMG110_TOUCH_Y1             5
  33 #define CY8CTMG110_TOUCH_X2             7
  34 #define CY8CTMG110_TOUCH_Y2             9
  35 #define CY8CTMG110_FINGERS              11
  36 #define CY8CTMG110_GESTURE              12
  37 #define CY8CTMG110_REG_MAX              13
  38
  39
  40 /*
  41  * The touch driver structure.
  42  */
  43 struct cy8ctmg110 {
  44         struct input_dev *input;
  45         char phys[32];
  46         struct i2c_client *client;
  47         struct gpio_desc *reset_gpio;
  48 };
  49
  50 /*
  51  * cy8ctmg110_power is the routine that is called when touch hardware
  52  * is being powered off or on. When powering on this routine de-asserts
  53  * the RESET line, when powering off reset line is asserted.
  54  */
  55 static void cy8ctmg110_power(struct cy8ctmg110 *ts, bool poweron)
  56 {
  57         if (ts->reset_gpio)
  58                 gpiod_set_value_cansleep(ts->reset_gpio, !poweron);
  59 }
  60
  61 static int cy8ctmg110_write_regs(struct cy8ctmg110 *tsc, unsigned char reg,
  62                 unsigned char len, unsigned char *value)
  63 {
  64         struct i2c_client *client = tsc->client;
  65         int ret;
  66         unsigned char i2c_data[6];
  67
  68         BUG_ON(len > 5);
  69
  70         i2c_data[0] = reg;
  71         memcpy(i2c_data + 1, value, len);
  72
  73         ret = i2c_master_send(client, i2c_data, len + 1);
  74         if (ret != len + 1) {
  75                 dev_err(&client->dev, "i2c write data cmd failed\n");
  76                 return ret < 0 ? ret : -EIO;
  77         }
  78
  79         return 0;
  80 }
  81
  82 static int cy8ctmg110_read_regs(struct cy8ctmg110 *tsc,
  83                 unsigned char *data, unsigned char len, unsigned char cmd)
  84 {
  85         struct i2c_client *client = tsc->client;
  86         int ret;
  87         struct i2c_msg msg[2] = {
  88                 /* first write slave position to i2c devices */
  89                 {
  90                         .addr = client->addr,
  91                         .len = 1,
  92                         .buf = &cmd
  93                 },
  94                 /* Second read data from position */
  95                 {
  96                         .addr = client->addr,
  97                         .flags = I2C_M_RD,
  98                         .len = len,
  99                         .buf = data
 100                 }
 101         };
 102
 103         ret = i2c_transfer(client->adapter, msg, 2);
 104         if (ret < 0)
 105                 return ret;
 106
 107         return 0;
 108 }
 109
 110 static int cy8ctmg110_touch_pos(struct cy8ctmg110 *tsc)
 111 {
 112         struct input_dev *input = tsc->input;
 113         unsigned char reg_p[CY8CTMG110_REG_MAX];
 114
 115         memset(reg_p, 0, CY8CTMG110_REG_MAX);
 116
 117         /* Reading coordinates */
 118         if (cy8ctmg110_read_regs(tsc, reg_p, 9, CY8CTMG110_TOUCH_X1) != 0)
 119                 return -EIO;
 120
 121         /* Number of touch */
 122         if (reg_p[8] == 0) {
 123                 input_report_key(input, BTN_TOUCH, 0);
 124         } else  {
 125                 input_report_key(input, BTN_TOUCH, 1);
 126                 input_report_abs(input, ABS_X,
 127                                  be16_to_cpup((__be16 *)(reg_p + 0)));
 128                 input_report_abs(input, ABS_Y,
 129                                  be16_to_cpup((__be16 *)(reg_p + 2)));
 130         }
 131
 132         input_sync(input);
 133
 134         return 0;
 135 }
 136
 137 static int cy8ctmg110_set_sleepmode(struct cy8ctmg110 *ts, bool sleep)
 138 {
 139         unsigned char reg_p[3];
 140
 141         if (sleep) {
 142                 reg_p[0] = 0x00;
 143                 reg_p[1] = 0xff;
 144                 reg_p[2] = 5;
 145         } else {
 146                 reg_p[0] = 0x10;
 147                 reg_p[1] = 0xff;
 148                 reg_p[2] = 0;
 149         }
 150
 151         return cy8ctmg110_write_regs(ts, CY8CTMG110_TOUCH_WAKEUP_TIME, 3, reg_p);
 152 }
 153
 154 static irqreturn_t cy8ctmg110_irq_thread(int irq, void *dev_id)
 155 {
 156         struct cy8ctmg110 *tsc = dev_id;
 157
 158         cy8ctmg110_touch_pos(tsc);
 159
 160         return IRQ_HANDLED;
 161 }
 162
 163 static void cy8ctmg110_shut_off(void *_ts)
 164 {
 165         struct cy8ctmg110 *ts = _ts;
 166
 167         cy8ctmg110_set_sleepmode(ts, true);
 168         cy8ctmg110_power(ts, false);
 169 }
 170
 171 static int cy8ctmg110_probe(struct i2c_client *client)
 172 {
 173         struct cy8ctmg110 *ts;
 174         struct input_dev *input_dev;
 175         int err;
 176
 177         if (!i2c_check_functionality(client->adapter,
 178                                         I2C_FUNC_SMBUS_READ_WORD_DATA))
 179                 return -EIO;
 180
 181         ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
 182         if (!ts)
 183                 return -ENOMEM;
 184
 185         input_dev = devm_input_allocate_device(&client->dev);
 186         if (!input_dev)
 187                 return -ENOMEM;
 188
 189         ts->client = client;
 190         ts->input = input_dev;
 191
 192         snprintf(ts->phys, sizeof(ts->phys),
 193                  "%s/input0", dev_name(&client->dev));
 194
 195         input_dev->name = CY8CTMG110_DRIVER_NAME " Touchscreen";
 196         input_dev->phys = ts->phys;
 197         input_dev->id.bustype = BUS_I2C;
 198
 199         input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
 200         input_set_abs_params(input_dev, ABS_X,
 201                         CY8CTMG110_X_MIN, CY8CTMG110_X_MAX, 4, 0);
 202         input_set_abs_params(input_dev, ABS_Y,
 203                         CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 4, 0);
 204
 205         /* Request and assert reset line */
 206         ts->reset_gpio = devm_gpiod_get_optional(&client->dev, NULL,
 207                                                  GPIOD_OUT_HIGH);
 208         if (IS_ERR(ts->reset_gpio)) {
 209                 err = PTR_ERR(ts->reset_gpio);
 210                 dev_err(&client->dev,
 211                         "Unable to request reset GPIO: %d\n", err);
 212                 return err;
 213         }
 214
 215         cy8ctmg110_power(ts, true);
 216         cy8ctmg110_set_sleepmode(ts, false);
 217
 218         err = devm_add_action_or_reset(&client->dev, cy8ctmg110_shut_off, ts);
 219         if (err)
 220                 return err;
 221
 222         err = devm_request_threaded_irq(&client->dev, client->irq,
 223                                         NULL, cy8ctmg110_irq_thread,
 224                                         IRQF_ONESHOT, "touch_reset_key", ts);
 225         if (err) {
 226                 dev_err(&client->dev,
 227                         "irq %d busy? error %d\n", client->irq, err);
 228                 return err;
 229         }
 230
 231         err = input_register_device(input_dev);
 232         if (err)
 233                 return err;
 234
 235         i2c_set_clientdata(client, ts);
 236
 237         return 0;
 238 }
 239
 240 static int cy8ctmg110_suspend(struct device *dev)
 241 {
 242         struct i2c_client *client = to_i2c_client(dev);
 243         struct cy8ctmg110 *ts = i2c_get_clientdata(client);
 244
 245         if (!device_may_wakeup(&client->dev)) {
 246                 cy8ctmg110_set_sleepmode(ts, true);
 247                 cy8ctmg110_power(ts, false);
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int cy8ctmg110_resume(struct device *dev)
 254 {
 255         struct i2c_client *client = to_i2c_client(dev);
 256         struct cy8ctmg110 *ts = i2c_get_clientdata(client);
 257
 258         if (!device_may_wakeup(&client->dev)) {
 259                 cy8ctmg110_power(ts, true);
 260                 cy8ctmg110_set_sleepmode(ts, false);
 261         }
 262
 263         return 0;
 264 }
 265
 266 static DEFINE_SIMPLE_DEV_PM_OPS(cy8ctmg110_pm,
 267                                 cy8ctmg110_suspend, cy8ctmg110_resume);
 268
 269 static const struct i2c_device_id cy8ctmg110_idtable[] = {
 270         { CY8CTMG110_DRIVER_NAME, 1 },
 271         { }
 272 };
 273
 274 MODULE_DEVICE_TABLE(i2c, cy8ctmg110_idtable);
 275
 276 static struct i2c_driver cy8ctmg110_driver = {
 277         .driver         = {
 278                 .name   = CY8CTMG110_DRIVER_NAME,
 279                 .pm     = pm_sleep_ptr(&cy8ctmg110_pm),
 280         },
 281         .id_table       = cy8ctmg110_idtable,
 282         .probe          = cy8ctmg110_probe,
 283 };
 284
 285 module_i2c_driver(cy8ctmg110_driver);
 286
 287 MODULE_AUTHOR("Samuli Konttila <samuli.konttila@aavamobile.com>");
 288 MODULE_DESCRIPTION("cy8ctmg110 TouchScreen Driver");
 289 MODULE_LICENSE("GPL v2");