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