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