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 struct device *dev; 225 struct gpio_desc *gpiod; 226 int i; 227 228 dev = &data->spi->dev; 229 230 /* Get the reset lines GPIO pin number */ 231 for (i = 0; i < 2; i++) { 232 gpiod = devm_gpiod_get_index(dev, NULL, i, GPIOD_OUT_LOW); 233 if (IS_ERR(gpiod)) 234 return dev_err_probe(dev, PTR_ERR(gpiod), 235 "Failed to get power GPIO %d\n", i); 236 237 data->gpiod_rst[i] = gpiod; 238 } 239 240 return 0; 241 } 242 243 static int surface3_spi_create_touch_input(struct surface3_ts_data *data) 244 { 245 struct input_dev *input; 246 int error; 247 248 input = devm_input_allocate_device(&data->spi->dev); 249 if (!input) 250 return -ENOMEM; 251 252 data->input_dev = input; 253 254 input_set_abs_params(input, ABS_MT_POSITION_X, 0, 9600, 0, 0); 255 input_abs_set_res(input, ABS_MT_POSITION_X, 40); 256 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, 7200, 0, 0); 257 input_abs_set_res(input, ABS_MT_POSITION_Y, 48); 258 input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 1024, 0, 0); 259 input_set_abs_params(input, ABS_MT_WIDTH_MINOR, 0, 1024, 0, 0); 260 input_mt_init_slots(input, 10, INPUT_MT_DIRECT); 261 262 input->name = "Surface3 SPI Capacitive TouchScreen"; 263 input->phys = "input/ts"; 264 input->id.bustype = BUS_SPI; 265 input->id.vendor = 0x045e; /* Microsoft */ 266 input->id.product = 0x0001; 267 input->id.version = 0x0000; 268 269 error = input_register_device(input); 270 if (error) { 271 dev_err(&data->spi->dev, 272 "Failed to register input device: %d", error); 273 return error; 274 } 275 276 return 0; 277 } 278 279 static int surface3_spi_create_pen_input(struct surface3_ts_data *data) 280 { 281 struct input_dev *input; 282 int error; 283 284 input = devm_input_allocate_device(&data->spi->dev); 285 if (!input) 286 return -ENOMEM; 287 288 data->pen_input_dev = input; 289 data->pen_tool = BTN_TOOL_PEN; 290 291 __set_bit(INPUT_PROP_DIRECT, input->propbit); 292 __set_bit(INPUT_PROP_POINTER, input->propbit); 293 input_set_abs_params(input, ABS_X, 0, 9600, 0, 0); 294 input_abs_set_res(input, ABS_X, 40); 295 input_set_abs_params(input, ABS_Y, 0, 7200, 0, 0); 296 input_abs_set_res(input, ABS_Y, 48); 297 input_set_abs_params(input, ABS_PRESSURE, 0, 1024, 0, 0); 298 input_set_capability(input, EV_KEY, BTN_TOUCH); 299 input_set_capability(input, EV_KEY, BTN_STYLUS); 300 input_set_capability(input, EV_KEY, BTN_TOOL_PEN); 301 input_set_capability(input, EV_KEY, BTN_TOOL_RUBBER); 302 303 input->name = "Surface3 SPI Pen Input"; 304 input->phys = "input/ts"; 305 input->id.bustype = BUS_SPI; 306 input->id.vendor = 0x045e; /* Microsoft */ 307 input->id.product = 0x0002; 308 input->id.version = 0x0000; 309 310 error = input_register_device(input); 311 if (error) { 312 dev_err(&data->spi->dev, 313 "Failed to register input device: %d", error); 314 return error; 315 } 316 317 return 0; 318 } 319 320 static int surface3_spi_probe(struct spi_device *spi) 321 { 322 struct surface3_ts_data *data; 323 int error; 324 325 /* Set up SPI*/ 326 spi->bits_per_word = 8; 327 spi->mode = SPI_MODE_0; 328 error = spi_setup(spi); 329 if (error) 330 return error; 331 332 data = devm_kzalloc(&spi->dev, sizeof(*data), GFP_KERNEL); 333 if (!data) 334 return -ENOMEM; 335 336 data->spi = spi; 337 spi_set_drvdata(spi, data); 338 339 error = surface3_spi_get_gpio_config(data); 340 if (error) 341 return error; 342 343 surface3_spi_power(data, true); 344 surface3_spi_power(data, false); 345 surface3_spi_power(data, true); 346 347 error = surface3_spi_create_touch_input(data); 348 if (error) 349 return error; 350 351 error = surface3_spi_create_pen_input(data); 352 if (error) 353 return error; 354 355 error = devm_request_threaded_irq(&spi->dev, spi->irq, 356 NULL, surface3_spi_irq_handler, 357 IRQF_ONESHOT, 358 "Surface3-irq", data); 359 if (error) 360 return error; 361 362 return 0; 363 } 364 365 static int surface3_spi_suspend(struct device *dev) 366 { 367 struct spi_device *spi = to_spi_device(dev); 368 struct surface3_ts_data *data = spi_get_drvdata(spi); 369 370 disable_irq(data->spi->irq); 371 372 surface3_spi_power(data, false); 373 374 return 0; 375 } 376 377 static int surface3_spi_resume(struct device *dev) 378 { 379 struct spi_device *spi = to_spi_device(dev); 380 struct surface3_ts_data *data = spi_get_drvdata(spi); 381 382 surface3_spi_power(data, true); 383 384 enable_irq(data->spi->irq); 385 386 return 0; 387 } 388 389 static DEFINE_SIMPLE_DEV_PM_OPS(surface3_spi_pm_ops, 390 surface3_spi_suspend, 391 surface3_spi_resume); 392 393 #ifdef CONFIG_ACPI 394 static const struct acpi_device_id surface3_spi_acpi_match[] = { 395 { "MSHW0037", 0 }, 396 { } 397 }; 398 MODULE_DEVICE_TABLE(acpi, surface3_spi_acpi_match); 399 #endif 400 401 static struct spi_driver surface3_spi_driver = { 402 .driver = { 403 .name = "Surface3-spi", 404 .acpi_match_table = ACPI_PTR(surface3_spi_acpi_match), 405 .pm = pm_sleep_ptr(&surface3_spi_pm_ops), 406 }, 407 .probe = surface3_spi_probe, 408 }; 409 410 module_spi_driver(surface3_spi_driver); 411 412 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 413 MODULE_DESCRIPTION("Surface 3 SPI touchscreen driver"); 414 MODULE_LICENSE("GPL v2"); 415