drivers/input/touchscreen/surface3_spi.c

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