1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Touchscreen driver for Dialog Semiconductor DA9034
4  *
5  * Copyright (C) 2006-2008 Marvell International Ltd.
6  *	Fengwei Yin <fengwei.yin@marvell.com>
7  *	Bin Yang  <bin.yang@marvell.com>
8  *	Eric Miao <eric.miao@marvell.com>
9  */
10 
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/delay.h>
14 #include <linux/platform_device.h>
15 #include <linux/input.h>
16 #include <linux/workqueue.h>
17 #include <linux/mfd/da903x.h>
18 #include <linux/slab.h>
19 
20 #define DA9034_MANUAL_CTRL	0x50
21 #define DA9034_LDO_ADC_EN	(1 << 4)
22 
23 #define DA9034_AUTO_CTRL1	0x51
24 
25 #define DA9034_AUTO_CTRL2	0x52
26 #define DA9034_AUTO_TSI_EN	(1 << 3)
27 #define DA9034_PEN_DETECT	(1 << 4)
28 
29 #define DA9034_TSI_CTRL1	0x53
30 #define DA9034_TSI_CTRL2	0x54
31 #define DA9034_TSI_X_MSB	0x6c
32 #define DA9034_TSI_Y_MSB	0x6d
33 #define DA9034_TSI_XY_LSB	0x6e
34 
35 enum {
36 	STATE_IDLE,	/* wait for pendown */
37 	STATE_BUSY,	/* TSI busy sampling */
38 	STATE_STOP,	/* sample available */
39 	STATE_WAIT,	/* Wait to start next sample */
40 };
41 
42 enum {
43 	EVENT_PEN_DOWN,
44 	EVENT_PEN_UP,
45 	EVENT_TSI_READY,
46 	EVENT_TIMEDOUT,
47 };
48 
49 struct da9034_touch {
50 	struct device		*da9034_dev;
51 	struct input_dev	*input_dev;
52 
53 	struct delayed_work	tsi_work;
54 	struct notifier_block	notifier;
55 
56 	int	state;
57 
58 	int	interval_ms;
59 	int	x_inverted;
60 	int	y_inverted;
61 
62 	int	last_x;
63 	int	last_y;
64 };
65 
66 static inline int is_pen_down(struct da9034_touch *touch)
67 {
68 	return da903x_query_status(touch->da9034_dev, DA9034_STATUS_PEN_DOWN);
69 }
70 
71 static inline int detect_pen_down(struct da9034_touch *touch, int on)
72 {
73 	if (on)
74 		return da903x_set_bits(touch->da9034_dev,
75 				DA9034_AUTO_CTRL2, DA9034_PEN_DETECT);
76 	else
77 		return da903x_clr_bits(touch->da9034_dev,
78 				DA9034_AUTO_CTRL2, DA9034_PEN_DETECT);
79 }
80 
81 static int read_tsi(struct da9034_touch *touch)
82 {
83 	uint8_t _x, _y, _v;
84 	int ret;
85 
86 	ret = da903x_read(touch->da9034_dev, DA9034_TSI_X_MSB, &_x);
87 	if (ret)
88 		return ret;
89 
90 	ret = da903x_read(touch->da9034_dev, DA9034_TSI_Y_MSB, &_y);
91 	if (ret)
92 		return ret;
93 
94 	ret = da903x_read(touch->da9034_dev, DA9034_TSI_XY_LSB, &_v);
95 	if (ret)
96 		return ret;
97 
98 	touch->last_x = ((_x << 2) & 0x3fc) | (_v & 0x3);
99 	touch->last_y = ((_y << 2) & 0x3fc) | ((_v & 0xc) >> 2);
100 
101 	return 0;
102 }
103 
104 static inline int start_tsi(struct da9034_touch *touch)
105 {
106 	return da903x_set_bits(touch->da9034_dev,
107 			DA9034_AUTO_CTRL2, DA9034_AUTO_TSI_EN);
108 }
109 
110 static inline int stop_tsi(struct da9034_touch *touch)
111 {
112 	return da903x_clr_bits(touch->da9034_dev,
113 			DA9034_AUTO_CTRL2, DA9034_AUTO_TSI_EN);
114 }
115 
116 static inline void report_pen_down(struct da9034_touch *touch)
117 {
118 	int x = touch->last_x;
119 	int y = touch->last_y;
120 
121 	x &= 0xfff;
122 	if (touch->x_inverted)
123 		x = 1024 - x;
124 	y &= 0xfff;
125 	if (touch->y_inverted)
126 		y = 1024 - y;
127 
128 	input_report_abs(touch->input_dev, ABS_X, x);
129 	input_report_abs(touch->input_dev, ABS_Y, y);
130 	input_report_key(touch->input_dev, BTN_TOUCH, 1);
131 
132 	input_sync(touch->input_dev);
133 }
134 
135 static inline void report_pen_up(struct da9034_touch *touch)
136 {
137 	input_report_key(touch->input_dev, BTN_TOUCH, 0);
138 	input_sync(touch->input_dev);
139 }
140 
141 static void da9034_event_handler(struct da9034_touch *touch, int event)
142 {
143 	int err;
144 
145 	switch (touch->state) {
146 	case STATE_IDLE:
147 		if (event != EVENT_PEN_DOWN)
148 			break;
149 
150 		/* Enable auto measurement of the TSI, this will
151 		 * automatically disable pen down detection
152 		 */
153 		err = start_tsi(touch);
154 		if (err)
155 			goto err_reset;
156 
157 		touch->state = STATE_BUSY;
158 		break;
159 
160 	case STATE_BUSY:
161 		if (event != EVENT_TSI_READY)
162 			break;
163 
164 		err = read_tsi(touch);
165 		if (err)
166 			goto err_reset;
167 
168 		/* Disable auto measurement of the TSI, so that
169 		 * pen down status will be available
170 		 */
171 		err = stop_tsi(touch);
172 		if (err)
173 			goto err_reset;
174 
175 		touch->state = STATE_STOP;
176 
177 		/* FIXME: PEN_{UP/DOWN} events are expected to be
178 		 * available by stopping TSI, but this is found not
179 		 * always true, delay and simulate such an event
180 		 * here is more reliable
181 		 */
182 		mdelay(1);
183 		da9034_event_handler(touch,
184 				     is_pen_down(touch) ? EVENT_PEN_DOWN :
185 							  EVENT_PEN_UP);
186 		break;
187 
188 	case STATE_STOP:
189 		if (event == EVENT_PEN_DOWN) {
190 			report_pen_down(touch);
191 			schedule_delayed_work(&touch->tsi_work,
192 				msecs_to_jiffies(touch->interval_ms));
193 			touch->state = STATE_WAIT;
194 		}
195 
196 		if (event == EVENT_PEN_UP) {
197 			report_pen_up(touch);
198 			touch->state = STATE_IDLE;
199 		}
200 		break;
201 
202 	case STATE_WAIT:
203 		if (event != EVENT_TIMEDOUT)
204 			break;
205 
206 		if (is_pen_down(touch)) {
207 			start_tsi(touch);
208 			touch->state = STATE_BUSY;
209 		} else {
210 			report_pen_up(touch);
211 			touch->state = STATE_IDLE;
212 		}
213 		break;
214 	}
215 	return;
216 
217 err_reset:
218 	touch->state = STATE_IDLE;
219 	stop_tsi(touch);
220 	detect_pen_down(touch, 1);
221 }
222 
223 static void da9034_tsi_work(struct work_struct *work)
224 {
225 	struct da9034_touch *touch =
226 		container_of(work, struct da9034_touch, tsi_work.work);
227 
228 	da9034_event_handler(touch, EVENT_TIMEDOUT);
229 }
230 
231 static int da9034_touch_notifier(struct notifier_block *nb,
232 				 unsigned long event, void *data)
233 {
234 	struct da9034_touch *touch =
235 		container_of(nb, struct da9034_touch, notifier);
236 
237 	if (event & DA9034_EVENT_TSI_READY)
238 		da9034_event_handler(touch, EVENT_TSI_READY);
239 
240 	if ((event & DA9034_EVENT_PEN_DOWN) && touch->state == STATE_IDLE)
241 		da9034_event_handler(touch, EVENT_PEN_DOWN);
242 
243 	return 0;
244 }
245 
246 static int da9034_touch_open(struct input_dev *dev)
247 {
248 	struct da9034_touch *touch = input_get_drvdata(dev);
249 	int ret;
250 
251 	ret = da903x_register_notifier(touch->da9034_dev, &touch->notifier,
252 			DA9034_EVENT_PEN_DOWN | DA9034_EVENT_TSI_READY);
253 	if (ret)
254 		return -EBUSY;
255 
256 	/* Enable ADC LDO */
257 	ret = da903x_set_bits(touch->da9034_dev,
258 			DA9034_MANUAL_CTRL, DA9034_LDO_ADC_EN);
259 	if (ret)
260 		return ret;
261 
262 	/* TSI_DELAY: 3 slots, TSI_SKIP: 3 slots */
263 	ret = da903x_write(touch->da9034_dev, DA9034_TSI_CTRL1, 0x1b);
264 	if (ret)
265 		return ret;
266 
267 	ret = da903x_write(touch->da9034_dev, DA9034_TSI_CTRL2, 0x00);
268 	if (ret)
269 		return ret;
270 
271 	touch->state = STATE_IDLE;
272 	detect_pen_down(touch, 1);
273 
274 	return 0;
275 }
276 
277 static void da9034_touch_close(struct input_dev *dev)
278 {
279 	struct da9034_touch *touch = input_get_drvdata(dev);
280 
281 	da903x_unregister_notifier(touch->da9034_dev, &touch->notifier,
282 			DA9034_EVENT_PEN_DOWN | DA9034_EVENT_TSI_READY);
283 
284 	cancel_delayed_work_sync(&touch->tsi_work);
285 
286 	touch->state = STATE_IDLE;
287 	stop_tsi(touch);
288 	detect_pen_down(touch, 0);
289 
290 	/* Disable ADC LDO */
291 	da903x_clr_bits(touch->da9034_dev,
292 			DA9034_MANUAL_CTRL, DA9034_LDO_ADC_EN);
293 }
294 
295 
296 static int da9034_touch_probe(struct platform_device *pdev)
297 {
298 	struct da9034_touch_pdata *pdata = dev_get_platdata(&pdev->dev);
299 	struct da9034_touch *touch;
300 	struct input_dev *input_dev;
301 	int error;
302 
303 	touch = devm_kzalloc(&pdev->dev, sizeof(struct da9034_touch),
304 			     GFP_KERNEL);
305 	if (!touch) {
306 		dev_err(&pdev->dev, "failed to allocate driver data\n");
307 		return -ENOMEM;
308 	}
309 
310 	touch->da9034_dev = pdev->dev.parent;
311 
312 	if (pdata) {
313 		touch->interval_ms	= pdata->interval_ms;
314 		touch->x_inverted	= pdata->x_inverted;
315 		touch->y_inverted	= pdata->y_inverted;
316 	} else {
317 		/* fallback into default */
318 		touch->interval_ms	= 10;
319 	}
320 
321 	INIT_DELAYED_WORK(&touch->tsi_work, da9034_tsi_work);
322 	touch->notifier.notifier_call = da9034_touch_notifier;
323 
324 	input_dev = devm_input_allocate_device(&pdev->dev);
325 	if (!input_dev) {
326 		dev_err(&pdev->dev, "failed to allocate input device\n");
327 		return -ENOMEM;
328 	}
329 
330 	input_dev->name		= pdev->name;
331 	input_dev->open		= da9034_touch_open;
332 	input_dev->close	= da9034_touch_close;
333 	input_dev->dev.parent	= &pdev->dev;
334 
335 	__set_bit(EV_ABS, input_dev->evbit);
336 	__set_bit(ABS_X, input_dev->absbit);
337 	__set_bit(ABS_Y, input_dev->absbit);
338 	input_set_abs_params(input_dev, ABS_X, 0, 1023, 0, 0);
339 	input_set_abs_params(input_dev, ABS_Y, 0, 1023, 0, 0);
340 
341 	__set_bit(EV_KEY, input_dev->evbit);
342 	__set_bit(BTN_TOUCH, input_dev->keybit);
343 
344 	touch->input_dev = input_dev;
345 	input_set_drvdata(input_dev, touch);
346 
347 	error = input_register_device(input_dev);
348 	if (error)
349 		return error;
350 
351 	return 0;
352 }
353 
354 static struct platform_driver da9034_touch_driver = {
355 	.driver	= {
356 		.name	= "da9034-touch",
357 	},
358 	.probe		= da9034_touch_probe,
359 };
360 module_platform_driver(da9034_touch_driver);
361 
362 MODULE_DESCRIPTION("Touchscreen driver for Dialog Semiconductor DA9034");
363 MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>, Bin Yang <bin.yang@marvell.com>");
364 MODULE_LICENSE("GPL");
365 MODULE_ALIAS("platform:da9034-touch");
366