1 /*
2 * Copyright (c) 2020, 2025 NXP
3 * Copyright (c) 2020 Mark Olsson <mark@markolsson.se>
4 * Copyright (c) 2020 Teslabs Engineering S.L.
5 *
6 * SPDX-License-Identifier: Apache-2.0
7 */
8
9 #define DT_DRV_COMPAT goodix_gt911
10
11 #include <zephyr/drivers/gpio.h>
12 #include <zephyr/drivers/i2c.h>
13 #include <zephyr/input/input.h>
14 #include <zephyr/input/input_touch.h>
15 #include <zephyr/sys/byteorder.h>
16 #include <zephyr/pm/pm.h>
17
18 #include <zephyr/logging/log.h>
19 LOG_MODULE_REGISTER(gt911, CONFIG_INPUT_LOG_LEVEL);
20
21 /* GT911 used registers */
22 #define GT911_DEVICE_ID BSWAP_16(0x8140U)
23 #define GT911_REG_STATUS BSWAP_16(0x814EU)
24
25 /* REG_TD_STATUS: Touch points. */
26 #define GT911_TOUCH_POINTS_MSK 0x0FU
27
28 /* REG_TD_STATUS: Pressed. */
29 #define GT911_TOUCH_STATUS_MSK (1 << 7U)
30
31 /* The GT911's config */
32 #define GT911_REG_CONFIG BSWAP_16(0x8047U)
33 #define GT911_REG_CONFIG_VERSION GT911_REG_CONFIG
34 #define GT911_REG_CONFIG_TOUCH_NUM_OFFSET 0x5
35 #define GT911_REG_CONFIG_SIZE 186U
36 #define GT911_PRODUCT_ID 0x00313139U
37
38 /* Points registers */
39 #define GT911_REG_POINT_0 0x814F
40 #define GT911_POINT_OFFSET 0x8
41 #define GT911_REG_POINT_ADDR(n) BSWAP_16(GT911_REG_POINT_0 + GT911_POINT_OFFSET * n)
42
43 /** GT911 configuration (DT). */
44 struct gt911_config {
45 struct input_touchscreen_common_config common;
46 /** I2C bus. */
47 struct i2c_dt_spec bus;
48 struct gpio_dt_spec rst_gpio;
49 /** Interrupt GPIO information. */
50 struct gpio_dt_spec int_gpio;
51 /* Alternate fallback I2C address */
52 uint8_t alt_addr;
53 };
54
55 /** GT911 data. */
56 struct gt911_data {
57 /** Device pointer. */
58 const struct device *dev;
59 /** Work queue (for deferred read). */
60 struct k_work work;
61 /** Actual device I2C address */
62 uint8_t actual_address;
63 #ifdef CONFIG_INPUT_GT911_INTERRUPT
64 /** Interrupt GPIO callback. */
65 struct gpio_callback int_gpio_cb;
66 #else
67 /** Timer (polling mode). */
68 struct k_timer timer;
69 #endif
70 #ifdef CONFIG_PM
71 struct pm_notifier pm_notifier_handle;
72 #endif
73 };
74
75 INPUT_TOUCH_STRUCT_CHECK(struct gt911_config);
76
77 /** gt911 point reg */
78 struct gt911_point_reg {
79 uint8_t id; /*!< Track ID. */
80 uint8_t low_x; /*!< Low byte of x coordinate. */
81 uint8_t high_x; /*!< High byte of x coordinate. */
82 uint8_t low_y; /*!< Low byte of y coordinate. */
83 uint8_t high_y; /*!< High byte of x coordinate. */
84 uint8_t low_size; /*!< Low byte of point size. */
85 uint8_t high_size; /*!< High byte of point size. */
86 uint8_t reserved; /*!< Reserved. */
87 };
88
89 /*
90 * Device-specific wrappers around i2c_write_dt and i2c_write_read_dt.
91 * These wrappers handle the case where the GT911 did not accept the requested
92 * I2C address, and the alternate I2C address is used.
93 */
gt911_i2c_write(const struct device * dev,const uint8_t * buf,uint32_t num_bytes)94 static int gt911_i2c_write(const struct device *dev, const uint8_t *buf, uint32_t num_bytes)
95 {
96 const struct gt911_config *config = dev->config;
97 struct gt911_data *data = dev->data;
98
99 return i2c_write(config->bus.bus, buf, num_bytes, data->actual_address);
100 }
101
gt911_i2c_write_read(const struct device * dev,const void * write_buf,size_t num_write,void * read_buf,size_t num_read)102 static int gt911_i2c_write_read(const struct device *dev, const void *write_buf, size_t num_write,
103 void *read_buf, size_t num_read)
104 {
105 const struct gt911_config *config = dev->config;
106 struct gt911_data *data = dev->data;
107
108 return i2c_write_read(config->bus.bus, data->actual_address, write_buf, num_write, read_buf,
109 num_read);
110 }
111
gt911_process(const struct device * dev)112 static int gt911_process(const struct device *dev)
113 {
114 int r;
115 uint16_t reg_addr;
116 uint8_t status;
117 uint8_t i;
118 uint8_t j;
119 uint16_t row;
120 uint16_t col;
121 uint8_t points;
122 static uint8_t prev_points;
123 struct gt911_point_reg point_reg[CONFIG_INPUT_GT911_MAX_TOUCH_POINTS];
124 static struct gt911_point_reg prev_point_reg[CONFIG_INPUT_GT911_MAX_TOUCH_POINTS];
125
126 /* obtain number of touch points */
127 reg_addr = GT911_REG_STATUS;
128 r = gt911_i2c_write_read(dev, ®_addr, sizeof(reg_addr), &status, sizeof(status));
129 if (r < 0) {
130 return r;
131 }
132
133 if (!(status & GT911_TOUCH_STATUS_MSK)) {
134 /* Status bit not set, ignore this event */
135 return 0;
136 }
137
138 /*
139 * Note- since we program the max number of touch inputs during init,
140 * the controller won't report more than the maximum number of touch
141 * points we are configured to support
142 */
143 points = status & GT911_TOUCH_POINTS_MSK;
144
145 /* need to clear the status */
146 uint8_t clear_buffer[3] = {(uint8_t)GT911_REG_STATUS, (uint8_t)(GT911_REG_STATUS >> 8), 0};
147
148 r = gt911_i2c_write(dev, clear_buffer, sizeof(clear_buffer));
149 if (r < 0) {
150 return r;
151 }
152
153 /* current points array */
154 for (i = 0; i < points; i++) {
155 reg_addr = GT911_REG_POINT_ADDR(i);
156 r = gt911_i2c_write_read(dev, ®_addr, sizeof(reg_addr), &point_reg[i],
157 sizeof(point_reg[i]));
158
159 if (r < 0) {
160 return r;
161 }
162 }
163
164 /* touch events */
165 for (i = 0; i < points; i++) {
166 if (CONFIG_INPUT_GT911_MAX_TOUCH_POINTS > 1) {
167 input_report_abs(dev, INPUT_ABS_MT_SLOT, point_reg[i].id, true, K_FOREVER);
168 }
169
170 row = ((point_reg[i].high_y) << 8U) | point_reg[i].low_y;
171 col = ((point_reg[i].high_x) << 8U) | point_reg[i].low_x;
172
173 input_touchscreen_report_pos(dev, col, row, K_FOREVER);
174 input_report_key(dev, INPUT_BTN_TOUCH, 1, true, K_FOREVER);
175 }
176
177 /* release events */
178 for (i = 0; i < prev_points; i++) {
179 /* We look for the prev_point in the current points list */
180 for (j = 0; j < points; j++) {
181 if (prev_point_reg[i].id == point_reg[j].id) {
182 break;
183 }
184 }
185
186 if (j == points) {
187 if (CONFIG_INPUT_GT911_MAX_TOUCH_POINTS > 1) {
188 input_report_abs(dev, INPUT_ABS_MT_SLOT, prev_point_reg[i].id, true,
189 K_FOREVER);
190 }
191 row = ((prev_point_reg[i].high_y) << 8U) | prev_point_reg[i].low_y;
192 col = ((prev_point_reg[i].high_x) << 8U) | prev_point_reg[i].low_x;
193 input_touchscreen_report_pos(dev, col, row, K_FOREVER);
194 input_report_key(dev, INPUT_BTN_TOUCH, 0, true, K_FOREVER);
195 }
196 }
197
198 memcpy(prev_point_reg, point_reg, sizeof(point_reg));
199 prev_points = points;
200
201 return 0;
202 }
203
gt911_work_handler(struct k_work * work)204 static void gt911_work_handler(struct k_work *work)
205 {
206 struct gt911_data *data = CONTAINER_OF(work, struct gt911_data, work);
207
208 gt911_process(data->dev);
209 }
210
211 #ifdef CONFIG_INPUT_GT911_INTERRUPT
gt911_isr_handler(const struct device * dev,struct gpio_callback * cb,uint32_t pins)212 static void gt911_isr_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
213 {
214 struct gt911_data *data = CONTAINER_OF(cb, struct gt911_data, int_gpio_cb);
215
216 k_work_submit(&data->work);
217 }
218 #else
gt911_timer_handler(struct k_timer * timer)219 static void gt911_timer_handler(struct k_timer *timer)
220 {
221 struct gt911_data *data = CONTAINER_OF(timer, struct gt911_data, timer);
222
223 k_work_submit(&data->work);
224 }
225 #endif
226
gt911_get_firmware_checksum(const uint8_t * firmware)227 static uint8_t gt911_get_firmware_checksum(const uint8_t *firmware)
228 {
229 uint8_t sum = 0;
230 uint16_t i = 0;
231
232 for (i = 0; i < GT911_REG_CONFIG_SIZE - 2U; i++) {
233 sum += (*firmware);
234 firmware++;
235 }
236
237 return (~sum + 1U);
238 }
239
gt911_verify_firmware(const uint8_t * firmware)240 static bool gt911_verify_firmware(const uint8_t *firmware)
241 {
242 return ((firmware[GT911_REG_CONFIG_VERSION - GT911_REG_CONFIG] != 0U) &&
243 (gt911_get_firmware_checksum(firmware) == firmware[GT911_REG_CONFIG_SIZE - 2U]));
244 }
245
246 #if CONFIG_PM
gt911_pm_state_exit(const struct device * dev,enum pm_state state)247 static void gt911_pm_state_exit(const struct device *dev, enum pm_state state)
248 {
249 switch (state) {
250 case PM_STATE_STANDBY:
251 /* Reconfigure the GPIO interrupt pin on exit from
252 * certain low power states as we might lose the GPIO state.
253 */
254 const struct gt911_config *config = dev->config;
255 int r;
256
257 r = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
258 if (r < 0) {
259 LOG_ERR("Could not configure interrupt GPIO pin");
260 return;
261 }
262
263 #ifdef CONFIG_INPUT_GT911_INTERRUPT
264 r = gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
265 if (r < 0) {
266 LOG_ERR("Could not configure interrupt GPIO interrupt.");
267 return;
268 }
269 #endif /* CONFIG_INPUT_GT911_INTERRUPT */
270 break;
271 default:
272 break;
273 }
274 }
275 #endif /* CONFIG_PM */
276
gt911_init(const struct device * dev)277 static int gt911_init(const struct device *dev)
278 {
279 const struct gt911_config *config = dev->config;
280 struct gt911_data *data = dev->data;
281
282 if (!i2c_is_ready_dt(&config->bus)) {
283 LOG_ERR("I2C controller device not ready");
284 return -ENODEV;
285 }
286
287 data->dev = dev;
288 data->actual_address = config->bus.addr;
289
290 k_work_init(&data->work, gt911_work_handler);
291
292 int r;
293
294 if (!gpio_is_ready_dt(&config->int_gpio)) {
295 LOG_ERR("Interrupt GPIO controller device not ready");
296 return -ENODEV;
297 }
298
299 if (config->rst_gpio.port != NULL) {
300 if (!gpio_is_ready_dt(&config->rst_gpio)) {
301 LOG_ERR("Reset GPIO controller device not ready");
302 return -ENODEV;
303 }
304
305 r = gpio_pin_configure_dt(&config->rst_gpio, GPIO_OUTPUT_ACTIVE);
306 if (r < 0) {
307 LOG_ERR("Could not configure reset GPIO pin");
308 return r;
309 }
310 }
311
312 /*
313 * We need to configure the int-pin to 0, in order to enter the
314 * AddressMode0. Keeping the INT pin low during the reset sequence
315 * should result in the device selecting an I2C address of 0x5D.
316 * Note that if an alternate I2C address is set, we will probe
317 * for the alternate address if 0x5D does not work. This is useful
318 * for boards that do not route the INT pin, or only permit it
319 * to be used as an input
320 */
321 r = gpio_pin_configure_dt(&config->int_gpio, GPIO_OUTPUT_INACTIVE);
322 if (r < 0) {
323 LOG_ERR("Could not configure int GPIO pin");
324 return r;
325 }
326 /* Delay at least 10 ms after power on before we configure gt911 */
327 k_sleep(K_MSEC(20));
328 if (config->rst_gpio.port != NULL) {
329 /* reset the device and confgiure the addr mode0 */
330 gpio_pin_set_dt(&config->rst_gpio, 1);
331 /* hold down at least 1us, 1ms here */
332 k_sleep(K_MSEC(1));
333 gpio_pin_set_dt(&config->rst_gpio, 0);
334 /* hold down at least 5ms. This is the point the INT pin must be low. */
335 k_sleep(K_MSEC(5));
336 }
337 /* hold down 50ms to make sure the address available */
338 k_sleep(K_MSEC(50));
339
340 r = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
341 if (r < 0) {
342 LOG_ERR("Could not configure interrupt GPIO pin");
343 return r;
344 }
345
346 #ifdef CONFIG_INPUT_GT911_INTERRUPT
347 r = gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
348 if (r < 0) {
349 LOG_ERR("Could not configure interrupt GPIO interrupt.");
350 return r;
351 }
352
353 gpio_init_callback(&data->int_gpio_cb, gt911_isr_handler, BIT(config->int_gpio.pin));
354 #else
355 k_timer_init(&data->timer, gt911_timer_handler, NULL);
356 #endif
357
358 /* check the Device ID first: '911' */
359 uint32_t reg_id = 0;
360 uint16_t reg_addr = GT911_DEVICE_ID;
361
362 if (config->alt_addr != 0x0) {
363 /*
364 * The level of the INT pin during reset is used by the GT911
365 * to select the I2C address mode. If an alternate I2C address
366 * is set, we should probe the GT911 to determine which address
367 * it actually selected. This is useful for boards that do not
368 * route the INT pin, or can only read it as an input (IE when
369 * using a level shifter).
370 */
371 r = gt911_i2c_write_read(dev, ®_addr, sizeof(reg_addr), ®_id, sizeof(reg_id));
372 if (r < 0) {
373 /* Try alternate address */
374 data->actual_address = config->alt_addr;
375 r = gt911_i2c_write_read(dev, ®_addr, sizeof(reg_addr), ®_id,
376 sizeof(reg_id));
377 LOG_INF("Device did not accept I2C address, "
378 "updated to 0x%02X",
379 data->actual_address);
380 }
381 } else {
382 r = gt911_i2c_write_read(dev, ®_addr, sizeof(reg_addr), ®_id, sizeof(reg_id));
383 }
384 if (r < 0) {
385 LOG_ERR("Device did not respond to I2C request");
386 return r;
387 }
388 if (reg_id != GT911_PRODUCT_ID) {
389 LOG_ERR("The Device ID is not correct");
390 return -ENODEV;
391 }
392
393 /* need to setup the firmware first: read and write */
394 uint8_t gt911_config_firmware[GT911_REG_CONFIG_SIZE + 2] = {
395 (uint8_t)GT911_REG_CONFIG, (uint8_t)(GT911_REG_CONFIG >> 8)};
396
397 reg_addr = GT911_REG_CONFIG;
398 r = gt911_i2c_write_read(dev, ®_addr, sizeof(reg_addr), gt911_config_firmware + 2,
399 GT911_REG_CONFIG_SIZE);
400 if (r < 0) {
401 return r;
402 }
403 if (!gt911_verify_firmware(gt911_config_firmware + 2)) {
404 return -ENODEV;
405 }
406
407 gt911_config_firmware[GT911_REG_CONFIG_TOUCH_NUM_OFFSET + 2] =
408 CONFIG_INPUT_GT911_MAX_TOUCH_POINTS;
409
410 gt911_config_firmware[GT911_REG_CONFIG_SIZE] =
411 gt911_get_firmware_checksum(gt911_config_firmware + 2);
412 gt911_config_firmware[GT911_REG_CONFIG_SIZE + 1] = 1;
413
414 r = gt911_i2c_write(dev, gt911_config_firmware, sizeof(gt911_config_firmware));
415 if (r < 0) {
416 return r;
417 }
418
419 #ifdef CONFIG_INPUT_GT911_INTERRUPT
420 r = gpio_add_callback(config->int_gpio.port, &data->int_gpio_cb);
421 if (r < 0) {
422 LOG_ERR("Could not set gpio callback");
423 return r;
424 }
425 #else
426 k_timer_start(&data->timer, K_MSEC(CONFIG_INPUT_GT911_PERIOD_MS),
427 K_MSEC(CONFIG_INPUT_GT911_PERIOD_MS));
428 #endif
429
430 #if CONFIG_PM
431 /* We need to reconfigure the interrupt GPIO when waking up from
432 * certain low power modes.
433 */
434 pm_notifier_register(&data->pm_notifier_handle);
435 #endif
436 return 0;
437 }
438
439 #if CONFIG_PM
440 #define GT911_PM_NOTIFIER_FUNCS(n) \
441 static void gt911_##n##_pm_state_exit(enum pm_state state) \
442 { \
443 gt911_pm_state_exit(DEVICE_DT_INST_GET(n), state); \
444 }
445
446 #define GT911_PM_NOTIFIER(n) \
447 .pm_notifier_handle = { \
448 .state_exit = gt911_##n##_pm_state_exit, \
449 },
450 #else
451 #define GT911_PM_NOTIFIER_FUNCS(n)
452 #define GT911_PM_NOTIFIER(n)
453 #endif /* CONFIG_PM */
454
455 #define GT911_INIT(index) \
456 static const struct gt911_config gt911_config_##index = { \
457 .common = INPUT_TOUCH_DT_INST_COMMON_CONFIG_INIT(index), \
458 .bus = I2C_DT_SPEC_INST_GET(index), \
459 .rst_gpio = GPIO_DT_SPEC_INST_GET_OR(index, reset_gpios, {0}), \
460 .int_gpio = GPIO_DT_SPEC_INST_GET(index, irq_gpios), \
461 .alt_addr = DT_INST_PROP_OR(index, alt_addr, 0), \
462 }; \
463 GT911_PM_NOTIFIER_FUNCS(index) \
464 static struct gt911_data gt911_data_##index = { \
465 GT911_PM_NOTIFIER(index) \
466 }; \
467 DEVICE_DT_INST_DEFINE(index, gt911_init, NULL, >911_data_##index, >911_config_##index, \
468 POST_KERNEL, CONFIG_INPUT_INIT_PRIORITY, NULL);
469
470 DT_INST_FOREACH_STATUS_OKAY(GT911_INIT)
471
