1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Driver for ELAN eKTF2127 i2c touchscreen controller 4 * 5 * For this driver the layout of the Chipone icn8318 i2c 6 * touchscreencontroller is used. 7 * 8 * Author: 9 * Michel Verlaan <michel.verl@gmail.com> 10 * Siebren Vroegindeweij <siebren.vroegindeweij@hotmail.com> 11 * 12 * Original chipone_icn8318 driver: 13 * Hans de Goede <hdegoede@redhat.com> 14 */ 15 16 #include <linux/gpio/consumer.h> 17 #include <linux/interrupt.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/module.h> 23 #include <linux/of.h> 24 #include <linux/delay.h> 25 26 /* Packet header defines (first byte of data send / received) */ 27 #define EKTF2127_NOISE 0x40 28 #define EKTF2127_RESPONSE 0x52 29 #define EKTF2127_REQUEST 0x53 30 #define EKTF2127_HELLO 0x55 31 #define EKTF2127_REPORT2 0x5a 32 #define EKTF2127_REPORT 0x5d 33 #define EKTF2127_CALIB_DONE 0x66 34 35 /* Register defines (second byte of data send / received) */ 36 #define EKTF2127_ENV_NOISY 0x41 37 #define EKTF2127_HEIGHT 0x60 38 #define EKTF2127_WIDTH 0x63 39 40 /* 2 bytes header + 5 * 3 bytes coordinates + 3 bytes pressure info + footer */ 41 #define EKTF2127_TOUCH_REPORT_SIZE 21 42 #define EKTF2127_MAX_TOUCHES 5 43 44 struct ektf2127_ts { 45 struct i2c_client *client; 46 struct input_dev *input; 47 struct gpio_desc *power_gpios; 48 struct touchscreen_properties prop; 49 }; 50 51 static void ektf2127_parse_coordinates(const u8 *buf, unsigned int touch_count, 52 struct input_mt_pos *touches) 53 { 54 int index = 0; 55 int i; 56 57 for (i = 0; i < touch_count; i++) { 58 index = 2 + i * 3; 59 60 touches[i].x = (buf[index] & 0x0f); 61 touches[i].x <<= 8; 62 touches[i].x |= buf[index + 2]; 63 64 touches[i].y = (buf[index] & 0xf0); 65 touches[i].y <<= 4; 66 touches[i].y |= buf[index + 1]; 67 } 68 } 69 70 static void ektf2127_report_event(struct ektf2127_ts *ts, const u8 *buf) 71 { 72 struct input_mt_pos touches[EKTF2127_MAX_TOUCHES]; 73 int slots[EKTF2127_MAX_TOUCHES]; 74 unsigned int touch_count, i; 75 76 touch_count = buf[1] & 0x07; 77 if (touch_count > EKTF2127_MAX_TOUCHES) { 78 dev_err(&ts->client->dev, 79 "Too many touches %d > %d\n", 80 touch_count, EKTF2127_MAX_TOUCHES); 81 touch_count = EKTF2127_MAX_TOUCHES; 82 } 83 84 ektf2127_parse_coordinates(buf, touch_count, touches); 85 input_mt_assign_slots(ts->input, slots, touches, 86 touch_count, 0); 87 88 for (i = 0; i < touch_count; i++) { 89 input_mt_slot(ts->input, slots[i]); 90 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true); 91 touchscreen_report_pos(ts->input, &ts->prop, 92 touches[i].x, touches[i].y, true); 93 } 94 95 input_mt_sync_frame(ts->input); 96 input_sync(ts->input); 97 } 98 99 static void ektf2127_report2_contact(struct ektf2127_ts *ts, int slot, 100 const u8 *buf, bool active) 101 { 102 input_mt_slot(ts->input, slot); 103 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, active); 104 105 if (active) { 106 int x = (buf[0] & 0xf0) << 4 | buf[1]; 107 int y = (buf[0] & 0x0f) << 8 | buf[2]; 108 109 touchscreen_report_pos(ts->input, &ts->prop, x, y, true); 110 } 111 } 112 113 static void ektf2127_report2_event(struct ektf2127_ts *ts, const u8 *buf) 114 { 115 ektf2127_report2_contact(ts, 0, &buf[1], !!(buf[7] & 2)); 116 ektf2127_report2_contact(ts, 1, &buf[4], !!(buf[7] & 4)); 117 118 input_mt_sync_frame(ts->input); 119 input_sync(ts->input); 120 } 121 122 static irqreturn_t ektf2127_irq(int irq, void *dev_id) 123 { 124 struct ektf2127_ts *ts = dev_id; 125 struct device *dev = &ts->client->dev; 126 char buf[EKTF2127_TOUCH_REPORT_SIZE]; 127 int ret; 128 129 ret = i2c_master_recv(ts->client, buf, EKTF2127_TOUCH_REPORT_SIZE); 130 if (ret != EKTF2127_TOUCH_REPORT_SIZE) { 131 dev_err(dev, "Error reading touch data: %d\n", ret); 132 goto out; 133 } 134 135 switch (buf[0]) { 136 case EKTF2127_REPORT: 137 ektf2127_report_event(ts, buf); 138 break; 139 140 case EKTF2127_REPORT2: 141 ektf2127_report2_event(ts, buf); 142 break; 143 144 case EKTF2127_NOISE: 145 if (buf[1] == EKTF2127_ENV_NOISY) 146 dev_dbg(dev, "Environment is electrically noisy\n"); 147 break; 148 149 case EKTF2127_HELLO: 150 case EKTF2127_CALIB_DONE: 151 break; 152 153 default: 154 dev_err(dev, "Unexpected packet header byte %#02x\n", buf[0]); 155 break; 156 } 157 158 out: 159 return IRQ_HANDLED; 160 } 161 162 static int ektf2127_start(struct input_dev *dev) 163 { 164 struct ektf2127_ts *ts = input_get_drvdata(dev); 165 166 enable_irq(ts->client->irq); 167 gpiod_set_value_cansleep(ts->power_gpios, 1); 168 169 return 0; 170 } 171 172 static void ektf2127_stop(struct input_dev *dev) 173 { 174 struct ektf2127_ts *ts = input_get_drvdata(dev); 175 176 disable_irq(ts->client->irq); 177 gpiod_set_value_cansleep(ts->power_gpios, 0); 178 } 179 180 static int __maybe_unused ektf2127_suspend(struct device *dev) 181 { 182 struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev)); 183 184 mutex_lock(&ts->input->mutex); 185 if (input_device_enabled(ts->input)) 186 ektf2127_stop(ts->input); 187 mutex_unlock(&ts->input->mutex); 188 189 return 0; 190 } 191 192 static int __maybe_unused ektf2127_resume(struct device *dev) 193 { 194 struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev)); 195 196 mutex_lock(&ts->input->mutex); 197 if (input_device_enabled(ts->input)) 198 ektf2127_start(ts->input); 199 mutex_unlock(&ts->input->mutex); 200 201 return 0; 202 } 203 204 static SIMPLE_DEV_PM_OPS(ektf2127_pm_ops, ektf2127_suspend, 205 ektf2127_resume); 206 207 static int ektf2127_query_dimension(struct i2c_client *client, bool width) 208 { 209 struct device *dev = &client->dev; 210 const char *what = width ? "width" : "height"; 211 u8 what_code = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT; 212 u8 buf[4]; 213 int ret; 214 int error; 215 216 /* Request dimension */ 217 buf[0] = EKTF2127_REQUEST; 218 buf[1] = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT; 219 buf[2] = 0x00; 220 buf[3] = 0x00; 221 ret = i2c_master_send(client, buf, sizeof(buf)); 222 if (ret != sizeof(buf)) { 223 error = ret < 0 ? ret : -EIO; 224 dev_err(dev, "Failed to request %s: %d\n", what, error); 225 return error; 226 } 227 228 msleep(20); 229 230 /* Read response */ 231 ret = i2c_master_recv(client, buf, sizeof(buf)); 232 if (ret != sizeof(buf)) { 233 error = ret < 0 ? ret : -EIO; 234 dev_err(dev, "Failed to receive %s data: %d\n", what, error); 235 return error; 236 } 237 238 if (buf[0] != EKTF2127_RESPONSE || buf[1] != what_code) { 239 dev_err(dev, "Unexpected %s data: %#02x %#02x\n", 240 what, buf[0], buf[1]); 241 return -EIO; 242 } 243 244 return (((buf[3] & 0xf0) << 4) | buf[2]) - 1; 245 } 246 247 static int ektf2127_probe(struct i2c_client *client, 248 const struct i2c_device_id *id) 249 { 250 struct device *dev = &client->dev; 251 struct ektf2127_ts *ts; 252 struct input_dev *input; 253 u8 buf[4]; 254 int max_x, max_y; 255 int error; 256 257 if (!client->irq) { 258 dev_err(dev, "Error no irq specified\n"); 259 return -EINVAL; 260 } 261 262 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); 263 if (!ts) 264 return -ENOMEM; 265 266 /* This requests the gpio *and* turns on the touchscreen controller */ 267 ts->power_gpios = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH); 268 if (IS_ERR(ts->power_gpios)) { 269 error = PTR_ERR(ts->power_gpios); 270 if (error != -EPROBE_DEFER) 271 dev_err(dev, "Error getting power gpio: %d\n", error); 272 return error; 273 } 274 275 input = devm_input_allocate_device(dev); 276 if (!input) 277 return -ENOMEM; 278 279 input->name = client->name; 280 input->id.bustype = BUS_I2C; 281 input->open = ektf2127_start; 282 input->close = ektf2127_stop; 283 284 ts->client = client; 285 286 /* Read hello (ignore result, depends on initial power state) */ 287 msleep(20); 288 i2c_master_recv(ts->client, buf, sizeof(buf)); 289 290 /* Read resolution from chip */ 291 max_x = ektf2127_query_dimension(client, true); 292 if (max_x < 0) 293 return max_x; 294 295 max_y = ektf2127_query_dimension(client, false); 296 if (max_y < 0) 297 return max_y; 298 299 input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0); 300 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0); 301 touchscreen_parse_properties(input, true, &ts->prop); 302 303 error = input_mt_init_slots(input, EKTF2127_MAX_TOUCHES, 304 INPUT_MT_DIRECT | 305 INPUT_MT_DROP_UNUSED | 306 INPUT_MT_TRACK); 307 if (error) 308 return error; 309 310 ts->input = input; 311 input_set_drvdata(input, ts); 312 313 error = devm_request_threaded_irq(dev, client->irq, 314 NULL, ektf2127_irq, 315 IRQF_ONESHOT, client->name, ts); 316 if (error) { 317 dev_err(dev, "Error requesting irq: %d\n", error); 318 return error; 319 } 320 321 /* Stop device till opened */ 322 ektf2127_stop(ts->input); 323 324 error = input_register_device(input); 325 if (error) 326 return error; 327 328 i2c_set_clientdata(client, ts); 329 330 return 0; 331 } 332 333 #ifdef CONFIG_OF 334 static const struct of_device_id ektf2127_of_match[] = { 335 { .compatible = "elan,ektf2127" }, 336 { .compatible = "elan,ektf2132" }, 337 {} 338 }; 339 MODULE_DEVICE_TABLE(of, ektf2127_of_match); 340 #endif 341 342 static const struct i2c_device_id ektf2127_i2c_id[] = { 343 { "ektf2127", 0 }, 344 { "ektf2132", 0 }, 345 {} 346 }; 347 MODULE_DEVICE_TABLE(i2c, ektf2127_i2c_id); 348 349 static struct i2c_driver ektf2127_driver = { 350 .driver = { 351 .name = "elan_ektf2127", 352 .pm = &ektf2127_pm_ops, 353 .of_match_table = of_match_ptr(ektf2127_of_match), 354 }, 355 .probe = ektf2127_probe, 356 .id_table = ektf2127_i2c_id, 357 }; 358 module_i2c_driver(ektf2127_driver); 359 360 MODULE_DESCRIPTION("ELAN eKTF2127/eKTF2132 I2C Touchscreen Driver"); 361 MODULE_AUTHOR("Michel Verlaan, Siebren Vroegindeweij"); 362 MODULE_LICENSE("GPL"); 363