Commit | Line | Data |
---|---|---|
75259966 TF |
1 | /* |
2 | * drivers/input/touchscreen/tps6507x_ts.c | |
3 | * | |
4 | * Touchscreen driver for the tps6507x chip. | |
5 | * | |
6 | * Copyright (c) 2009 RidgeRun (todd.fischer@ridgerun.com) | |
7 | * | |
8 | * Credits: | |
9 | * | |
10 | * Using code from tsc2007, MtekVision Co., Ltd. | |
11 | * | |
12 | * For licencing details see kernel-base/COPYING | |
13 | * | |
14 | * TPS65070, TPS65073, TPS650731, and TPS650732 support | |
15 | * 10 bit touch screen interface. | |
16 | */ | |
17 | ||
18 | #include <linux/module.h> | |
19 | #include <linux/workqueue.h> | |
20 | #include <linux/slab.h> | |
21 | #include <linux/input.h> | |
22 | #include <linux/platform_device.h> | |
23 | #include <linux/mfd/tps6507x.h> | |
24 | #include <linux/input/tps6507x-ts.h> | |
25 | #include <linux/delay.h> | |
26 | ||
27 | #define TSC_DEFAULT_POLL_PERIOD 30 /* ms */ | |
28 | #define TPS_DEFAULT_MIN_PRESSURE 0x30 | |
29 | #define MAX_10BIT ((1 << 10) - 1) | |
30 | ||
31 | #define TPS6507X_ADCONFIG_CONVERT_TS (TPS6507X_ADCONFIG_AD_ENABLE | \ | |
32 | TPS6507X_ADCONFIG_START_CONVERSION | \ | |
33 | TPS6507X_ADCONFIG_INPUT_REAL_TSC) | |
34 | #define TPS6507X_ADCONFIG_POWER_DOWN_TS (TPS6507X_ADCONFIG_INPUT_REAL_TSC) | |
35 | ||
36 | struct ts_event { | |
37 | u16 x; | |
38 | u16 y; | |
39 | u16 pressure; | |
40 | }; | |
41 | ||
42 | struct tps6507x_ts { | |
43 | struct input_dev *input_dev; | |
44 | struct device *dev; | |
45 | char phys[32]; | |
75259966 TF |
46 | struct delayed_work work; |
47 | unsigned polling; /* polling is active */ | |
48 | struct ts_event tc; | |
49 | struct tps6507x_dev *mfd; | |
50 | u16 model; | |
51 | unsigned pendown; | |
52 | int irq; | |
53 | void (*clear_penirq)(void); | |
54 | unsigned long poll_period; /* ms */ | |
55 | u16 min_pressure; | |
56 | int vref; /* non-zero to leave vref on */ | |
57 | }; | |
58 | ||
59 | static int tps6507x_read_u8(struct tps6507x_ts *tsc, u8 reg, u8 *data) | |
60 | { | |
61 | int err; | |
62 | ||
63 | err = tsc->mfd->read_dev(tsc->mfd, reg, 1, data); | |
64 | ||
65 | if (err) | |
66 | return err; | |
67 | ||
68 | return 0; | |
69 | } | |
70 | ||
71 | static int tps6507x_write_u8(struct tps6507x_ts *tsc, u8 reg, u8 data) | |
72 | { | |
73 | return tsc->mfd->write_dev(tsc->mfd, reg, 1, &data); | |
74 | } | |
75 | ||
76 | static s32 tps6507x_adc_conversion(struct tps6507x_ts *tsc, | |
77 | u8 tsc_mode, u16 *value) | |
78 | { | |
79 | s32 ret; | |
80 | u8 adc_status; | |
81 | u8 result; | |
82 | ||
83 | /* Route input signal to A/D converter */ | |
84 | ||
85 | ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE, tsc_mode); | |
86 | if (ret) { | |
87 | dev_err(tsc->dev, "TSC mode read failed\n"); | |
88 | goto err; | |
89 | } | |
90 | ||
91 | /* Start A/D conversion */ | |
92 | ||
93 | ret = tps6507x_write_u8(tsc, TPS6507X_REG_ADCONFIG, | |
94 | TPS6507X_ADCONFIG_CONVERT_TS); | |
95 | if (ret) { | |
96 | dev_err(tsc->dev, "ADC config write failed\n"); | |
97 | return ret; | |
98 | } | |
99 | ||
100 | do { | |
101 | ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADCONFIG, | |
102 | &adc_status); | |
103 | if (ret) { | |
104 | dev_err(tsc->dev, "ADC config read failed\n"); | |
105 | goto err; | |
106 | } | |
107 | } while (adc_status & TPS6507X_ADCONFIG_START_CONVERSION); | |
108 | ||
109 | ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_2, &result); | |
110 | if (ret) { | |
111 | dev_err(tsc->dev, "ADC result 2 read failed\n"); | |
112 | goto err; | |
113 | } | |
114 | ||
115 | *value = (result & TPS6507X_REG_ADRESULT_2_MASK) << 8; | |
116 | ||
117 | ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_1, &result); | |
118 | if (ret) { | |
119 | dev_err(tsc->dev, "ADC result 1 read failed\n"); | |
120 | goto err; | |
121 | } | |
122 | ||
123 | *value |= result; | |
124 | ||
125 | dev_dbg(tsc->dev, "TSC channel %d = 0x%X\n", tsc_mode, *value); | |
126 | ||
127 | err: | |
128 | return ret; | |
129 | } | |
130 | ||
131 | /* Need to call tps6507x_adc_standby() after using A/D converter for the | |
132 | * touch screen interrupt to work properly. | |
133 | */ | |
134 | ||
135 | static s32 tps6507x_adc_standby(struct tps6507x_ts *tsc) | |
136 | { | |
137 | s32 ret; | |
138 | s32 loops = 0; | |
139 | u8 val; | |
140 | ||
141 | ret = tps6507x_write_u8(tsc, TPS6507X_REG_ADCONFIG, | |
142 | TPS6507X_ADCONFIG_INPUT_TSC); | |
143 | if (ret) | |
144 | return ret; | |
145 | ||
146 | ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE, | |
147 | TPS6507X_TSCMODE_STANDBY); | |
148 | if (ret) | |
149 | return ret; | |
150 | ||
151 | ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val); | |
152 | if (ret) | |
153 | return ret; | |
154 | ||
155 | while (val & TPS6507X_REG_TSC_INT) { | |
156 | mdelay(10); | |
157 | ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val); | |
158 | if (ret) | |
159 | return ret; | |
160 | loops++; | |
161 | } | |
162 | ||
163 | return ret; | |
164 | } | |
165 | ||
166 | static void tps6507x_ts_handler(struct work_struct *work) | |
167 | { | |
168 | struct tps6507x_ts *tsc = container_of(work, | |
169 | struct tps6507x_ts, work.work); | |
170 | struct input_dev *input_dev = tsc->input_dev; | |
171 | int pendown; | |
172 | int schd; | |
173 | int poll = 0; | |
174 | s32 ret; | |
175 | ||
176 | ret = tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_PRESSURE, | |
177 | &tsc->tc.pressure); | |
178 | if (ret) | |
179 | goto done; | |
180 | ||
181 | pendown = tsc->tc.pressure > tsc->min_pressure; | |
182 | ||
183 | if (unlikely(!pendown && tsc->pendown)) { | |
184 | dev_dbg(tsc->dev, "UP\n"); | |
185 | input_report_key(input_dev, BTN_TOUCH, 0); | |
186 | input_report_abs(input_dev, ABS_PRESSURE, 0); | |
187 | input_sync(input_dev); | |
188 | tsc->pendown = 0; | |
189 | } | |
190 | ||
191 | if (pendown) { | |
192 | ||
193 | if (!tsc->pendown) { | |
194 | dev_dbg(tsc->dev, "DOWN\n"); | |
195 | input_report_key(input_dev, BTN_TOUCH, 1); | |
196 | } else | |
197 | dev_dbg(tsc->dev, "still down\n"); | |
198 | ||
199 | ret = tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_X_POSITION, | |
200 | &tsc->tc.x); | |
201 | if (ret) | |
202 | goto done; | |
203 | ||
204 | ret = tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_Y_POSITION, | |
205 | &tsc->tc.y); | |
206 | if (ret) | |
207 | goto done; | |
208 | ||
209 | input_report_abs(input_dev, ABS_X, tsc->tc.x); | |
210 | input_report_abs(input_dev, ABS_Y, tsc->tc.y); | |
211 | input_report_abs(input_dev, ABS_PRESSURE, tsc->tc.pressure); | |
212 | input_sync(input_dev); | |
213 | tsc->pendown = 1; | |
214 | poll = 1; | |
215 | } | |
216 | ||
217 | done: | |
218 | /* always poll if not using interrupts */ | |
219 | poll = 1; | |
220 | ||
221 | if (poll) { | |
1c1e8646 TH |
222 | schd = schedule_delayed_work(&tsc->work, |
223 | msecs_to_jiffies(tsc->poll_period)); | |
75259966 TF |
224 | if (schd) |
225 | tsc->polling = 1; | |
226 | else { | |
227 | tsc->polling = 0; | |
228 | dev_err(tsc->dev, "re-schedule failed"); | |
229 | } | |
230 | } else | |
231 | tsc->polling = 0; | |
232 | ||
233 | ret = tps6507x_adc_standby(tsc); | |
234 | } | |
235 | ||
236 | static int tps6507x_ts_probe(struct platform_device *pdev) | |
237 | { | |
238 | int error; | |
239 | struct tps6507x_ts *tsc; | |
240 | struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent); | |
241 | struct touchscreen_init_data *init_data; | |
242 | struct input_dev *input_dev; | |
243 | struct tps6507x_board *tps_board; | |
244 | int schd; | |
245 | ||
246 | /** | |
247 | * tps_board points to pmic related constants | |
248 | * coming from the board-evm file. | |
249 | */ | |
250 | ||
251 | tps_board = (struct tps6507x_board *)tps6507x_dev->dev->platform_data; | |
252 | ||
253 | if (!tps_board) { | |
254 | dev_err(tps6507x_dev->dev, | |
255 | "Could not find tps6507x platform data\n"); | |
256 | return -EIO; | |
257 | } | |
258 | ||
259 | /** | |
260 | * init_data points to array of regulator_init structures | |
261 | * coming from the board-evm file. | |
262 | */ | |
263 | ||
264 | init_data = tps_board->tps6507x_ts_init_data; | |
265 | ||
266 | tsc = kzalloc(sizeof(struct tps6507x_ts), GFP_KERNEL); | |
267 | if (!tsc) { | |
268 | dev_err(tps6507x_dev->dev, "failed to allocate driver data\n"); | |
269 | error = -ENOMEM; | |
270 | goto err0; | |
271 | } | |
272 | ||
273 | tps6507x_dev->ts = tsc; | |
274 | tsc->mfd = tps6507x_dev; | |
275 | tsc->dev = tps6507x_dev->dev; | |
276 | input_dev = input_allocate_device(); | |
277 | if (!input_dev) { | |
278 | dev_err(tsc->dev, "Failed to allocate input device.\n"); | |
279 | error = -ENOMEM; | |
280 | goto err1; | |
281 | } | |
282 | ||
283 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); | |
284 | input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); | |
285 | ||
286 | input_set_abs_params(input_dev, ABS_X, 0, MAX_10BIT, 0, 0); | |
287 | input_set_abs_params(input_dev, ABS_Y, 0, MAX_10BIT, 0, 0); | |
288 | input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_10BIT, 0, 0); | |
289 | ||
290 | input_dev->name = "TPS6507x Touchscreen"; | |
291 | input_dev->id.bustype = BUS_I2C; | |
292 | input_dev->dev.parent = tsc->dev; | |
293 | ||
294 | snprintf(tsc->phys, sizeof(tsc->phys), | |
295 | "%s/input0", dev_name(tsc->dev)); | |
296 | input_dev->phys = tsc->phys; | |
297 | ||
298 | dev_dbg(tsc->dev, "device: %s\n", input_dev->phys); | |
299 | ||
300 | input_set_drvdata(input_dev, tsc); | |
301 | ||
302 | tsc->input_dev = input_dev; | |
303 | ||
304 | INIT_DELAYED_WORK(&tsc->work, tps6507x_ts_handler); | |
75259966 TF |
305 | |
306 | if (init_data) { | |
307 | tsc->poll_period = init_data->poll_period; | |
308 | tsc->vref = init_data->vref; | |
309 | tsc->min_pressure = init_data->min_pressure; | |
310 | input_dev->id.vendor = init_data->vendor; | |
311 | input_dev->id.product = init_data->product; | |
312 | input_dev->id.version = init_data->version; | |
313 | } else { | |
314 | tsc->poll_period = TSC_DEFAULT_POLL_PERIOD; | |
315 | tsc->min_pressure = TPS_DEFAULT_MIN_PRESSURE; | |
316 | } | |
317 | ||
318 | error = tps6507x_adc_standby(tsc); | |
319 | if (error) | |
320 | goto err2; | |
321 | ||
322 | error = input_register_device(input_dev); | |
323 | if (error) | |
324 | goto err2; | |
325 | ||
1c1e8646 TH |
326 | schd = schedule_delayed_work(&tsc->work, |
327 | msecs_to_jiffies(tsc->poll_period)); | |
75259966 TF |
328 | |
329 | if (schd) | |
330 | tsc->polling = 1; | |
331 | else { | |
332 | tsc->polling = 0; | |
333 | dev_err(tsc->dev, "schedule failed"); | |
334 | goto err2; | |
335 | } | |
98417884 | 336 | platform_set_drvdata(pdev, tps6507x_dev); |
75259966 TF |
337 | |
338 | return 0; | |
339 | ||
340 | err2: | |
f7a2e302 | 341 | cancel_delayed_work_sync(&tsc->work); |
75259966 TF |
342 | input_free_device(input_dev); |
343 | err1: | |
344 | kfree(tsc); | |
345 | tps6507x_dev->ts = NULL; | |
346 | err0: | |
347 | return error; | |
348 | } | |
349 | ||
350 | static int __devexit tps6507x_ts_remove(struct platform_device *pdev) | |
351 | { | |
352 | struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev); | |
353 | struct tps6507x_ts *tsc = tps6507x_dev->ts; | |
354 | struct input_dev *input_dev = tsc->input_dev; | |
355 | ||
f7a2e302 | 356 | cancel_delayed_work_sync(&tsc->work); |
75259966 | 357 | |
8a26f5d1 | 358 | input_unregister_device(input_dev); |
75259966 TF |
359 | |
360 | tps6507x_dev->ts = NULL; | |
361 | kfree(tsc); | |
362 | ||
363 | return 0; | |
364 | } | |
365 | ||
366 | static struct platform_driver tps6507x_ts_driver = { | |
367 | .driver = { | |
368 | .name = "tps6507x-ts", | |
369 | .owner = THIS_MODULE, | |
370 | }, | |
371 | .probe = tps6507x_ts_probe, | |
372 | .remove = __devexit_p(tps6507x_ts_remove), | |
373 | }; | |
374 | ||
375 | static int __init tps6507x_ts_init(void) | |
376 | { | |
377 | return platform_driver_register(&tps6507x_ts_driver); | |
378 | } | |
379 | module_init(tps6507x_ts_init); | |
380 | ||
381 | static void __exit tps6507x_ts_exit(void) | |
382 | { | |
383 | platform_driver_unregister(&tps6507x_ts_driver); | |
384 | } | |
385 | module_exit(tps6507x_ts_exit); | |
386 | ||
387 | MODULE_AUTHOR("Todd Fischer <todd.fischer@ridgerun.com>"); | |
388 | MODULE_DESCRIPTION("TPS6507x - TouchScreen driver"); | |
389 | MODULE_LICENSE("GPL v2"); | |
390 | MODULE_ALIAS("platform:tps6507x-tsc"); |