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
 30#define TSC2007_MEASURE_TEMP0		(0x0 << 4)
 31#define TSC2007_MEASURE_AUX		(0x2 << 4)
 32#define TSC2007_MEASURE_TEMP1		(0x4 << 4)
 33#define TSC2007_ACTIVATE_XN		(0x8 << 4)
 34#define TSC2007_ACTIVATE_YN		(0x9 << 4)
 35#define TSC2007_ACTIVATE_YP_XN		(0xa << 4)
 36#define TSC2007_SETUP			(0xb << 4)
 37#define TSC2007_MEASURE_X		(0xc << 4)
 38#define TSC2007_MEASURE_Y		(0xd << 4)
 39#define TSC2007_MEASURE_Z1		(0xe << 4)
 40#define TSC2007_MEASURE_Z2		(0xf << 4)
 41
 42#define TSC2007_POWER_OFF_IRQ_EN	(0x0 << 2)
 43#define TSC2007_ADC_ON_IRQ_DIS0		(0x1 << 2)
 44#define TSC2007_ADC_OFF_IRQ_EN		(0x2 << 2)
 45#define TSC2007_ADC_ON_IRQ_DIS1		(0x3 << 2)
 46
 47#define TSC2007_12BIT			(0x0 << 1)
 48#define TSC2007_8BIT			(0x1 << 1)
 49
 50#define	MAX_12BIT			((1 << 12) - 1)
 51
 52#define ADC_ON_12BIT	(TSC2007_12BIT | TSC2007_ADC_ON_IRQ_DIS0)
 53
 54#define READ_Y		(ADC_ON_12BIT | TSC2007_MEASURE_Y)
 55#define READ_Z1		(ADC_ON_12BIT | TSC2007_MEASURE_Z1)
 56#define READ_Z2		(ADC_ON_12BIT | TSC2007_MEASURE_Z2)
 57#define READ_X		(ADC_ON_12BIT | TSC2007_MEASURE_X)
 58#define PWRDOWN		(TSC2007_12BIT | TSC2007_POWER_OFF_IRQ_EN)
 59
 60struct ts_event {
 61	u16	x;
 62	u16	y;
 63	u16	z1, z2;
 64};
 65
 66struct tsc2007 {
 67	struct input_dev	*input;
 68	char			phys[32];
 69
 70	struct i2c_client	*client;
 71
 72	u16			model;
 73	u16			x_plate_ohms;
 74	u16			max_rt;
 75	unsigned long		poll_delay;
 76	unsigned long		poll_period;
 77
 78	int			irq;
 79
 80	wait_queue_head_t	wait;
 81	bool			stopped;
 82
 83	int			(*get_pendown_state)(void);
 84	void			(*clear_penirq)(void);
 85};
 86
 87static inline int tsc2007_xfer(struct tsc2007 *tsc, u8 cmd)
 88{
 89	s32 data;
 90	u16 val;
 91
 92	data = i2c_smbus_read_word_data(tsc->client, cmd);
 93	if (data < 0) {
 94		dev_err(&tsc->client->dev, "i2c io error: %d\n", data);
 95		return data;
 96	}
 97
 98	/* The protocol and raw data format from i2c interface:
 99	 * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
100	 * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit].
101	 */
102	val = swab16(data) >> 4;
103
104	dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val);
105
106	return val;
107}
108
109static void tsc2007_read_values(struct tsc2007 *tsc, struct ts_event *tc)
110{
111	/* y- still on; turn on only y+ (and ADC) */
112	tc->y = tsc2007_xfer(tsc, READ_Y);
113
114	/* turn y- off, x+ on, then leave in lowpower */
115	tc->x = tsc2007_xfer(tsc, READ_X);
116
117	/* turn y+ off, x- on; we'll use formula #1 */
118	tc->z1 = tsc2007_xfer(tsc, READ_Z1);
119	tc->z2 = tsc2007_xfer(tsc, READ_Z2);
120
121	/* Prepare for next touch reading - power down ADC, enable PENIRQ */
122	tsc2007_xfer(tsc, PWRDOWN);
123}
124
125static u32 tsc2007_calculate_pressure(struct tsc2007 *tsc, struct ts_event *tc)
126{
127	u32 rt = 0;
128
129	/* range filtering */
130	if (tc->x == MAX_12BIT)
131		tc->x = 0;
132
133	if (likely(tc->x && tc->z1)) {
134		/* compute touch pressure resistance using equation #1 */
135		rt = tc->z2 - tc->z1;
136		rt *= tc->x;
137		rt *= tsc->x_plate_ohms;
138		rt /= tc->z1;
139		rt = (rt + 2047) >> 12;
140	}
141
142	return rt;
143}
144
145static bool tsc2007_is_pen_down(struct tsc2007 *ts)
146{
147	/*
148	 * NOTE: We can't rely on the pressure to determine the pen down
149	 * state, even though this controller has a pressure sensor.
150	 * The pressure value can fluctuate for quite a while after
151	 * lifting the pen and in some cases may not even settle at the
152	 * expected value.
153	 *
154	 * The only safe way to check for the pen up condition is in the
155	 * work function by reading the pen signal state (it's a GPIO
156	 * and IRQ). Unfortunately such callback is not always available,
157	 * in that case we assume that the pen is down and expect caller
158	 * to fall back on the pressure reading.
159	 */
160
161	if (!ts->get_pendown_state)
162		return true;
163
164	return ts->get_pendown_state();
165}
166
167static irqreturn_t tsc2007_soft_irq(int irq, void *handle)
168{
169	struct tsc2007 *ts = handle;
170	struct input_dev *input = ts->input;
171	struct ts_event tc;
172	u32 rt;
173
174	while (!ts->stopped && tsc2007_is_pen_down(ts)) {
175
176		/* pen is down, continue with the measurement */
177		tsc2007_read_values(ts, &tc);
178
179		rt = tsc2007_calculate_pressure(ts, &tc);
180
181		if (rt == 0 && !ts->get_pendown_state) {
182			/*
183			 * If pressure reported is 0 and we don't have
184			 * callback to check pendown state, we have to
185			 * assume that pen was lifted up.
186			 */
187			break;
188		}
189
190		if (rt <= ts->max_rt) {
191			dev_dbg(&ts->client->dev,
192				"DOWN point(%4d,%4d), pressure (%4u)\n",
193				tc.x, tc.y, rt);
194
195			input_report_key(input, BTN_TOUCH, 1);
196			input_report_abs(input, ABS_X, tc.x);
197			input_report_abs(input, ABS_Y, tc.y);
198			input_report_abs(input, ABS_PRESSURE, rt);
199
200			input_sync(input);
201
202		} else {
203			/*
204			 * Sample found inconsistent by debouncing or pressure is
205			 * beyond the maximum. Don't report it to user space,
206			 * repeat at least once more the measurement.
207			 */
208			dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
209		}
210
211		wait_event_timeout(ts->wait, ts->stopped,
212				   msecs_to_jiffies(ts->poll_period));
213	}
214
215	dev_dbg(&ts->client->dev, "UP\n");
216
217	input_report_key(input, BTN_TOUCH, 0);
218	input_report_abs(input, ABS_PRESSURE, 0);
219	input_sync(input);
220
221	if (ts->clear_penirq)
222		ts->clear_penirq();
223
224	return IRQ_HANDLED;
225}
226
227static irqreturn_t tsc2007_hard_irq(int irq, void *handle)
228{
229	struct tsc2007 *ts = handle;
230
231	if (!ts->get_pendown_state || likely(ts->get_pendown_state()))
232		return IRQ_WAKE_THREAD;
233
234	if (ts->clear_penirq)
235		ts->clear_penirq();
236
237	return IRQ_HANDLED;
238}
239
240static void tsc2007_stop(struct tsc2007 *ts)
241{
242	ts->stopped = true;
243	mb();
244	wake_up(&ts->wait);
245
246	disable_irq(ts->irq);
247}
248
249static int tsc2007_open(struct input_dev *input_dev)
250{
251	struct tsc2007 *ts = input_get_drvdata(input_dev);
252	int err;
253
254	ts->stopped = false;
255	mb();
256
257	enable_irq(ts->irq);
258
259	/* Prepare for touch readings - power down ADC and enable PENIRQ */
260	err = tsc2007_xfer(ts, PWRDOWN);
261	if (err < 0) {
262		tsc2007_stop(ts);
263		return err;
264	}
265
266	return 0;
267}
268
269static void tsc2007_close(struct input_dev *input_dev)
270{
271	struct tsc2007 *ts = input_get_drvdata(input_dev);
272
273	tsc2007_stop(ts);
274}
275
276static int __devinit tsc2007_probe(struct i2c_client *client,
277				   const struct i2c_device_id *id)
278{
279	struct tsc2007 *ts;
280	struct tsc2007_platform_data *pdata = client->dev.platform_data;
281	struct input_dev *input_dev;
282	int err;
283
284	if (!pdata) {
285		dev_err(&client->dev, "platform data is required!\n");
286		return -EINVAL;
287	}
288
289	if (!i2c_check_functionality(client->adapter,
290				     I2C_FUNC_SMBUS_READ_WORD_DATA))
291		return -EIO;
292
293	ts = kzalloc(sizeof(struct tsc2007), GFP_KERNEL);
294	input_dev = input_allocate_device();
295	if (!ts || !input_dev) {
296		err = -ENOMEM;
297		goto err_free_mem;
298	}
299
300	ts->client = client;
301	ts->irq = client->irq;
302	ts->input = input_dev;
303	init_waitqueue_head(&ts->wait);
304
305	ts->model             = pdata->model;
306	ts->x_plate_ohms      = pdata->x_plate_ohms;
307	ts->max_rt            = pdata->max_rt ? : MAX_12BIT;
308	ts->poll_delay        = pdata->poll_delay ? : 1;
309	ts->poll_period       = pdata->poll_period ? : 1;
310	ts->get_pendown_state = pdata->get_pendown_state;
311	ts->clear_penirq      = pdata->clear_penirq;
312
313	if (pdata->x_plate_ohms == 0) {
314		dev_err(&client->dev, "x_plate_ohms is not set up in platform data");
315		err = -EINVAL;
316		goto err_free_mem;
317	}
318
319	snprintf(ts->phys, sizeof(ts->phys),
320		 "%s/input0", dev_name(&client->dev));
321
322	input_dev->name = "TSC2007 Touchscreen";
323	input_dev->phys = ts->phys;
324	input_dev->id.bustype = BUS_I2C;
325
326	input_dev->open = tsc2007_open;
327	input_dev->close = tsc2007_close;
328
329	input_set_drvdata(input_dev, ts);
330
331	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
332	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
333
334	input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, pdata->fuzzx, 0);
335	input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, pdata->fuzzy, 0);
336	input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT,
337			pdata->fuzzz, 0);
338
339	if (pdata->init_platform_hw)
340		pdata->init_platform_hw();
341
342	err = request_threaded_irq(ts->irq, tsc2007_hard_irq, tsc2007_soft_irq,
343				   IRQF_ONESHOT, client->dev.driver->name, ts);
344	if (err < 0) {
345		dev_err(&client->dev, "irq %d busy?\n", ts->irq);
346		goto err_free_mem;
347	}
348
349	tsc2007_stop(ts);
350
351	err = input_register_device(input_dev);
352	if (err)
353		goto err_free_irq;
354
355	i2c_set_clientdata(client, ts);
356
357	return 0;
358
359 err_free_irq:
360	free_irq(ts->irq, ts);
361	if (pdata->exit_platform_hw)
362		pdata->exit_platform_hw();
363 err_free_mem:
364	input_free_device(input_dev);
365	kfree(ts);
366	return err;
367}
368
369static int __devexit tsc2007_remove(struct i2c_client *client)
370{
371	struct tsc2007	*ts = i2c_get_clientdata(client);
372	struct tsc2007_platform_data *pdata = client->dev.platform_data;
373
374	free_irq(ts->irq, ts);
375
376	if (pdata->exit_platform_hw)
377		pdata->exit_platform_hw();
378
379	input_unregister_device(ts->input);
380	kfree(ts);
381
382	return 0;
383}
384
385static const struct i2c_device_id tsc2007_idtable[] = {
386	{ "tsc2007", 0 },
387	{ }
388};
389
390MODULE_DEVICE_TABLE(i2c, tsc2007_idtable);
391
392static struct i2c_driver tsc2007_driver = {
393	.driver = {
394		.owner	= THIS_MODULE,
395		.name	= "tsc2007"
396	},
397	.id_table	= tsc2007_idtable,
398	.probe		= tsc2007_probe,
399	.remove		= __devexit_p(tsc2007_remove),
400};
401
402module_i2c_driver(tsc2007_driver);
403
404MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>");
405MODULE_DESCRIPTION("TSC2007 TouchScreen Driver");
406MODULE_LICENSE("GPL");