1 /*
2  * Driver for cypress touch screen controller
3  *
4  * Copyright (c) 2009 Aava Mobile
5  *
6  * Some cleanups by Alan Cox <alan@linux.intel.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21 
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/input.h>
25 #include <linux/slab.h>
26 #include <linux/interrupt.h>
27 #include <linux/io.h>
28 #include <linux/i2c.h>
29 #include <linux/gpio.h>
30 #include <linux/input/cy8ctmg110_pdata.h>
31 
32 #define CY8CTMG110_DRIVER_NAME      "cy8ctmg110"
33 
34 /* Touch coordinates */
35 #define CY8CTMG110_X_MIN		0
36 #define CY8CTMG110_Y_MIN		0
37 #define CY8CTMG110_X_MAX		759
38 #define CY8CTMG110_Y_MAX		465
39 
40 
41 /* cy8ctmg110 register definitions */
42 #define CY8CTMG110_TOUCH_WAKEUP_TIME	0
43 #define CY8CTMG110_TOUCH_SLEEP_TIME	2
44 #define CY8CTMG110_TOUCH_X1		3
45 #define CY8CTMG110_TOUCH_Y1		5
46 #define CY8CTMG110_TOUCH_X2		7
47 #define CY8CTMG110_TOUCH_Y2		9
48 #define CY8CTMG110_FINGERS		11
49 #define CY8CTMG110_GESTURE		12
50 #define CY8CTMG110_REG_MAX		13
51 
52 
53 /*
54  * The touch driver structure.
55  */
56 struct cy8ctmg110 {
57 	struct input_dev *input;
58 	char phys[32];
59 	struct i2c_client *client;
60 	int reset_pin;
61 	int irq_pin;
62 };
63 
64 /*
65  * cy8ctmg110_power is the routine that is called when touch hardware
66  * will powered off or on.
67  */
68 static void cy8ctmg110_power(struct cy8ctmg110 *ts, bool poweron)
69 {
70 	if (ts->reset_pin)
71 		gpio_direction_output(ts->reset_pin, 1 - poweron);
72 }
73 
74 static int cy8ctmg110_write_regs(struct cy8ctmg110 *tsc, unsigned char reg,
75 		unsigned char len, unsigned char *value)
76 {
77 	struct i2c_client *client = tsc->client;
78 	int ret;
79 	unsigned char i2c_data[6];
80 
81 	BUG_ON(len > 5);
82 
83 	i2c_data[0] = reg;
84 	memcpy(i2c_data + 1, value, len);
85 
86 	ret = i2c_master_send(client, i2c_data, len + 1);
87 	if (ret != 1) {
88 		dev_err(&client->dev, "i2c write data cmd failed\n");
89 		return ret ? ret : -EIO;
90 	}
91 
92 	return 0;
93 }
94 
95 static int cy8ctmg110_read_regs(struct cy8ctmg110 *tsc,
96 		unsigned char *data, unsigned char len, unsigned char cmd)
97 {
98 	struct i2c_client *client = tsc->client;
99 	int ret;
100 	struct i2c_msg msg[2] = {
101 		/* first write slave position to i2c devices */
102 		{ client->addr, 0, 1, &cmd },
103 		/* Second read data from position */
104 		{ client->addr, I2C_M_RD, len, data }
105 	};
106 
107 	ret = i2c_transfer(client->adapter, msg, 2);
108 	if (ret < 0)
109 		return ret;
110 
111 	return 0;
112 }
113 
114 static int cy8ctmg110_touch_pos(struct cy8ctmg110 *tsc)
115 {
116 	struct input_dev *input = tsc->input;
117 	unsigned char reg_p[CY8CTMG110_REG_MAX];
118 	int x, y;
119 
120 	memset(reg_p, 0, CY8CTMG110_REG_MAX);
121 
122 	/* Reading coordinates */
123 	if (cy8ctmg110_read_regs(tsc, reg_p, 9, CY8CTMG110_TOUCH_X1) != 0)
124 		return -EIO;
125 
126 	y = reg_p[2] << 8 | reg_p[3];
127 	x = reg_p[0] << 8 | reg_p[1];
128 
129 	/* Number of touch */
130 	if (reg_p[8] == 0) {
131 		input_report_key(input, BTN_TOUCH, 0);
132 	} else  {
133 		input_report_key(input, BTN_TOUCH, 1);
134 		input_report_abs(input, ABS_X, x);
135 		input_report_abs(input, ABS_Y, y);
136 	}
137 
138 	input_sync(input);
139 
140 	return 0;
141 }
142 
143 static int cy8ctmg110_set_sleepmode(struct cy8ctmg110 *ts, bool sleep)
144 {
145 	unsigned char reg_p[3];
146 
147 	if (sleep) {
148 		reg_p[0] = 0x00;
149 		reg_p[1] = 0xff;
150 		reg_p[2] = 5;
151 	} else {
152 		reg_p[0] = 0x10;
153 		reg_p[1] = 0xff;
154 		reg_p[2] = 0;
155 	}
156 
157 	return cy8ctmg110_write_regs(ts, CY8CTMG110_TOUCH_WAKEUP_TIME, 3, reg_p);
158 }
159 
160 static irqreturn_t cy8ctmg110_irq_thread(int irq, void *dev_id)
161 {
162 	struct cy8ctmg110 *tsc = dev_id;
163 
164 	cy8ctmg110_touch_pos(tsc);
165 
166 	return IRQ_HANDLED;
167 }
168 
169 static int __devinit cy8ctmg110_probe(struct i2c_client *client,
170 					const struct i2c_device_id *id)
171 {
172 	const struct cy8ctmg110_pdata *pdata = client->dev.platform_data;
173 	struct cy8ctmg110 *ts;
174 	struct input_dev *input_dev;
175 	int err;
176 
177 	/* No pdata no way forward */
178 	if (pdata == NULL) {
179 		dev_err(&client->dev, "no pdata\n");
180 		return -ENODEV;
181 	}
182 
183 	if (!i2c_check_functionality(client->adapter,
184 					I2C_FUNC_SMBUS_READ_WORD_DATA))
185 		return -EIO;
186 
187 	ts = kzalloc(sizeof(struct cy8ctmg110), GFP_KERNEL);
188 	input_dev = input_allocate_device();
189 	if (!ts || !input_dev) {
190 		err = -ENOMEM;
191 		goto err_free_mem;
192 	}
193 
194 	ts->client = client;
195 	ts->input = input_dev;
196 
197 	snprintf(ts->phys, sizeof(ts->phys),
198 		 "%s/input0", dev_name(&client->dev));
199 
200 	input_dev->name = CY8CTMG110_DRIVER_NAME " Touchscreen";
201 	input_dev->phys = ts->phys;
202 	input_dev->id.bustype = BUS_I2C;
203 	input_dev->dev.parent = &client->dev;
204 
205 	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
206 	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
207 
208 	input_set_abs_params(input_dev, ABS_X,
209 			CY8CTMG110_X_MIN, CY8CTMG110_X_MAX, 4, 0);
210 	input_set_abs_params(input_dev, ABS_Y,
211 			CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 4, 0);
212 
213 	if (ts->reset_pin) {
214 		err = gpio_request(ts->reset_pin, NULL);
215 		if (err) {
216 			dev_err(&client->dev,
217 				"Unable to request GPIO pin %d.\n",
218 				ts->reset_pin);
219 			goto err_free_mem;
220 		}
221 	}
222 
223 	cy8ctmg110_power(ts, true);
224 	cy8ctmg110_set_sleepmode(ts, false);
225 
226 	err = gpio_request(ts->irq_pin, "touch_irq_key");
227 	if (err < 0) {
228 		dev_err(&client->dev,
229 			"Failed to request GPIO %d, error %d\n",
230 			ts->irq_pin, err);
231 		goto err_shutoff_device;
232 	}
233 
234 	err = gpio_direction_input(ts->irq_pin);
235 	if (err < 0) {
236 		dev_err(&client->dev,
237 			"Failed to configure input direction for GPIO %d, error %d\n",
238 			ts->irq_pin, err);
239 		goto err_free_irq_gpio;
240 	}
241 
242 	client->irq = gpio_to_irq(ts->irq_pin);
243 	if (client->irq < 0) {
244 		err = client->irq;
245 		dev_err(&client->dev,
246 			"Unable to get irq number for GPIO %d, error %d\n",
247 			ts->irq_pin, err);
248 		goto err_free_irq_gpio;
249 	}
250 
251 	err = request_threaded_irq(client->irq, NULL, cy8ctmg110_irq_thread,
252 				   IRQF_TRIGGER_RISING, "touch_reset_key", ts);
253 	if (err < 0) {
254 		dev_err(&client->dev,
255 			"irq %d busy? error %d\n", client->irq, err);
256 		goto err_free_irq_gpio;
257 	}
258 
259 	err = input_register_device(input_dev);
260 	if (err)
261 		goto err_free_irq;
262 
263 	i2c_set_clientdata(client, ts);
264 	device_init_wakeup(&client->dev, 1);
265 	return 0;
266 
267 err_free_irq:
268 	free_irq(client->irq, ts);
269 err_free_irq_gpio:
270 	gpio_free(ts->irq_pin);
271 err_shutoff_device:
272 	cy8ctmg110_set_sleepmode(ts, true);
273 	cy8ctmg110_power(ts, false);
274 	if (ts->reset_pin)
275 		gpio_free(ts->reset_pin);
276 err_free_mem:
277 	input_free_device(input_dev);
278 	kfree(ts);
279 	return err;
280 }
281 
282 #ifdef CONFIG_PM
283 static int cy8ctmg110_suspend(struct device *dev)
284 {
285 	struct i2c_client *client = to_i2c_client(dev);
286 	struct cy8ctmg110 *ts = i2c_get_clientdata(client);
287 
288 	if (device_may_wakeup(&client->dev))
289 		enable_irq_wake(client->irq);
290 	else {
291 		cy8ctmg110_set_sleepmode(ts, true);
292 		cy8ctmg110_power(ts, false);
293 	}
294 	return 0;
295 }
296 
297 static int cy8ctmg110_resume(struct device *dev)
298 {
299 	struct i2c_client *client = to_i2c_client(dev);
300 	struct cy8ctmg110 *ts = i2c_get_clientdata(client);
301 
302 	if (device_may_wakeup(&client->dev))
303 		disable_irq_wake(client->irq);
304 	else {
305 		cy8ctmg110_power(ts, true);
306 		cy8ctmg110_set_sleepmode(ts, false);
307 	}
308 	return 0;
309 }
310 
311 static SIMPLE_DEV_PM_OPS(cy8ctmg110_pm, cy8ctmg110_suspend, cy8ctmg110_resume);
312 #endif
313 
314 static int __devexit cy8ctmg110_remove(struct i2c_client *client)
315 {
316 	struct cy8ctmg110 *ts = i2c_get_clientdata(client);
317 
318 	cy8ctmg110_set_sleepmode(ts, true);
319 	cy8ctmg110_power(ts, false);
320 
321 	free_irq(client->irq, ts);
322 	input_unregister_device(ts->input);
323 	gpio_free(ts->irq_pin);
324 	if (ts->reset_pin)
325 		gpio_free(ts->reset_pin);
326 	kfree(ts);
327 
328 	return 0;
329 }
330 
331 static struct i2c_device_id cy8ctmg110_idtable[] = {
332 	{ CY8CTMG110_DRIVER_NAME, 1 },
333 	{ }
334 };
335 
336 MODULE_DEVICE_TABLE(i2c, cy8ctmg110_idtable);
337 
338 static struct i2c_driver cy8ctmg110_driver = {
339 	.driver		= {
340 		.owner	= THIS_MODULE,
341 		.name	= CY8CTMG110_DRIVER_NAME,
342 #ifdef CONFIG_PM
343 		.pm	= &cy8ctmg110_pm,
344 #endif
345 	},
346 	.id_table	= cy8ctmg110_idtable,
347 	.probe		= cy8ctmg110_probe,
348 	.remove		= __devexit_p(cy8ctmg110_remove),
349 };
350 
351 static int __init cy8ctmg110_init(void)
352 {
353 	return i2c_add_driver(&cy8ctmg110_driver);
354 }
355 
356 static void __exit cy8ctmg110_exit(void)
357 {
358 	i2c_del_driver(&cy8ctmg110_driver);
359 }
360 
361 module_init(cy8ctmg110_init);
362 module_exit(cy8ctmg110_exit);
363 
364 MODULE_AUTHOR("Samuli Konttila <samuli.konttila@aavamobile.com>");
365 MODULE_DESCRIPTION("cy8ctmg110 TouchScreen Driver");
366 MODULE_LICENSE("GPL v2");
367