1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/bitfield.h> 4 #include <linux/bits.h> 5 #include <linux/delay.h> 6 #include <linux/i2c.h> 7 #include <linux/input.h> 8 #include <linux/input/mt.h> 9 #include <linux/input/touchscreen.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/property.h> 13 #include <linux/regulator/consumer.h> 14 15 #define IST30XX_REG_STATUS 0x20 16 #define IST30XX_REG_CHIPID (0x40000000 | IST3038C_DIRECT_ACCESS) 17 18 #define IST30XX_WHOAMI 0x30003000 19 #define IST30XXA_WHOAMI 0x300a300a 20 #define IST30XXB_WHOAMI 0x300b300b 21 #define IST3038_WHOAMI 0x30383038 22 23 #define IST3032C_WHOAMI 0x32c 24 #define IST3038C_WHOAMI 0x38c 25 26 #define IST3038B_REG_CHIPID 0x30 27 #define IST3038B_WHOAMI 0x30380b 28 29 #define IST3038C_HIB_ACCESS (0x800B << 16) 30 #define IST3038C_DIRECT_ACCESS BIT(31) 31 #define IST3038C_REG_CHIPID (0x40001000 | IST3038C_DIRECT_ACCESS) 32 #define IST3038C_REG_HIB_BASE 0x30000100 33 #define IST3038C_REG_TOUCH_STATUS (IST3038C_REG_HIB_BASE | IST3038C_HIB_ACCESS) 34 #define IST3038C_REG_TOUCH_COORD (IST3038C_REG_HIB_BASE | IST3038C_HIB_ACCESS | 0x8) 35 #define IST3038C_REG_INTR_MESSAGE (IST3038C_REG_HIB_BASE | IST3038C_HIB_ACCESS | 0x4) 36 #define IST3038C_CHIP_ON_DELAY_MS 60 37 #define IST3038C_I2C_RETRY_COUNT 3 38 #define IST3038C_MAX_FINGER_NUM 10 39 #define IST3038C_X_MASK GENMASK(23, 12) 40 #define IST3038C_Y_MASK GENMASK(11, 0) 41 #define IST3038C_AREA_MASK GENMASK(27, 24) 42 #define IST3038C_FINGER_COUNT_MASK GENMASK(15, 12) 43 #define IST3038C_FINGER_STATUS_MASK GENMASK(9, 0) 44 #define IST3032C_KEY_STATUS_MASK GENMASK(20, 16) 45 46 struct imagis_properties { 47 unsigned int interrupt_msg_cmd; 48 unsigned int touch_coord_cmd; 49 unsigned int whoami_cmd; 50 unsigned int whoami_val; 51 bool protocol_b; 52 bool touch_keys_supported; 53 }; 54 55 struct imagis_ts { 56 struct i2c_client *client; 57 const struct imagis_properties *tdata; 58 struct input_dev *input_dev; 59 struct touchscreen_properties prop; 60 struct regulator_bulk_data supplies[2]; 61 u32 keycodes[5]; 62 int num_keycodes; 63 }; 64 65 static int imagis_i2c_read_reg(struct imagis_ts *ts, 66 unsigned int reg, u32 *data) 67 { 68 __be32 ret_be; 69 __be32 reg_be = cpu_to_be32(reg); 70 struct i2c_msg msg[] = { 71 { 72 .addr = ts->client->addr, 73 .flags = 0, 74 .buf = (unsigned char *)®_be, 75 .len = sizeof(reg_be), 76 }, { 77 .addr = ts->client->addr, 78 .flags = I2C_M_RD, 79 .buf = (unsigned char *)&ret_be, 80 .len = sizeof(ret_be), 81 }, 82 }; 83 int ret, error; 84 int retry = IST3038C_I2C_RETRY_COUNT; 85 86 /* Retry in case the controller fails to respond */ 87 do { 88 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg)); 89 if (ret == ARRAY_SIZE(msg)) { 90 *data = be32_to_cpu(ret_be); 91 return 0; 92 } 93 94 error = ret < 0 ? ret : -EIO; 95 dev_err(&ts->client->dev, 96 "%s - i2c_transfer failed: %d (%d)\n", 97 __func__, error, ret); 98 } while (--retry); 99 100 return error; 101 } 102 103 static irqreturn_t imagis_interrupt(int irq, void *dev_id) 104 { 105 struct imagis_ts *ts = dev_id; 106 u32 intr_message, finger_status; 107 unsigned int finger_count, finger_pressed, key_pressed; 108 int i; 109 int error; 110 111 error = imagis_i2c_read_reg(ts, ts->tdata->interrupt_msg_cmd, &intr_message); 112 if (error) { 113 dev_err(&ts->client->dev, 114 "failed to read the interrupt message: %d\n", error); 115 goto out; 116 } 117 118 finger_count = FIELD_GET(IST3038C_FINGER_COUNT_MASK, intr_message); 119 if (finger_count > IST3038C_MAX_FINGER_NUM) { 120 dev_err(&ts->client->dev, 121 "finger count %d is more than maximum supported\n", 122 finger_count); 123 goto out; 124 } 125 126 finger_pressed = FIELD_GET(IST3038C_FINGER_STATUS_MASK, intr_message); 127 128 for (i = 0; i < finger_count; i++) { 129 if (ts->tdata->protocol_b) 130 error = imagis_i2c_read_reg(ts, 131 ts->tdata->touch_coord_cmd + (i * 4), 132 &finger_status); 133 else 134 error = imagis_i2c_read_reg(ts, 135 ts->tdata->touch_coord_cmd, &finger_status); 136 if (error) { 137 dev_err(&ts->client->dev, 138 "failed to read coordinates for finger %d: %d\n", 139 i, error); 140 goto out; 141 } 142 143 input_mt_slot(ts->input_dev, i); 144 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 145 finger_pressed & BIT(i)); 146 touchscreen_report_pos(ts->input_dev, &ts->prop, 147 FIELD_GET(IST3038C_X_MASK, finger_status), 148 FIELD_GET(IST3038C_Y_MASK, finger_status), 149 true); 150 input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 151 FIELD_GET(IST3038C_AREA_MASK, finger_status)); 152 } 153 154 key_pressed = FIELD_GET(IST3032C_KEY_STATUS_MASK, intr_message); 155 156 for (int i = 0; i < ts->num_keycodes; i++) 157 input_report_key(ts->input_dev, ts->keycodes[i], 158 key_pressed & BIT(i)); 159 160 input_mt_sync_frame(ts->input_dev); 161 input_sync(ts->input_dev); 162 163 out: 164 return IRQ_HANDLED; 165 } 166 167 static void imagis_power_off(void *_ts) 168 { 169 struct imagis_ts *ts = _ts; 170 171 regulator_bulk_disable(ARRAY_SIZE(ts->supplies), ts->supplies); 172 } 173 174 static int imagis_power_on(struct imagis_ts *ts) 175 { 176 int error; 177 178 error = regulator_bulk_enable(ARRAY_SIZE(ts->supplies), ts->supplies); 179 if (error) 180 return error; 181 182 msleep(IST3038C_CHIP_ON_DELAY_MS); 183 184 return 0; 185 } 186 187 static int imagis_start(struct imagis_ts *ts) 188 { 189 int error; 190 191 error = imagis_power_on(ts); 192 if (error) 193 return error; 194 195 enable_irq(ts->client->irq); 196 197 return 0; 198 } 199 200 static int imagis_stop(struct imagis_ts *ts) 201 { 202 disable_irq(ts->client->irq); 203 204 imagis_power_off(ts); 205 206 return 0; 207 } 208 209 static int imagis_input_open(struct input_dev *dev) 210 { 211 struct imagis_ts *ts = input_get_drvdata(dev); 212 213 return imagis_start(ts); 214 } 215 216 static void imagis_input_close(struct input_dev *dev) 217 { 218 struct imagis_ts *ts = input_get_drvdata(dev); 219 220 imagis_stop(ts); 221 } 222 223 static int imagis_init_input_dev(struct imagis_ts *ts) 224 { 225 struct input_dev *input_dev; 226 int error; 227 228 input_dev = devm_input_allocate_device(&ts->client->dev); 229 if (!input_dev) 230 return -ENOMEM; 231 232 ts->input_dev = input_dev; 233 234 input_dev->name = "Imagis capacitive touchscreen"; 235 input_dev->phys = "input/ts"; 236 input_dev->id.bustype = BUS_I2C; 237 input_dev->open = imagis_input_open; 238 input_dev->close = imagis_input_close; 239 240 input_set_drvdata(input_dev, ts); 241 242 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X); 243 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y); 244 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 16, 0, 0); 245 if (ts->tdata->touch_keys_supported) { 246 ts->num_keycodes = of_property_read_variable_u32_array( 247 ts->client->dev.of_node, "linux,keycodes", 248 ts->keycodes, 0, ARRAY_SIZE(ts->keycodes)); 249 if (ts->num_keycodes <= 0) { 250 ts->keycodes[0] = KEY_APPSELECT; 251 ts->keycodes[1] = KEY_BACK; 252 ts->num_keycodes = 2; 253 } 254 255 input_dev->keycodemax = ts->num_keycodes; 256 input_dev->keycodesize = sizeof(ts->keycodes[0]); 257 input_dev->keycode = ts->keycodes; 258 } 259 260 for (int i = 0; i < ts->num_keycodes; i++) 261 input_set_capability(input_dev, EV_KEY, ts->keycodes[i]); 262 263 touchscreen_parse_properties(input_dev, true, &ts->prop); 264 if (!ts->prop.max_x || !ts->prop.max_y) { 265 dev_err(&ts->client->dev, 266 "Touchscreen-size-x and/or touchscreen-size-y not set in dts\n"); 267 return -EINVAL; 268 } 269 270 error = input_mt_init_slots(input_dev, 271 IST3038C_MAX_FINGER_NUM, 272 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 273 if (error) { 274 dev_err(&ts->client->dev, 275 "Failed to initialize MT slots: %d", error); 276 return error; 277 } 278 279 error = input_register_device(input_dev); 280 if (error) { 281 dev_err(&ts->client->dev, 282 "Failed to register input device: %d", error); 283 return error; 284 } 285 286 return 0; 287 } 288 289 static int imagis_init_regulators(struct imagis_ts *ts) 290 { 291 struct i2c_client *client = ts->client; 292 293 ts->supplies[0].supply = "vdd"; 294 ts->supplies[1].supply = "vddio"; 295 return devm_regulator_bulk_get(&client->dev, 296 ARRAY_SIZE(ts->supplies), 297 ts->supplies); 298 } 299 300 static int imagis_probe(struct i2c_client *i2c) 301 { 302 struct device *dev = &i2c->dev; 303 struct imagis_ts *ts; 304 int chip_id, error; 305 306 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); 307 if (!ts) 308 return -ENOMEM; 309 310 ts->client = i2c; 311 312 ts->tdata = device_get_match_data(dev); 313 if (!ts->tdata) { 314 dev_err(dev, "missing chip data\n"); 315 return -EINVAL; 316 } 317 318 error = imagis_init_regulators(ts); 319 if (error) { 320 dev_err(dev, "regulator init error: %d\n", error); 321 return error; 322 } 323 324 error = imagis_power_on(ts); 325 if (error) { 326 dev_err(dev, "failed to enable regulators: %d\n", error); 327 return error; 328 } 329 330 error = devm_add_action_or_reset(dev, imagis_power_off, ts); 331 if (error) { 332 dev_err(dev, "failed to install poweroff action: %d\n", error); 333 return error; 334 } 335 336 error = imagis_i2c_read_reg(ts, ts->tdata->whoami_cmd, &chip_id); 337 if (error) { 338 dev_err(dev, "chip ID read failure: %d\n", error); 339 return error; 340 } 341 342 if (chip_id != ts->tdata->whoami_val) { 343 dev_err(dev, "unknown chip ID: 0x%x\n", chip_id); 344 return -EINVAL; 345 } 346 347 error = devm_request_threaded_irq(dev, i2c->irq, 348 NULL, imagis_interrupt, 349 IRQF_ONESHOT | IRQF_NO_AUTOEN, 350 "imagis-touchscreen", ts); 351 if (error) { 352 dev_err(dev, "IRQ %d allocation failure: %d\n", 353 i2c->irq, error); 354 return error; 355 } 356 357 error = imagis_init_input_dev(ts); 358 if (error) 359 return error; 360 361 return 0; 362 } 363 364 static int imagis_suspend(struct device *dev) 365 { 366 struct i2c_client *client = to_i2c_client(dev); 367 struct imagis_ts *ts = i2c_get_clientdata(client); 368 int retval = 0; 369 370 mutex_lock(&ts->input_dev->mutex); 371 372 if (input_device_enabled(ts->input_dev)) 373 retval = imagis_stop(ts); 374 375 mutex_unlock(&ts->input_dev->mutex); 376 377 return retval; 378 } 379 380 static int imagis_resume(struct device *dev) 381 { 382 struct i2c_client *client = to_i2c_client(dev); 383 struct imagis_ts *ts = i2c_get_clientdata(client); 384 int retval = 0; 385 386 mutex_lock(&ts->input_dev->mutex); 387 388 if (input_device_enabled(ts->input_dev)) 389 retval = imagis_start(ts); 390 391 mutex_unlock(&ts->input_dev->mutex); 392 393 return retval; 394 } 395 396 static DEFINE_SIMPLE_DEV_PM_OPS(imagis_pm_ops, imagis_suspend, imagis_resume); 397 398 static const struct imagis_properties imagis_3032c_data = { 399 .interrupt_msg_cmd = IST3038C_REG_INTR_MESSAGE, 400 .touch_coord_cmd = IST3038C_REG_TOUCH_COORD, 401 .whoami_cmd = IST3038C_REG_CHIPID, 402 .whoami_val = IST3032C_WHOAMI, 403 .touch_keys_supported = true, 404 .protocol_b = true, 405 }; 406 407 static const struct imagis_properties imagis_3038_data = { 408 .interrupt_msg_cmd = IST30XX_REG_STATUS, 409 .touch_coord_cmd = IST30XX_REG_STATUS, 410 .whoami_cmd = IST30XX_REG_CHIPID, 411 .whoami_val = IST3038_WHOAMI, 412 .touch_keys_supported = true, 413 }; 414 415 static const struct imagis_properties imagis_3038b_data = { 416 .interrupt_msg_cmd = IST30XX_REG_STATUS, 417 .touch_coord_cmd = IST30XX_REG_STATUS, 418 .whoami_cmd = IST3038B_REG_CHIPID, 419 .whoami_val = IST3038B_WHOAMI, 420 }; 421 422 static const struct imagis_properties imagis_3038c_data = { 423 .interrupt_msg_cmd = IST3038C_REG_INTR_MESSAGE, 424 .touch_coord_cmd = IST3038C_REG_TOUCH_COORD, 425 .whoami_cmd = IST3038C_REG_CHIPID, 426 .whoami_val = IST3038C_WHOAMI, 427 .protocol_b = true, 428 }; 429 430 #ifdef CONFIG_OF 431 static const struct of_device_id imagis_of_match[] = { 432 { .compatible = "imagis,ist3032c", .data = &imagis_3032c_data }, 433 { .compatible = "imagis,ist3038", .data = &imagis_3038_data }, 434 { .compatible = "imagis,ist3038b", .data = &imagis_3038b_data }, 435 { .compatible = "imagis,ist3038c", .data = &imagis_3038c_data }, 436 { }, 437 }; 438 MODULE_DEVICE_TABLE(of, imagis_of_match); 439 #endif 440 441 static struct i2c_driver imagis_ts_driver = { 442 .driver = { 443 .name = "imagis-touchscreen", 444 .pm = pm_sleep_ptr(&imagis_pm_ops), 445 .of_match_table = of_match_ptr(imagis_of_match), 446 }, 447 .probe = imagis_probe, 448 }; 449 450 module_i2c_driver(imagis_ts_driver); 451 452 MODULE_DESCRIPTION("Imagis IST3038C Touchscreen Driver"); 453 MODULE_AUTHOR("Markuss Broks <markuss.broks@gmail.com>"); 454 MODULE_LICENSE("GPL"); 455