1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for Himax hx83112b touchscreens 4 * 5 * Copyright (C) 2022 Job Noorman <job@noorman.info> 6 * 7 * HX83100A support 8 * Copyright (C) 2024 Felix Kaechele <felix@kaechele.ca> 9 * 10 * This code is based on "Himax Android Driver Sample Code for QCT platform": 11 * 12 * Copyright (C) 2017 Himax Corporation. 13 */ 14 15 #include <linux/delay.h> 16 #include <linux/err.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/i2c.h> 19 #include <linux/input.h> 20 #include <linux/input/mt.h> 21 #include <linux/input/touchscreen.h> 22 #include <linux/interrupt.h> 23 #include <linux/kernel.h> 24 #include <linux/regmap.h> 25 26 #define HIMAX_MAX_POINTS 10 27 28 #define HIMAX_AHB_ADDR_BYTE_0 0x00 29 #define HIMAX_AHB_ADDR_RDATA_BYTE_0 0x08 30 #define HIMAX_AHB_ADDR_ACCESS_DIRECTION 0x0c 31 #define HIMAX_AHB_ADDR_INCR4 0x0d 32 #define HIMAX_AHB_ADDR_CONTI 0x13 33 #define HIMAX_AHB_ADDR_EVENT_STACK 0x30 34 35 #define HIMAX_AHB_CMD_ACCESS_DIRECTION_READ 0x00 36 #define HIMAX_AHB_CMD_INCR4 0x10 37 #define HIMAX_AHB_CMD_CONTI 0x31 38 39 #define HIMAX_REG_ADDR_ICID 0x900000d0 40 41 #define HX83100A_REG_FW_EVENT_STACK 0x90060000 42 43 #define HIMAX_INVALID_COORD 0xffff 44 45 struct himax_event_point { 46 __be16 x; 47 __be16 y; 48 } __packed; 49 50 struct himax_event { 51 struct himax_event_point points[HIMAX_MAX_POINTS]; 52 u8 majors[HIMAX_MAX_POINTS]; 53 u8 pad0[2]; 54 u8 num_points; 55 u8 pad1[2]; 56 u8 checksum_fix; 57 } __packed; 58 59 static_assert(sizeof(struct himax_event) == 56); 60 61 struct himax_ts_data; 62 struct himax_chip { 63 u32 id; 64 int (*check_id)(struct himax_ts_data *ts); 65 int (*read_events)(struct himax_ts_data *ts, struct himax_event *event, 66 size_t length); 67 }; 68 69 struct himax_ts_data { 70 const struct himax_chip *chip; 71 struct gpio_desc *gpiod_rst; 72 struct input_dev *input_dev; 73 struct i2c_client *client; 74 struct regmap *regmap; 75 struct touchscreen_properties props; 76 }; 77 78 static const struct regmap_config himax_regmap_config = { 79 .reg_bits = 8, 80 .val_bits = 32, 81 .val_format_endian = REGMAP_ENDIAN_LITTLE, 82 }; 83 84 static int himax_bus_enable_burst(struct himax_ts_data *ts) 85 { 86 int error; 87 88 error = regmap_write(ts->regmap, HIMAX_AHB_ADDR_CONTI, 89 HIMAX_AHB_CMD_CONTI); 90 if (error) 91 return error; 92 93 error = regmap_write(ts->regmap, HIMAX_AHB_ADDR_INCR4, 94 HIMAX_AHB_CMD_INCR4); 95 if (error) 96 return error; 97 98 return 0; 99 } 100 101 static int himax_bus_read(struct himax_ts_data *ts, u32 address, void *dst, 102 size_t length) 103 { 104 int error; 105 106 if (length > 4) { 107 error = himax_bus_enable_burst(ts); 108 if (error) 109 return error; 110 } 111 112 error = regmap_write(ts->regmap, HIMAX_AHB_ADDR_BYTE_0, address); 113 if (error) 114 return error; 115 116 error = regmap_write(ts->regmap, HIMAX_AHB_ADDR_ACCESS_DIRECTION, 117 HIMAX_AHB_CMD_ACCESS_DIRECTION_READ); 118 if (error) 119 return error; 120 121 if (length > 4) 122 error = regmap_noinc_read(ts->regmap, HIMAX_AHB_ADDR_RDATA_BYTE_0, 123 dst, length); 124 else 125 error = regmap_read(ts->regmap, HIMAX_AHB_ADDR_RDATA_BYTE_0, 126 dst); 127 if (error) 128 return error; 129 130 return 0; 131 } 132 133 static int himax_read_mcu(struct himax_ts_data *ts, u32 address, u32 *dst) 134 { 135 int error; 136 137 error = himax_bus_read(ts, address, dst, sizeof(dst)); 138 if (error) 139 return error; 140 141 return 0; 142 } 143 144 static void himax_reset(struct himax_ts_data *ts) 145 { 146 gpiod_set_value_cansleep(ts->gpiod_rst, 1); 147 148 /* Delay copied from downstream driver */ 149 msleep(20); 150 gpiod_set_value_cansleep(ts->gpiod_rst, 0); 151 152 /* 153 * The downstream driver doesn't contain this delay but is seems safer 154 * to include it. The range is just a guess that seems to work well. 155 */ 156 usleep_range(1000, 1100); 157 } 158 159 static int himax_read_product_id(struct himax_ts_data *ts, u32 *product_id) 160 { 161 int error; 162 163 error = himax_read_mcu(ts, HIMAX_REG_ADDR_ICID, product_id); 164 if (error) 165 return error; 166 167 *product_id >>= 8; 168 return 0; 169 } 170 171 static int himax_check_product_id(struct himax_ts_data *ts) 172 { 173 int error; 174 u32 product_id; 175 176 error = himax_read_product_id(ts, &product_id); 177 if (error) 178 return error; 179 180 dev_dbg(&ts->client->dev, "Product id: %x\n", product_id); 181 182 if (product_id == ts->chip->id) 183 return 0; 184 185 dev_err(&ts->client->dev, "Unknown product id: %x\n", 186 product_id); 187 return -EINVAL; 188 } 189 190 static int himax_input_register(struct himax_ts_data *ts) 191 { 192 int error; 193 194 ts->input_dev = devm_input_allocate_device(&ts->client->dev); 195 if (!ts->input_dev) { 196 dev_err(&ts->client->dev, "Failed to allocate input device\n"); 197 return -ENOMEM; 198 } 199 200 ts->input_dev->name = "Himax Touchscreen"; 201 202 input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_X); 203 input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_Y); 204 input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0); 205 input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 200, 0, 0); 206 207 touchscreen_parse_properties(ts->input_dev, true, &ts->props); 208 209 error = input_mt_init_slots(ts->input_dev, HIMAX_MAX_POINTS, 210 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 211 if (error) { 212 dev_err(&ts->client->dev, 213 "Failed to initialize MT slots: %d\n", error); 214 return error; 215 } 216 217 error = input_register_device(ts->input_dev); 218 if (error) { 219 dev_err(&ts->client->dev, 220 "Failed to register input device: %d\n", error); 221 return error; 222 } 223 224 return 0; 225 } 226 227 static u8 himax_event_get_num_points(const struct himax_event *event) 228 { 229 if (event->num_points == 0xff) 230 return 0; 231 else 232 return event->num_points & 0x0f; 233 } 234 235 static bool himax_process_event_point(struct himax_ts_data *ts, 236 const struct himax_event *event, 237 int point_index) 238 { 239 const struct himax_event_point *point = &event->points[point_index]; 240 u16 x = be16_to_cpu(point->x); 241 u16 y = be16_to_cpu(point->y); 242 u8 w = event->majors[point_index]; 243 244 if (x == HIMAX_INVALID_COORD || y == HIMAX_INVALID_COORD) 245 return false; 246 247 input_mt_slot(ts->input_dev, point_index); 248 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true); 249 touchscreen_report_pos(ts->input_dev, &ts->props, x, y, true); 250 input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, w); 251 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w); 252 return true; 253 } 254 255 static void himax_process_event(struct himax_ts_data *ts, 256 const struct himax_event *event) 257 { 258 int i; 259 int num_points_left = himax_event_get_num_points(event); 260 261 for (i = 0; i < HIMAX_MAX_POINTS && num_points_left > 0; i++) { 262 if (himax_process_event_point(ts, event, i)) 263 num_points_left--; 264 } 265 266 input_mt_sync_frame(ts->input_dev); 267 input_sync(ts->input_dev); 268 } 269 270 static bool himax_verify_checksum(struct himax_ts_data *ts, 271 const struct himax_event *event) 272 { 273 u8 *data = (u8 *)event; 274 int i; 275 u16 checksum = 0; 276 277 for (i = 0; i < sizeof(*event); i++) 278 checksum += data[i]; 279 280 if ((checksum & 0x00ff) != 0) { 281 dev_err(&ts->client->dev, "Wrong event checksum: %04x\n", 282 checksum); 283 return false; 284 } 285 286 return true; 287 } 288 289 static int himax_read_events(struct himax_ts_data *ts, 290 struct himax_event *event, size_t length) 291 { 292 return regmap_raw_read(ts->regmap, HIMAX_AHB_ADDR_EVENT_STACK, event, 293 length); 294 } 295 296 static int hx83100a_read_events(struct himax_ts_data *ts, 297 struct himax_event *event, size_t length) 298 { 299 return himax_bus_read(ts, HX83100A_REG_FW_EVENT_STACK, event, length); 300 }; 301 302 static int himax_handle_input(struct himax_ts_data *ts) 303 { 304 int error; 305 struct himax_event event; 306 307 error = ts->chip->read_events(ts, &event, sizeof(event)); 308 if (error) { 309 dev_err(&ts->client->dev, "Failed to read input event: %d\n", 310 error); 311 return error; 312 } 313 314 /* 315 * Only process the current event when it has a valid checksum but 316 * don't consider it a fatal error when it doesn't. 317 */ 318 if (himax_verify_checksum(ts, &event)) 319 himax_process_event(ts, &event); 320 321 return 0; 322 } 323 324 static irqreturn_t himax_irq_handler(int irq, void *dev_id) 325 { 326 int error; 327 struct himax_ts_data *ts = dev_id; 328 329 error = himax_handle_input(ts); 330 if (error) 331 return IRQ_NONE; 332 333 return IRQ_HANDLED; 334 } 335 336 static int himax_probe(struct i2c_client *client) 337 { 338 int error; 339 struct device *dev = &client->dev; 340 struct himax_ts_data *ts; 341 342 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 343 dev_err(dev, "I2C check functionality failed\n"); 344 return -ENXIO; 345 } 346 347 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); 348 if (!ts) 349 return -ENOMEM; 350 351 i2c_set_clientdata(client, ts); 352 ts->client = client; 353 ts->chip = i2c_get_match_data(client); 354 355 ts->regmap = devm_regmap_init_i2c(client, &himax_regmap_config); 356 error = PTR_ERR_OR_ZERO(ts->regmap); 357 if (error) { 358 dev_err(dev, "Failed to initialize regmap: %d\n", error); 359 return error; 360 } 361 362 ts->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 363 error = PTR_ERR_OR_ZERO(ts->gpiod_rst); 364 if (error) { 365 dev_err(dev, "Failed to get reset GPIO: %d\n", error); 366 return error; 367 } 368 369 himax_reset(ts); 370 371 if (ts->chip->check_id) { 372 error = himax_check_product_id(ts); 373 if (error) 374 return error; 375 } 376 377 error = himax_input_register(ts); 378 if (error) 379 return error; 380 381 error = devm_request_threaded_irq(dev, client->irq, NULL, 382 himax_irq_handler, IRQF_ONESHOT, 383 client->name, ts); 384 if (error) 385 return error; 386 387 return 0; 388 } 389 390 static int himax_suspend(struct device *dev) 391 { 392 struct himax_ts_data *ts = dev_get_drvdata(dev); 393 394 disable_irq(ts->client->irq); 395 return 0; 396 } 397 398 static int himax_resume(struct device *dev) 399 { 400 struct himax_ts_data *ts = dev_get_drvdata(dev); 401 402 enable_irq(ts->client->irq); 403 return 0; 404 } 405 406 static DEFINE_SIMPLE_DEV_PM_OPS(himax_pm_ops, himax_suspend, himax_resume); 407 408 static const struct himax_chip hx83100a_chip = { 409 .read_events = hx83100a_read_events, 410 }; 411 412 static const struct himax_chip hx83112b_chip = { 413 .id = 0x83112b, 414 .check_id = himax_check_product_id, 415 .read_events = himax_read_events, 416 }; 417 418 static const struct i2c_device_id himax_ts_id[] = { 419 { "hx83100a", (kernel_ulong_t)&hx83100a_chip }, 420 { "hx83112b", (kernel_ulong_t)&hx83112b_chip }, 421 { /* sentinel */ } 422 }; 423 MODULE_DEVICE_TABLE(i2c, himax_ts_id); 424 425 #ifdef CONFIG_OF 426 static const struct of_device_id himax_of_match[] = { 427 { .compatible = "himax,hx83100a", .data = &hx83100a_chip }, 428 { .compatible = "himax,hx83112b", .data = &hx83112b_chip }, 429 { /* sentinel */ } 430 }; 431 MODULE_DEVICE_TABLE(of, himax_of_match); 432 #endif 433 434 static struct i2c_driver himax_ts_driver = { 435 .probe = himax_probe, 436 .id_table = himax_ts_id, 437 .driver = { 438 .name = "Himax-hx83112b-TS", 439 .of_match_table = of_match_ptr(himax_of_match), 440 .pm = pm_sleep_ptr(&himax_pm_ops), 441 }, 442 }; 443 module_i2c_driver(himax_ts_driver); 444 445 MODULE_AUTHOR("Job Noorman <job@noorman.info>"); 446 MODULE_DESCRIPTION("Himax hx83112b touchscreen driver"); 447 MODULE_LICENSE("GPL"); 448