1/*
2 * drivers/input/touchscreen/tsc2007.c
3 *
4 * Copyright (c) 2008 MtekVision Co., Ltd.
5 *	Kwangwoo Lee <kwlee@mtekvision.com>
6 *
7 * Using code from:
8 *  - ads7846.c
9 *	Copyright (c) 2005 David Brownell
10 *	Copyright (c) 2006 Nokia Corporation
11 *  - corgi_ts.c
12 *	Copyright (C) 2004-2005 Richard Purdie
13 *  - omap_ts.[hc], ads7846.h, ts_osk.c
14 *	Copyright (C) 2002 MontaVista Software
15 *	Copyright (C) 2004 Texas Instruments
16 *	Copyright (C) 2005 Dirk Behme
17 *
18 *  This program is free software; you can redistribute it and/or modify
19 *  it under the terms of the GNU General Public License version 2 as
20 *  published by the Free Software Foundation.
21 */
22
23#include <linux/module.h>
24#include <linux/slab.h>
25#include <linux/input.h>
26#include <linux/interrupt.h>
27#include <linux/i2c.h>
28#include <linux/i2c/tsc2007.h>
29#include <linux/of_device.h>
30#include <linux/of.h>
31#include <linux/of_gpio.h>
32
33#define TSC2007_MEASURE_TEMP0		(0x0 << 4)
34#define TSC2007_MEASURE_AUX		(0x2 << 4)
35#define TSC2007_MEASURE_TEMP1		(0x4 << 4)
36#define TSC2007_ACTIVATE_XN		(0x8 << 4)
37#define TSC2007_ACTIVATE_YN		(0x9 << 4)
38#define TSC2007_ACTIVATE_YP_XN		(0xa << 4)
39#define TSC2007_SETUP			(0xb << 4)
40#define TSC2007_MEASURE_X		(0xc << 4)
41#define TSC2007_MEASURE_Y		(0xd << 4)
42#define TSC2007_MEASURE_Z1		(0xe << 4)
43#define TSC2007_MEASURE_Z2		(0xf << 4)
44
45#define TSC2007_POWER_OFF_IRQ_EN	(0x0 << 2)
46#define TSC2007_ADC_ON_IRQ_DIS0		(0x1 << 2)
47#define TSC2007_ADC_OFF_IRQ_EN		(0x2 << 2)
48#define TSC2007_ADC_ON_IRQ_DIS1		(0x3 << 2)
49
50#define TSC2007_12BIT			(0x0 << 1)
51#define TSC2007_8BIT			(0x1 << 1)
52
53#define	MAX_12BIT			((1 << 12) - 1)
54
55#define ADC_ON_12BIT	(TSC2007_12BIT | TSC2007_ADC_ON_IRQ_DIS0)
56
57#define READ_Y		(ADC_ON_12BIT | TSC2007_MEASURE_Y)
58#define READ_Z1		(ADC_ON_12BIT | TSC2007_MEASURE_Z1)
59#define READ_Z2		(ADC_ON_12BIT | TSC2007_MEASURE_Z2)
60#define READ_X		(ADC_ON_12BIT | TSC2007_MEASURE_X)
61#define PWRDOWN		(TSC2007_12BIT | TSC2007_POWER_OFF_IRQ_EN)
62
63struct ts_event {
64	u16	x;
65	u16	y;
66	u16	z1, z2;
67};
68
69struct tsc2007 {
70	struct input_dev	*input;
71	char			phys[32];
72
73	struct i2c_client	*client;
74
75	u16			model;
76	u16			x_plate_ohms;
77	u16			max_rt;
78	unsigned long		poll_period; /* in jiffies */
79	int			fuzzx;
80	int			fuzzy;
81	int			fuzzz;
82
83	unsigned		gpio;
84	int			irq;
85
86	wait_queue_head_t	wait;
87	bool			stopped;
88
89	int			(*get_pendown_state)(struct device *);
90	void			(*clear_penirq)(void);
91};
92
93static inline int tsc2007_xfer(struct tsc2007 *tsc, u8 cmd)
94{
95	s32 data;
96	u16 val;
97
98	data = i2c_smbus_read_word_data(tsc->client, cmd);
99	if (data < 0) {
100		dev_err(&tsc->client->dev, "i2c io error: %d\n", data);
101		return data;
102	}
103
104	/* The protocol and raw data format from i2c interface:
105	 * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
106	 * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit].
107	 */
108	val = swab16(data) >> 4;
109
110	dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val);
111
112	return val;
113}
114
115static void tsc2007_read_values(struct tsc2007 *tsc, struct ts_event *tc)
116{
117	/* y- still on; turn on only y+ (and ADC) */
118	tc->y = tsc2007_xfer(tsc, READ_Y);
119
120	/* turn y- off, x+ on, then leave in lowpower */
121	tc->x = tsc2007_xfer(tsc, READ_X);
122
123	/* turn y+ off, x- on; we'll use formula #1 */
124	tc->z1 = tsc2007_xfer(tsc, READ_Z1);
125	tc->z2 = tsc2007_xfer(tsc, READ_Z2);
126
127	/* Prepare for next touch reading - power down ADC, enable PENIRQ */
128	tsc2007_xfer(tsc, PWRDOWN);
129}
130
131static u32 tsc2007_calculate_pressure(struct tsc2007 *tsc, struct ts_event *tc)
132{
133	u32 rt = 0;
134
135	/* range filtering */
136	if (tc->x == MAX_12BIT)
137		tc->x = 0;
138
139	if (likely(tc->x && tc->z1)) {
140		/* compute touch pressure resistance using equation #1 */
141		rt = tc->z2 - tc->z1;
142		rt *= tc->x;
143		rt *= tsc->x_plate_ohms;
144		rt /= tc->z1;
145		rt = (rt + 2047) >> 12;
146	}
147
148	return rt;
149}
150
151static bool tsc2007_is_pen_down(struct tsc2007 *ts)
152{
153	/*
154	 * NOTE: We can't rely on the pressure to determine the pen down
155	 * state, even though this controller has a pressure sensor.
156	 * The pressure value can fluctuate for quite a while after
157	 * lifting the pen and in some cases may not even settle at the
158	 * expected value.
159	 *
160	 * The only safe way to check for the pen up condition is in the
161	 * work function by reading the pen signal state (it's a GPIO
162	 * and IRQ). Unfortunately such callback is not always available,
163	 * in that case we assume that the pen is down and expect caller
164	 * to fall back on the pressure reading.
165	 */
166
167	if (!ts->get_pendown_state)
168		return true;
169
170	return ts->get_pendown_state(&ts->client->dev);
171}
172
173static irqreturn_t tsc2007_soft_irq(int irq, void *handle)
174{
175	struct tsc2007 *ts = handle;
176	struct input_dev *input = ts->input;
177	struct ts_event tc;
178	u32 rt;
179
180	while (!ts->stopped && tsc2007_is_pen_down(ts)) {
181
182		/* pen is down, continue with the measurement */
183		tsc2007_read_values(ts, &tc);
184
185		rt = tsc2007_calculate_pressure(ts, &tc);
186
187		if (!rt && !ts->get_pendown_state) {
188			/*
189			 * If pressure reported is 0 and we don't have
190			 * callback to check pendown state, we have to
191			 * assume that pen was lifted up.
192			 */
193			break;
194		}
195
196		if (rt <= ts->max_rt) {
197			dev_dbg(&ts->client->dev,
198				"DOWN point(%4d,%4d), pressure (%4u)\n",
199				tc.x, tc.y, rt);
200
201			input_report_key(input, BTN_TOUCH, 1);
202			input_report_abs(input, ABS_X, tc.x);
203			input_report_abs(input, ABS_Y, tc.y);
204			input_report_abs(input, ABS_PRESSURE, rt);
205
206			input_sync(input);
207
208		} else {
209			/*
210			 * Sample found inconsistent by debouncing or pressure is
211			 * beyond the maximum. Don't report it to user space,
212			 * repeat at least once more the measurement.
213			 */
214			dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
215		}
216
217		wait_event_timeout(ts->wait, ts->stopped, ts->poll_period);
218	}
219
220	dev_dbg(&ts->client->dev, "UP\n");
221
222	input_report_key(input, BTN_TOUCH, 0);
223	input_report_abs(input, ABS_PRESSURE, 0);
224	input_sync(input);
225
226	if (ts->clear_penirq)
227		ts->clear_penirq();
228
229	return IRQ_HANDLED;
230}
231
232static irqreturn_t tsc2007_hard_irq(int irq, void *handle)
233{
234	struct tsc2007 *ts = handle;
235
236	if (tsc2007_is_pen_down(ts))
237		return IRQ_WAKE_THREAD;
238
239	if (ts->clear_penirq)
240		ts->clear_penirq();
241
242	return IRQ_HANDLED;
243}
244
245static void tsc2007_stop(struct tsc2007 *ts)
246{
247	ts->stopped = true;
248	mb();
249	wake_up(&ts->wait);
250
251	disable_irq(ts->irq);
252}
253
254static int tsc2007_open(struct input_dev *input_dev)
255{
256	struct tsc2007 *ts = input_get_drvdata(input_dev);
257	int err;
258
259	ts->stopped = false;
260	mb();
261
262	enable_irq(ts->irq);
263
264	/* Prepare for touch readings - power down ADC and enable PENIRQ */
265	err = tsc2007_xfer(ts, PWRDOWN);
266	if (err < 0) {
267		tsc2007_stop(ts);
268		return err;
269	}
270
271	return 0;
272}
273
274static void tsc2007_close(struct input_dev *input_dev)
275{
276	struct tsc2007 *ts = input_get_drvdata(input_dev);
277
278	tsc2007_stop(ts);
279}
280
281#ifdef CONFIG_OF
282static int tsc2007_get_pendown_state_gpio(struct device *dev)
283{
284	struct i2c_client *client = to_i2c_client(dev);
285	struct tsc2007 *ts = i2c_get_clientdata(client);
286
287	return !gpio_get_value(ts->gpio);
288}
289
290static int tsc2007_probe_dt(struct i2c_client *client, struct tsc2007 *ts)
291{
292	struct device_node *np = client->dev.of_node;
293	u32 val32;
294	u64 val64;
295
296	if (!np) {
297		dev_err(&client->dev, "missing device tree data\n");
298		return -EINVAL;
299	}
300
301	if (!of_property_read_u32(np, "ti,max-rt", &val32))
302		ts->max_rt = val32;
303	else
304		ts->max_rt = MAX_12BIT;
305
306	if (!of_property_read_u32(np, "ti,fuzzx", &val32))
307		ts->fuzzx = val32;
308
309	if (!of_property_read_u32(np, "ti,fuzzy", &val32))
310		ts->fuzzy = val32;
311
312	if (!of_property_read_u32(np, "ti,fuzzz", &val32))
313		ts->fuzzz = val32;
314
315	if (!of_property_read_u64(np, "ti,poll-period", &val64))
316		ts->poll_period = msecs_to_jiffies(val64);
317	else
318		ts->poll_period = msecs_to_jiffies(1);
319
320	if (!of_property_read_u32(np, "ti,x-plate-ohms", &val32)) {
321		ts->x_plate_ohms = val32;
322	} else {
323		dev_err(&client->dev, "missing ti,x-plate-ohms devicetree property.");
324		return -EINVAL;
325	}
326
327	ts->gpio = of_get_gpio(np, 0);
328	if (gpio_is_valid(ts->gpio))
329		ts->get_pendown_state = tsc2007_get_pendown_state_gpio;
330	else
331		dev_warn(&client->dev,
332			 "GPIO not specified in DT (of_get_gpio returned %d)\n",
333			 ts->gpio);
334
335	return 0;
336}
337#else
338static int tsc2007_probe_dt(struct i2c_client *client, struct tsc2007 *ts)
339{
340	dev_err(&client->dev, "platform data is required!\n");
341	return -EINVAL;
342}
343#endif
344
345static int tsc2007_probe_pdev(struct i2c_client *client, struct tsc2007 *ts,
346			      const struct tsc2007_platform_data *pdata,
347			      const struct i2c_device_id *id)
348{
349	ts->model             = pdata->model;
350	ts->x_plate_ohms      = pdata->x_plate_ohms;
351	ts->max_rt            = pdata->max_rt ? : MAX_12BIT;
352	ts->poll_period       = msecs_to_jiffies(pdata->poll_period ? : 1);
353	ts->get_pendown_state = pdata->get_pendown_state;
354	ts->clear_penirq      = pdata->clear_penirq;
355	ts->fuzzx             = pdata->fuzzx;
356	ts->fuzzy             = pdata->fuzzy;
357	ts->fuzzz             = pdata->fuzzz;
358
359	if (pdata->x_plate_ohms == 0) {
360		dev_err(&client->dev, "x_plate_ohms is not set up in platform data");
361		return -EINVAL;
362	}
363
364	return 0;
365}
366
367static void tsc2007_call_exit_platform_hw(void *data)
368{
369	struct device *dev = data;
370	const struct tsc2007_platform_data *pdata = dev_get_platdata(dev);
371
372	pdata->exit_platform_hw();
373}
374
375static int tsc2007_probe(struct i2c_client *client,
376			 const struct i2c_device_id *id)
377{
378	const struct tsc2007_platform_data *pdata = dev_get_platdata(&client->dev);
379	struct tsc2007 *ts;
380	struct input_dev *input_dev;
381	int err;
382
383	if (!i2c_check_functionality(client->adapter,
384				     I2C_FUNC_SMBUS_READ_WORD_DATA))
385		return -EIO;
386
387	ts = devm_kzalloc(&client->dev, sizeof(struct tsc2007), GFP_KERNEL);
388	if (!ts)
389		return -ENOMEM;
390
391	if (pdata)
392		err = tsc2007_probe_pdev(client, ts, pdata, id);
393	else
394		err = tsc2007_probe_dt(client, ts);
395	if (err)
396		return err;
397
398	input_dev = devm_input_allocate_device(&client->dev);
399	if (!input_dev)
400		return -ENOMEM;
401
402	i2c_set_clientdata(client, ts);
403
404	ts->client = client;
405	ts->irq = client->irq;
406	ts->input = input_dev;
407	init_waitqueue_head(&ts->wait);
408
409	snprintf(ts->phys, sizeof(ts->phys),
410		 "%s/input0", dev_name(&client->dev));
411
412	input_dev->name = "TSC2007 Touchscreen";
413	input_dev->phys = ts->phys;
414	input_dev->id.bustype = BUS_I2C;
415
416	input_dev->open = tsc2007_open;
417	input_dev->close = tsc2007_close;
418
419	input_set_drvdata(input_dev, ts);
420
421	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
422	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
423
424	input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, ts->fuzzx, 0);
425	input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, ts->fuzzy, 0);
426	input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT,
427			     ts->fuzzz, 0);
428
429	if (pdata) {
430		if (pdata->exit_platform_hw) {
431			err = devm_add_action(&client->dev,
432					      tsc2007_call_exit_platform_hw,
433					      &client->dev);
434			if (err) {
435				dev_err(&client->dev,
436					"Failed to register exit_platform_hw action, %d\n",
437					err);
438				return err;
439			}
440		}
441
442		if (pdata->init_platform_hw)
443			pdata->init_platform_hw();
444	}
445
446	err = devm_request_threaded_irq(&client->dev, ts->irq,
447					tsc2007_hard_irq, tsc2007_soft_irq,
448					IRQF_ONESHOT,
449					client->dev.driver->name, ts);
450	if (err) {
451		dev_err(&client->dev, "Failed to request irq %d: %d\n",
452			ts->irq, err);
453		return err;
454	}
455
456	tsc2007_stop(ts);
457
458	err = input_register_device(input_dev);
459	if (err) {
460		dev_err(&client->dev,
461			"Failed to register input device: %d\n", err);
462		return err;
463	}
464
465	return 0;
466}
467
468static const struct i2c_device_id tsc2007_idtable[] = {
469	{ "tsc2007", 0 },
470	{ }
471};
472
473MODULE_DEVICE_TABLE(i2c, tsc2007_idtable);
474
475#ifdef CONFIG_OF
476static const struct of_device_id tsc2007_of_match[] = {
477	{ .compatible = "ti,tsc2007" },
478	{ /* sentinel */ }
479};
480MODULE_DEVICE_TABLE(of, tsc2007_of_match);
481#endif
482
483static struct i2c_driver tsc2007_driver = {
484	.driver = {
485		.owner	= THIS_MODULE,
486		.name	= "tsc2007",
487		.of_match_table = of_match_ptr(tsc2007_of_match),
488	},
489	.id_table	= tsc2007_idtable,
490	.probe		= tsc2007_probe,
491};
492
493module_i2c_driver(tsc2007_driver);
494
495MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>");
496MODULE_DESCRIPTION("TSC2007 TouchScreen Driver");
497MODULE_LICENSE("GPL");
498