Commit | Line | Data |
---|---|---|
56a8bd6d TS |
1 | /* |
2 | * ST1232 Touchscreen Controller Driver | |
3 | * | |
4 | * Copyright (C) 2010 Renesas Solutions Corp. | |
5 | * Tony SIM <chinyeow.sim.xt@renesas.com> | |
6 | * | |
7 | * Using code from: | |
8 | * - android.git.kernel.org: projects/kernel/common.git: synaptics_i2c_rmi.c | |
9 | * Copyright (C) 2007 Google, Inc. | |
10 | * | |
11 | * This software is licensed under the terms of the GNU General Public | |
12 | * License version 2, as published by the Free Software Foundation, and | |
13 | * may be copied, distributed, and modified under those terms. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | */ | |
20 | ||
21 | #include <linux/delay.h> | |
e6a90810 | 22 | #include <linux/gpio.h> |
56a8bd6d TS |
23 | #include <linux/i2c.h> |
24 | #include <linux/input.h> | |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/module.h> | |
4d6e4826 | 27 | #include <linux/of.h> |
e6a90810 | 28 | #include <linux/of_gpio.h> |
9ee27ffb | 29 | #include <linux/pm_qos.h> |
56a8bd6d TS |
30 | #include <linux/slab.h> |
31 | #include <linux/types.h> | |
e6a90810 | 32 | #include <linux/platform_data/st1232_pdata.h> |
56a8bd6d TS |
33 | |
34 | #define ST1232_TS_NAME "st1232-ts" | |
35 | ||
36 | #define MIN_X 0x00 | |
37 | #define MIN_Y 0x00 | |
38 | #define MAX_X 0x31f /* (800 - 1) */ | |
39 | #define MAX_Y 0x1df /* (480 - 1) */ | |
40 | #define MAX_AREA 0xff | |
41 | #define MAX_FINGERS 2 | |
42 | ||
43 | struct st1232_ts_finger { | |
44 | u16 x; | |
45 | u16 y; | |
46 | u8 t; | |
47 | bool is_valid; | |
48 | }; | |
49 | ||
50 | struct st1232_ts_data { | |
51 | struct i2c_client *client; | |
52 | struct input_dev *input_dev; | |
53 | struct st1232_ts_finger finger[MAX_FINGERS]; | |
9ee27ffb | 54 | struct dev_pm_qos_request low_latency_req; |
e6a90810 | 55 | int reset_gpio; |
56a8bd6d TS |
56 | }; |
57 | ||
58 | static int st1232_ts_read_data(struct st1232_ts_data *ts) | |
59 | { | |
60 | struct st1232_ts_finger *finger = ts->finger; | |
61 | struct i2c_client *client = ts->client; | |
62 | struct i2c_msg msg[2]; | |
63 | int error; | |
64 | u8 start_reg; | |
65 | u8 buf[10]; | |
66 | ||
67 | /* read touchscreen data from ST1232 */ | |
68 | msg[0].addr = client->addr; | |
69 | msg[0].flags = 0; | |
70 | msg[0].len = 1; | |
71 | msg[0].buf = &start_reg; | |
72 | start_reg = 0x10; | |
73 | ||
74 | msg[1].addr = ts->client->addr; | |
75 | msg[1].flags = I2C_M_RD; | |
76 | msg[1].len = sizeof(buf); | |
77 | msg[1].buf = buf; | |
78 | ||
79 | error = i2c_transfer(client->adapter, msg, 2); | |
80 | if (error < 0) | |
81 | return error; | |
82 | ||
83 | /* get "valid" bits */ | |
84 | finger[0].is_valid = buf[2] >> 7; | |
85 | finger[1].is_valid = buf[5] >> 7; | |
86 | ||
87 | /* get xy coordinate */ | |
88 | if (finger[0].is_valid) { | |
89 | finger[0].x = ((buf[2] & 0x0070) << 4) | buf[3]; | |
90 | finger[0].y = ((buf[2] & 0x0007) << 8) | buf[4]; | |
91 | finger[0].t = buf[8]; | |
92 | } | |
93 | ||
94 | if (finger[1].is_valid) { | |
95 | finger[1].x = ((buf[5] & 0x0070) << 4) | buf[6]; | |
96 | finger[1].y = ((buf[5] & 0x0007) << 8) | buf[7]; | |
97 | finger[1].t = buf[9]; | |
98 | } | |
99 | ||
100 | return 0; | |
101 | } | |
102 | ||
103 | static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id) | |
104 | { | |
105 | struct st1232_ts_data *ts = dev_id; | |
106 | struct st1232_ts_finger *finger = ts->finger; | |
107 | struct input_dev *input_dev = ts->input_dev; | |
108 | int count = 0; | |
109 | int i, ret; | |
110 | ||
111 | ret = st1232_ts_read_data(ts); | |
112 | if (ret < 0) | |
113 | goto end; | |
114 | ||
115 | /* multi touch protocol */ | |
116 | for (i = 0; i < MAX_FINGERS; i++) { | |
117 | if (!finger[i].is_valid) | |
118 | continue; | |
119 | ||
120 | input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t); | |
121 | input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x); | |
122 | input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y); | |
123 | input_mt_sync(input_dev); | |
124 | count++; | |
125 | } | |
126 | ||
127 | /* SYN_MT_REPORT only if no contact */ | |
9ee27ffb | 128 | if (!count) { |
56a8bd6d | 129 | input_mt_sync(input_dev); |
9ee27ffb RW |
130 | if (ts->low_latency_req.dev) { |
131 | dev_pm_qos_remove_request(&ts->low_latency_req); | |
132 | ts->low_latency_req.dev = NULL; | |
133 | } | |
134 | } else if (!ts->low_latency_req.dev) { | |
135 | /* First contact, request 100 us latency. */ | |
136 | dev_pm_qos_add_ancestor_request(&ts->client->dev, | |
137 | &ts->low_latency_req, 100); | |
138 | } | |
56a8bd6d TS |
139 | |
140 | /* SYN_REPORT */ | |
141 | input_sync(input_dev); | |
142 | ||
143 | end: | |
144 | return IRQ_HANDLED; | |
145 | } | |
146 | ||
e6a90810 BH |
147 | static void st1232_ts_power(struct st1232_ts_data *ts, bool poweron) |
148 | { | |
149 | if (gpio_is_valid(ts->reset_gpio)) | |
150 | gpio_direction_output(ts->reset_gpio, poweron); | |
151 | } | |
152 | ||
5298cc4c | 153 | static int st1232_ts_probe(struct i2c_client *client, |
56a8bd6d TS |
154 | const struct i2c_device_id *id) |
155 | { | |
156 | struct st1232_ts_data *ts; | |
e6a90810 | 157 | struct st1232_pdata *pdata = client->dev.platform_data; |
56a8bd6d TS |
158 | struct input_dev *input_dev; |
159 | int error; | |
160 | ||
161 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { | |
162 | dev_err(&client->dev, "need I2C_FUNC_I2C\n"); | |
163 | return -EIO; | |
164 | } | |
165 | ||
166 | if (!client->irq) { | |
167 | dev_err(&client->dev, "no IRQ?\n"); | |
168 | return -EINVAL; | |
169 | } | |
170 | ||
95b24d22 LP |
171 | ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); |
172 | if (!ts) | |
173 | return -ENOMEM; | |
56a8bd6d | 174 | |
95b24d22 LP |
175 | input_dev = devm_input_allocate_device(&client->dev); |
176 | if (!input_dev) | |
177 | return -ENOMEM; | |
56a8bd6d TS |
178 | |
179 | ts->client = client; | |
180 | ts->input_dev = input_dev; | |
181 | ||
e6a90810 BH |
182 | if (pdata) |
183 | ts->reset_gpio = pdata->reset_gpio; | |
184 | else if (client->dev.of_node) | |
185 | ts->reset_gpio = of_get_gpio(client->dev.of_node, 0); | |
186 | else | |
187 | ts->reset_gpio = -ENODEV; | |
188 | ||
189 | if (gpio_is_valid(ts->reset_gpio)) { | |
190 | error = devm_gpio_request(&client->dev, ts->reset_gpio, NULL); | |
191 | if (error) { | |
192 | dev_err(&client->dev, | |
193 | "Unable to request GPIO pin %d.\n", | |
194 | ts->reset_gpio); | |
195 | return error; | |
196 | } | |
197 | } | |
198 | ||
199 | st1232_ts_power(ts, true); | |
200 | ||
56a8bd6d TS |
201 | input_dev->name = "st1232-touchscreen"; |
202 | input_dev->id.bustype = BUS_I2C; | |
203 | input_dev->dev.parent = &client->dev; | |
204 | ||
205 | __set_bit(EV_SYN, input_dev->evbit); | |
206 | __set_bit(EV_KEY, input_dev->evbit); | |
207 | __set_bit(EV_ABS, input_dev->evbit); | |
208 | ||
209 | input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0); | |
210 | input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0); | |
211 | input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0); | |
212 | ||
95b24d22 LP |
213 | error = devm_request_threaded_irq(&client->dev, client->irq, |
214 | NULL, st1232_ts_irq_handler, | |
215 | IRQF_ONESHOT, | |
216 | client->name, ts); | |
56a8bd6d TS |
217 | if (error) { |
218 | dev_err(&client->dev, "Failed to register interrupt\n"); | |
95b24d22 | 219 | return error; |
56a8bd6d TS |
220 | } |
221 | ||
222 | error = input_register_device(ts->input_dev); | |
223 | if (error) { | |
224 | dev_err(&client->dev, "Unable to register %s input device\n", | |
225 | input_dev->name); | |
95b24d22 | 226 | return error; |
56a8bd6d TS |
227 | } |
228 | ||
229 | i2c_set_clientdata(client, ts); | |
230 | device_init_wakeup(&client->dev, 1); | |
231 | ||
232 | return 0; | |
56a8bd6d TS |
233 | } |
234 | ||
e2619cf7 | 235 | static int st1232_ts_remove(struct i2c_client *client) |
56a8bd6d | 236 | { |
e6a90810 BH |
237 | struct st1232_ts_data *ts = i2c_get_clientdata(client); |
238 | ||
56a8bd6d | 239 | device_init_wakeup(&client->dev, 0); |
e6a90810 | 240 | st1232_ts_power(ts, false); |
56a8bd6d TS |
241 | |
242 | return 0; | |
243 | } | |
244 | ||
b3571400 | 245 | #ifdef CONFIG_PM_SLEEP |
56a8bd6d TS |
246 | static int st1232_ts_suspend(struct device *dev) |
247 | { | |
248 | struct i2c_client *client = to_i2c_client(dev); | |
e6a90810 | 249 | struct st1232_ts_data *ts = i2c_get_clientdata(client); |
56a8bd6d | 250 | |
e6a90810 | 251 | if (device_may_wakeup(&client->dev)) { |
56a8bd6d | 252 | enable_irq_wake(client->irq); |
e6a90810 | 253 | } else { |
56a8bd6d | 254 | disable_irq(client->irq); |
e6a90810 BH |
255 | st1232_ts_power(ts, false); |
256 | } | |
56a8bd6d TS |
257 | |
258 | return 0; | |
259 | } | |
260 | ||
261 | static int st1232_ts_resume(struct device *dev) | |
262 | { | |
263 | struct i2c_client *client = to_i2c_client(dev); | |
e6a90810 | 264 | struct st1232_ts_data *ts = i2c_get_clientdata(client); |
56a8bd6d | 265 | |
e6a90810 | 266 | if (device_may_wakeup(&client->dev)) { |
56a8bd6d | 267 | disable_irq_wake(client->irq); |
e6a90810 BH |
268 | } else { |
269 | st1232_ts_power(ts, true); | |
56a8bd6d | 270 | enable_irq(client->irq); |
e6a90810 | 271 | } |
56a8bd6d TS |
272 | |
273 | return 0; | |
274 | } | |
275 | ||
56a8bd6d TS |
276 | #endif |
277 | ||
b3571400 DT |
278 | static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops, |
279 | st1232_ts_suspend, st1232_ts_resume); | |
280 | ||
56a8bd6d TS |
281 | static const struct i2c_device_id st1232_ts_id[] = { |
282 | { ST1232_TS_NAME, 0 }, | |
283 | { } | |
284 | }; | |
285 | MODULE_DEVICE_TABLE(i2c, st1232_ts_id); | |
286 | ||
e6293d2f | 287 | #ifdef CONFIG_OF |
78f50c24 | 288 | static const struct of_device_id st1232_ts_dt_ids[] = { |
e6293d2f MD |
289 | { .compatible = "sitronix,st1232", }, |
290 | { } | |
291 | }; | |
292 | MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids); | |
293 | #endif | |
294 | ||
56a8bd6d TS |
295 | static struct i2c_driver st1232_ts_driver = { |
296 | .probe = st1232_ts_probe, | |
1cb0aa88 | 297 | .remove = st1232_ts_remove, |
56a8bd6d TS |
298 | .id_table = st1232_ts_id, |
299 | .driver = { | |
300 | .name = ST1232_TS_NAME, | |
301 | .owner = THIS_MODULE, | |
e6293d2f | 302 | .of_match_table = of_match_ptr(st1232_ts_dt_ids), |
56a8bd6d | 303 | .pm = &st1232_ts_pm_ops, |
56a8bd6d TS |
304 | }, |
305 | }; | |
306 | ||
1b92c1cf | 307 | module_i2c_driver(st1232_ts_driver); |
56a8bd6d TS |
308 | |
309 | MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>"); | |
310 | MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver"); | |
311 | MODULE_LICENSE("GPL"); |