blob: ad6a6640f385da6fcf4f0575701bece678aa41b2 [file] [log] [blame]
Samuli Konttila60347c12010-07-30 09:02:43 -07001/*
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 */
56struct 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 */
68static 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
74static 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;
Dan Carpenterf1b50762010-08-09 10:06:47 -070078 int ret;
Samuli Konttila60347c12010-07-30 09:02:43 -070079 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);
Axel Lin21184c42011-07-13 00:03:36 -070087 if (ret != len + 1) {
Samuli Konttila60347c12010-07-30 09:02:43 -070088 dev_err(&client->dev, "i2c write data cmd failed\n");
Axel Lin21184c42011-07-13 00:03:36 -070089 return ret < 0 ? ret : -EIO;
Samuli Konttila60347c12010-07-30 09:02:43 -070090 }
91
92 return 0;
93}
94
95static 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;
Dan Carpenterf1b50762010-08-09 10:06:47 -070099 int ret;
Samuli Konttila60347c12010-07-30 09:02:43 -0700100 struct i2c_msg msg[2] = {
101 /* first write slave position to i2c devices */
Shubhrajyoti Datta9493d972012-10-10 09:34:00 -0700102 {
103 .addr = client->addr,
104 .len = 1,
105 .buf = &cmd
106 },
Samuli Konttila60347c12010-07-30 09:02:43 -0700107 /* Second read data from position */
Shubhrajyoti Datta9493d972012-10-10 09:34:00 -0700108 {
109 .addr = client->addr,
110 .flags = I2C_M_RD,
111 .len = len,
112 .buf = data
113 }
Samuli Konttila60347c12010-07-30 09:02:43 -0700114 };
115
116 ret = i2c_transfer(client->adapter, msg, 2);
117 if (ret < 0)
118 return ret;
119
120 return 0;
121}
122
123static int cy8ctmg110_touch_pos(struct cy8ctmg110 *tsc)
124{
125 struct input_dev *input = tsc->input;
126 unsigned char reg_p[CY8CTMG110_REG_MAX];
127 int x, y;
128
129 memset(reg_p, 0, CY8CTMG110_REG_MAX);
130
131 /* Reading coordinates */
132 if (cy8ctmg110_read_regs(tsc, reg_p, 9, CY8CTMG110_TOUCH_X1) != 0)
133 return -EIO;
134
135 y = reg_p[2] << 8 | reg_p[3];
136 x = reg_p[0] << 8 | reg_p[1];
137
138 /* Number of touch */
139 if (reg_p[8] == 0) {
140 input_report_key(input, BTN_TOUCH, 0);
141 } else {
142 input_report_key(input, BTN_TOUCH, 1);
143 input_report_abs(input, ABS_X, x);
144 input_report_abs(input, ABS_Y, y);
145 }
146
147 input_sync(input);
148
149 return 0;
150}
151
152static int cy8ctmg110_set_sleepmode(struct cy8ctmg110 *ts, bool sleep)
153{
154 unsigned char reg_p[3];
155
156 if (sleep) {
157 reg_p[0] = 0x00;
158 reg_p[1] = 0xff;
159 reg_p[2] = 5;
160 } else {
161 reg_p[0] = 0x10;
162 reg_p[1] = 0xff;
163 reg_p[2] = 0;
164 }
165
166 return cy8ctmg110_write_regs(ts, CY8CTMG110_TOUCH_WAKEUP_TIME, 3, reg_p);
167}
168
169static irqreturn_t cy8ctmg110_irq_thread(int irq, void *dev_id)
170{
171 struct cy8ctmg110 *tsc = dev_id;
172
173 cy8ctmg110_touch_pos(tsc);
174
175 return IRQ_HANDLED;
176}
177
178static int __devinit cy8ctmg110_probe(struct i2c_client *client,
179 const struct i2c_device_id *id)
180{
181 const struct cy8ctmg110_pdata *pdata = client->dev.platform_data;
182 struct cy8ctmg110 *ts;
183 struct input_dev *input_dev;
184 int err;
185
186 /* No pdata no way forward */
187 if (pdata == NULL) {
188 dev_err(&client->dev, "no pdata\n");
189 return -ENODEV;
190 }
191
192 if (!i2c_check_functionality(client->adapter,
193 I2C_FUNC_SMBUS_READ_WORD_DATA))
194 return -EIO;
195
196 ts = kzalloc(sizeof(struct cy8ctmg110), GFP_KERNEL);
197 input_dev = input_allocate_device();
198 if (!ts || !input_dev) {
199 err = -ENOMEM;
200 goto err_free_mem;
201 }
202
203 ts->client = client;
204 ts->input = input_dev;
Axel Lin2c204102011-07-18 17:09:37 -0700205 ts->reset_pin = pdata->reset_pin;
206 ts->irq_pin = pdata->irq_pin;
Samuli Konttila60347c12010-07-30 09:02:43 -0700207
208 snprintf(ts->phys, sizeof(ts->phys),
209 "%s/input0", dev_name(&client->dev));
210
211 input_dev->name = CY8CTMG110_DRIVER_NAME " Touchscreen";
212 input_dev->phys = ts->phys;
213 input_dev->id.bustype = BUS_I2C;
214 input_dev->dev.parent = &client->dev;
215
216 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
217 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
218
219 input_set_abs_params(input_dev, ABS_X,
James Ketrenosa4e6aad2010-09-06 12:49:33 -0700220 CY8CTMG110_X_MIN, CY8CTMG110_X_MAX, 4, 0);
Samuli Konttila60347c12010-07-30 09:02:43 -0700221 input_set_abs_params(input_dev, ABS_Y,
James Ketrenosa4e6aad2010-09-06 12:49:33 -0700222 CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 4, 0);
Samuli Konttila60347c12010-07-30 09:02:43 -0700223
224 if (ts->reset_pin) {
225 err = gpio_request(ts->reset_pin, NULL);
226 if (err) {
227 dev_err(&client->dev,
228 "Unable to request GPIO pin %d.\n",
229 ts->reset_pin);
230 goto err_free_mem;
231 }
232 }
233
234 cy8ctmg110_power(ts, true);
235 cy8ctmg110_set_sleepmode(ts, false);
236
237 err = gpio_request(ts->irq_pin, "touch_irq_key");
238 if (err < 0) {
239 dev_err(&client->dev,
240 "Failed to request GPIO %d, error %d\n",
241 ts->irq_pin, err);
242 goto err_shutoff_device;
243 }
244
245 err = gpio_direction_input(ts->irq_pin);
246 if (err < 0) {
247 dev_err(&client->dev,
248 "Failed to configure input direction for GPIO %d, error %d\n",
249 ts->irq_pin, err);
250 goto err_free_irq_gpio;
251 }
252
253 client->irq = gpio_to_irq(ts->irq_pin);
254 if (client->irq < 0) {
255 err = client->irq;
256 dev_err(&client->dev,
257 "Unable to get irq number for GPIO %d, error %d\n",
258 ts->irq_pin, err);
259 goto err_free_irq_gpio;
260 }
261
262 err = request_threaded_irq(client->irq, NULL, cy8ctmg110_irq_thread,
Lars-Peter Clausen9b7e31b2012-07-04 13:02:56 -0700263 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
264 "touch_reset_key", ts);
Samuli Konttila60347c12010-07-30 09:02:43 -0700265 if (err < 0) {
266 dev_err(&client->dev,
267 "irq %d busy? error %d\n", client->irq, err);
268 goto err_free_irq_gpio;
269 }
270
271 err = input_register_device(input_dev);
272 if (err)
273 goto err_free_irq;
274
275 i2c_set_clientdata(client, ts);
276 device_init_wakeup(&client->dev, 1);
277 return 0;
278
279err_free_irq:
280 free_irq(client->irq, ts);
281err_free_irq_gpio:
282 gpio_free(ts->irq_pin);
283err_shutoff_device:
284 cy8ctmg110_set_sleepmode(ts, true);
285 cy8ctmg110_power(ts, false);
286 if (ts->reset_pin)
287 gpio_free(ts->reset_pin);
288err_free_mem:
289 input_free_device(input_dev);
290 kfree(ts);
291 return err;
292}
293
294#ifdef CONFIG_PM
Mark Brown93f38e92011-01-06 23:01:03 -0800295static int cy8ctmg110_suspend(struct device *dev)
Samuli Konttila60347c12010-07-30 09:02:43 -0700296{
Mark Brown93f38e92011-01-06 23:01:03 -0800297 struct i2c_client *client = to_i2c_client(dev);
Samuli Konttila60347c12010-07-30 09:02:43 -0700298 struct cy8ctmg110 *ts = i2c_get_clientdata(client);
299
300 if (device_may_wakeup(&client->dev))
301 enable_irq_wake(client->irq);
302 else {
303 cy8ctmg110_set_sleepmode(ts, true);
304 cy8ctmg110_power(ts, false);
305 }
306 return 0;
307}
308
Mark Brown93f38e92011-01-06 23:01:03 -0800309static int cy8ctmg110_resume(struct device *dev)
Samuli Konttila60347c12010-07-30 09:02:43 -0700310{
Mark Brown93f38e92011-01-06 23:01:03 -0800311 struct i2c_client *client = to_i2c_client(dev);
Samuli Konttila60347c12010-07-30 09:02:43 -0700312 struct cy8ctmg110 *ts = i2c_get_clientdata(client);
313
314 if (device_may_wakeup(&client->dev))
315 disable_irq_wake(client->irq);
316 else {
317 cy8ctmg110_power(ts, true);
318 cy8ctmg110_set_sleepmode(ts, false);
319 }
320 return 0;
321}
Mark Brown93f38e92011-01-06 23:01:03 -0800322
323static SIMPLE_DEV_PM_OPS(cy8ctmg110_pm, cy8ctmg110_suspend, cy8ctmg110_resume);
Samuli Konttila60347c12010-07-30 09:02:43 -0700324#endif
325
326static int __devexit cy8ctmg110_remove(struct i2c_client *client)
327{
328 struct cy8ctmg110 *ts = i2c_get_clientdata(client);
329
330 cy8ctmg110_set_sleepmode(ts, true);
331 cy8ctmg110_power(ts, false);
332
333 free_irq(client->irq, ts);
334 input_unregister_device(ts->input);
335 gpio_free(ts->irq_pin);
336 if (ts->reset_pin)
337 gpio_free(ts->reset_pin);
338 kfree(ts);
339
340 return 0;
341}
342
Axel Lind4483032011-07-13 00:04:36 -0700343static const struct i2c_device_id cy8ctmg110_idtable[] = {
Samuli Konttila60347c12010-07-30 09:02:43 -0700344 { CY8CTMG110_DRIVER_NAME, 1 },
345 { }
346};
347
348MODULE_DEVICE_TABLE(i2c, cy8ctmg110_idtable);
349
350static struct i2c_driver cy8ctmg110_driver = {
351 .driver = {
352 .owner = THIS_MODULE,
353 .name = CY8CTMG110_DRIVER_NAME,
Mark Brown93f38e92011-01-06 23:01:03 -0800354#ifdef CONFIG_PM
355 .pm = &cy8ctmg110_pm,
356#endif
Samuli Konttila60347c12010-07-30 09:02:43 -0700357 },
358 .id_table = cy8ctmg110_idtable,
359 .probe = cy8ctmg110_probe,
360 .remove = __devexit_p(cy8ctmg110_remove),
Samuli Konttila60347c12010-07-30 09:02:43 -0700361};
362
Axel Lin1b92c1c2012-03-16 23:05:41 -0700363module_i2c_driver(cy8ctmg110_driver);
Samuli Konttila60347c12010-07-30 09:02:43 -0700364
365MODULE_AUTHOR("Samuli Konttila <samuli.konttila@aavamobile.com>");
366MODULE_DESCRIPTION("cy8ctmg110 TouchScreen Driver");
367MODULE_LICENSE("GPL v2");