drivers/input/touchscreen/surface3_spi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  Driver for Ntrig/Microsoft Touchscreens over SPI
   4  *
   5  *  Copyright (c) 2016 Red Hat Inc.
   6  */
   7
   8
   9 #include <linux/kernel.h>
  10
  11 #include <linux/delay.h>
  12 #include <linux/gpio/consumer.h>
  13 #include <linux/input.h>
  14 #include <linux/input/mt.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/spi/spi.h>
  19 #include <linux/acpi.h>
  20
  21 #include <asm/unaligned.h>
  22
  23 #define SURFACE3_PACKET_SIZE    264
  24
  25 #define SURFACE3_REPORT_TOUCH   0xd2
  26 #define SURFACE3_REPORT_PEN     0x16
  27
  28 struct surface3_ts_data {
  29         struct spi_device *spi;
  30         struct gpio_desc *gpiod_rst[2];
  31         struct input_dev *input_dev;
  32         struct input_dev *pen_input_dev;
  33         int pen_tool;
  34
  35         u8 rd_buf[SURFACE3_PACKET_SIZE]         ____cacheline_aligned;
  36 };
  37
  38 struct surface3_ts_data_finger {
  39         u8 status;
  40         __le16 tracking_id;
  41         __le16 x;
  42         __le16 cx;
  43         __le16 y;
  44         __le16 cy;
  45         __le16 width;
  46         __le16 height;
  47         u32 padding;
  48 } __packed;
  49
  50 struct surface3_ts_data_pen {
  51         u8 status;
  52         __le16 x;
  53         __le16 y;
  54         __le16 pressure;
  55         u8 padding;
  56 } __packed;
  57
  58 static int surface3_spi_read(struct surface3_ts_data *ts_data)
  59 {
  60         struct spi_device *spi = ts_data->spi;
  61
  62         memset(ts_data->rd_buf, 0, sizeof(ts_data->rd_buf));
  63         return spi_read(spi, ts_data->rd_buf, sizeof(ts_data->rd_buf));
  64 }
  65
  66 static void surface3_spi_report_touch(struct surface3_ts_data *ts_data,
  67                                    struct surface3_ts_data_finger *finger)
  68 {
  69         int st = finger->status & 0x01;
  70         int slot;
  71
  72         slot = input_mt_get_slot_by_key(ts_data->input_dev,
  73                                 get_unaligned_le16(&finger->tracking_id));
  74         if (slot < 0)
  75                 return;
  76
  77         input_mt_slot(ts_data->input_dev, slot);
  78         input_mt_report_slot_state(ts_data->input_dev, MT_TOOL_FINGER, st);
  79         if (st) {
  80                 input_report_abs(ts_data->input_dev,
  81                                  ABS_MT_POSITION_X,
  82                                  get_unaligned_le16(&finger->x));
  83                 input_report_abs(ts_data->input_dev,
  84                                  ABS_MT_POSITION_Y,
  85                                  get_unaligned_le16(&finger->y));
  86                 input_report_abs(ts_data->input_dev,
  87                                  ABS_MT_WIDTH_MAJOR,
  88                                  get_unaligned_le16(&finger->width));
  89                 input_report_abs(ts_data->input_dev,
  90                                  ABS_MT_WIDTH_MINOR,
  91                                  get_unaligned_le16(&finger->height));
  92         }
  93 }
  94
  95 static void surface3_spi_process_touch(struct surface3_ts_data *ts_data, u8 *data)
  96 {
  97         unsigned int i;
  98
  99         for (i = 0; i < 13; i++) {
 100                 struct surface3_ts_data_finger *finger;
 101
 102                 finger = (struct surface3_ts_data_finger *)&data[17 +
 103                                 i * sizeof(struct surface3_ts_data_finger)];
 104
 105                 /*
 106                  * When bit 5 of status is 1, it marks the end of the report:
 107                  * - touch present: 0xe7
 108                  * - touch released: 0xe4
 109                  * - nothing valuable: 0xff
 110                  */
 111                 if (finger->status & 0x10)
 112                         break;
 113
 114                 surface3_spi_report_touch(ts_data, finger);
 115         }
 116
 117         input_mt_sync_frame(ts_data->input_dev);
 118         input_sync(ts_data->input_dev);
 119 }
 120
 121 static void surface3_spi_report_pen(struct surface3_ts_data *ts_data,
 122                                     struct surface3_ts_data_pen *pen)
 123 {
 124         struct input_dev *dev = ts_data->pen_input_dev;
 125         int st = pen->status;
 126         int prox = st & 0x01;
 127         int rubber = st & 0x18;
 128         int tool = (prox && rubber) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 129
 130         /* fake proximity out to switch tools */
 131         if (ts_data->pen_tool != tool) {
 132                 input_report_key(dev, ts_data->pen_tool, 0);
 133                 input_sync(dev);
 134                 ts_data->pen_tool = tool;
 135         }
 136
 137         input_report_key(dev, BTN_TOUCH, st & 0x12);
 138
 139         input_report_key(dev, ts_data->pen_tool, prox);
 140
 141         if (st) {
 142                 input_report_key(dev,
 143                                  BTN_STYLUS,
 144                                  st & 0x04);
 145
 146                 input_report_abs(dev,
 147                                  ABS_X,
 148                                  get_unaligned_le16(&pen->x));
 149                 input_report_abs(dev,
 150                                  ABS_Y,
 151                                  get_unaligned_le16(&pen->y));
 152                 input_report_abs(dev,
 153                                  ABS_PRESSURE,
 154                                  get_unaligned_le16(&pen->pressure));
 155         }
 156 }
 157
 158 static void surface3_spi_process_pen(struct surface3_ts_data *ts_data, u8 *data)
 159 {
 160         struct surface3_ts_data_pen *pen;
 161
 162         pen = (struct surface3_ts_data_pen *)&data[15];
 163
 164         surface3_spi_report_pen(ts_data, pen);
 165         input_sync(ts_data->pen_input_dev);
 166 }
 167
 168 static void surface3_spi_process(struct surface3_ts_data *ts_data)
 169 {
 170         static const char header[] = {
 171                 0xff, 0xff, 0xff, 0xff, 0xa5, 0x5a, 0xe7, 0x7e, 0x01
 172         };
 173         u8 *data = ts_data->rd_buf;
 174
 175         if (memcmp(header, data, sizeof(header)))
 176                 dev_err(&ts_data->spi->dev,
 177                         "%s header error: %*ph, ignoring...\n",
 178                         __func__, (int)sizeof(header), data);
 179
 180         switch (data[9]) {
 181         case SURFACE3_REPORT_TOUCH:
 182                 surface3_spi_process_touch(ts_data, data);
 183                 break;
 184         case SURFACE3_REPORT_PEN:
 185                 surface3_spi_process_pen(ts_data, data);
 186                 break;
 187         default:
 188                 dev_err(&ts_data->spi->dev,
 189                         "%s unknown packet type: %x, ignoring...\n",
 190                         __func__, data[9]);
 191                 break;
 192         }
 193 }
 194
 195 static irqreturn_t surface3_spi_irq_handler(int irq, void *dev_id)
 196 {
 197         struct surface3_ts_data *data = dev_id;
 198
 199         if (surface3_spi_read(data))
 200                 return IRQ_HANDLED;
 201
 202         dev_dbg(&data->spi->dev, "%s received -> %*ph\n",
 203                 __func__, SURFACE3_PACKET_SIZE, data->rd_buf);
 204         surface3_spi_process(data);
 205
 206         return IRQ_HANDLED;
 207 }
 208
 209 static void surface3_spi_power(struct surface3_ts_data *data, bool on)
 210 {
 211         gpiod_set_value(data->gpiod_rst[0], on);
 212         gpiod_set_value(data->gpiod_rst[1], on);
 213         /* let the device settle a little */
 214         msleep(20);
 215 }
 216
 217 /**
 218  * surface3_spi_get_gpio_config - Get GPIO config from ACPI/DT
 219  *
 220  * @data: surface3_spi_ts_data pointer
 221  */
 222 static int surface3_spi_get_gpio_config(struct surface3_ts_data *data)
 223 {
 224         int error;
 225         struct device *dev;
 226         struct gpio_desc *gpiod;
 227         int i;
 228
 229         dev = &data->spi->dev;
 230
 231         /* Get the reset lines GPIO pin number */
 232         for (i = 0; i < 2; i++) {
 233                 gpiod = devm_gpiod_get_index(dev, NULL, i, GPIOD_OUT_LOW);
 234                 if (IS_ERR(gpiod)) {
 235                         error = PTR_ERR(gpiod);
 236                         if (error != -EPROBE_DEFER)
 237                                 dev_err(dev,
 238                                         "Failed to get power GPIO %d: %d\n",
 239                                         i,
 240                                         error);
 241                         return error;
 242                 }
 243
 244                 data->gpiod_rst[i] = gpiod;
 245         }
 246
 247         return 0;
 248 }
 249
 250 static int surface3_spi_create_touch_input(struct surface3_ts_data *data)
 251 {
 252         struct input_dev *input;
 253         int error;
 254
 255         input = devm_input_allocate_device(&data->spi->dev);
 256         if (!input)
 257                 return -ENOMEM;
 258
 259         data->input_dev = input;
 260
 261         input_set_abs_params(input, ABS_MT_POSITION_X, 0, 9600, 0, 0);
 262         input_abs_set_res(input, ABS_MT_POSITION_X, 40);
 263         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, 7200, 0, 0);
 264         input_abs_set_res(input, ABS_MT_POSITION_Y, 48);
 265         input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 1024, 0, 0);
 266         input_set_abs_params(input, ABS_MT_WIDTH_MINOR, 0, 1024, 0, 0);
 267         input_mt_init_slots(input, 10, INPUT_MT_DIRECT);
 268
 269         input->name = "Surface3 SPI Capacitive TouchScreen";
 270         input->phys = "input/ts";
 271         input->id.bustype = BUS_SPI;
 272         input->id.vendor = 0x045e;      /* Microsoft */
 273         input->id.product = 0x0001;
 274         input->id.version = 0x0000;
 275
 276         error = input_register_device(input);
 277         if (error) {
 278                 dev_err(&data->spi->dev,
 279                         "Failed to register input device: %d", error);
 280                 return error;
 281         }
 282
 283         return 0;
 284 }
 285
 286 static int surface3_spi_create_pen_input(struct surface3_ts_data *data)
 287 {
 288         struct input_dev *input;
 289         int error;
 290
 291         input = devm_input_allocate_device(&data->spi->dev);
 292         if (!input)
 293                 return -ENOMEM;
 294
 295         data->pen_input_dev = input;
 296         data->pen_tool = BTN_TOOL_PEN;
 297
 298         __set_bit(INPUT_PROP_DIRECT, input->propbit);
 299         __set_bit(INPUT_PROP_POINTER, input->propbit);
 300         input_set_abs_params(input, ABS_X, 0, 9600, 0, 0);
 301         input_abs_set_res(input, ABS_X, 40);
 302         input_set_abs_params(input, ABS_Y, 0, 7200, 0, 0);
 303         input_abs_set_res(input, ABS_Y, 48);
 304         input_set_abs_params(input, ABS_PRESSURE, 0, 1024, 0, 0);
 305         input_set_capability(input, EV_KEY, BTN_TOUCH);
 306         input_set_capability(input, EV_KEY, BTN_STYLUS);
 307         input_set_capability(input, EV_KEY, BTN_TOOL_PEN);
 308         input_set_capability(input, EV_KEY, BTN_TOOL_RUBBER);
 309
 310         input->name = "Surface3 SPI Pen Input";
 311         input->phys = "input/ts";
 312         input->id.bustype = BUS_SPI;
 313         input->id.vendor = 0x045e;     /* Microsoft */
 314         input->id.product = 0x0002;
 315         input->id.version = 0x0000;
 316
 317         error = input_register_device(input);
 318         if (error) {
 319                 dev_err(&data->spi->dev,
 320                         "Failed to register input device: %d", error);
 321                 return error;
 322         }
 323
 324         return 0;
 325 }
 326
 327 static int surface3_spi_probe(struct spi_device *spi)
 328 {
 329         struct surface3_ts_data *data;
 330         int error;
 331
 332         /* Set up SPI*/
 333         spi->bits_per_word = 8;
 334         spi->mode = SPI_MODE_0;
 335         error = spi_setup(spi);
 336         if (error)
 337                 return error;
 338
 339         data = devm_kzalloc(&spi->dev, sizeof(*data), GFP_KERNEL);
 340         if (!data)
 341                 return -ENOMEM;
 342
 343         data->spi = spi;
 344         spi_set_drvdata(spi, data);
 345
 346         error = surface3_spi_get_gpio_config(data);
 347         if (error)
 348                 return error;
 349
 350         surface3_spi_power(data, true);
 351         surface3_spi_power(data, false);
 352         surface3_spi_power(data, true);
 353
 354         error = surface3_spi_create_touch_input(data);
 355         if (error)
 356                 return error;
 357
 358         error = surface3_spi_create_pen_input(data);
 359         if (error)
 360                 return error;
 361
 362         error = devm_request_threaded_irq(&spi->dev, spi->irq,
 363                                           NULL, surface3_spi_irq_handler,
 364                                           IRQF_ONESHOT,
 365                                           "Surface3-irq", data);
 366         if (error)
 367                 return error;
 368
 369         return 0;
 370 }
 371
 372 static int __maybe_unused surface3_spi_suspend(struct device *dev)
 373 {
 374         struct spi_device *spi = to_spi_device(dev);
 375         struct surface3_ts_data *data = spi_get_drvdata(spi);
 376
 377         disable_irq(data->spi->irq);
 378
 379         surface3_spi_power(data, false);
 380
 381         return 0;
 382 }
 383
 384 static int __maybe_unused surface3_spi_resume(struct device *dev)
 385 {
 386         struct spi_device *spi = to_spi_device(dev);
 387         struct surface3_ts_data *data = spi_get_drvdata(spi);
 388
 389         surface3_spi_power(data, true);
 390
 391         enable_irq(data->spi->irq);
 392
 393         return 0;
 394 }
 395
 396 static SIMPLE_DEV_PM_OPS(surface3_spi_pm_ops,
 397                          surface3_spi_suspend,
 398                          surface3_spi_resume);
 399
 400 #ifdef CONFIG_ACPI
 401 static const struct acpi_device_id surface3_spi_acpi_match[] = {
 402         { "MSHW0037", 0 },
 403         { }
 404 };
 405 MODULE_DEVICE_TABLE(acpi, surface3_spi_acpi_match);
 406 #endif
 407
 408 static struct spi_driver surface3_spi_driver = {
 409         .driver = {
 410                 .name   = "Surface3-spi",
 411                 .acpi_match_table = ACPI_PTR(surface3_spi_acpi_match),
 412                 .pm = &surface3_spi_pm_ops,
 413         },
 414         .probe = surface3_spi_probe,
 415 };
 416
 417 module_spi_driver(surface3_spi_driver);
 418
 419 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
 420 MODULE_DESCRIPTION("Surface 3 SPI touchscreen driver");
 421 MODULE_LICENSE("GPL v2");