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, | |
71d821fd RW |
137 | &ts->low_latency_req, |
138 | DEV_PM_QOS_RESUME_LATENCY, 100); | |
9ee27ffb | 139 | } |
56a8bd6d TS |
140 | |
141 | /* SYN_REPORT */ | |
142 | input_sync(input_dev); | |
143 | ||
144 | end: | |
145 | return IRQ_HANDLED; | |
146 | } | |
147 | ||
e6a90810 BH |
148 | static void st1232_ts_power(struct st1232_ts_data *ts, bool poweron) |
149 | { | |
150 | if (gpio_is_valid(ts->reset_gpio)) | |
151 | gpio_direction_output(ts->reset_gpio, poweron); | |
152 | } | |
153 | ||
5298cc4c | 154 | static int st1232_ts_probe(struct i2c_client *client, |
56a8bd6d TS |
155 | const struct i2c_device_id *id) |
156 | { | |
157 | struct st1232_ts_data *ts; | |
c838cb3d | 158 | struct st1232_pdata *pdata = dev_get_platdata(&client->dev); |
56a8bd6d TS |
159 | struct input_dev *input_dev; |
160 | int error; | |
161 | ||
162 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { | |
163 | dev_err(&client->dev, "need I2C_FUNC_I2C\n"); | |
164 | return -EIO; | |
165 | } | |
166 | ||
167 | if (!client->irq) { | |
168 | dev_err(&client->dev, "no IRQ?\n"); | |
169 | return -EINVAL; | |
170 | } | |
171 | ||
95b24d22 LP |
172 | ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); |
173 | if (!ts) | |
174 | return -ENOMEM; | |
56a8bd6d | 175 | |
95b24d22 LP |
176 | input_dev = devm_input_allocate_device(&client->dev); |
177 | if (!input_dev) | |
178 | return -ENOMEM; | |
56a8bd6d TS |
179 | |
180 | ts->client = client; | |
181 | ts->input_dev = input_dev; | |
182 | ||
e6a90810 BH |
183 | if (pdata) |
184 | ts->reset_gpio = pdata->reset_gpio; | |
185 | else if (client->dev.of_node) | |
186 | ts->reset_gpio = of_get_gpio(client->dev.of_node, 0); | |
187 | else | |
188 | ts->reset_gpio = -ENODEV; | |
189 | ||
190 | if (gpio_is_valid(ts->reset_gpio)) { | |
191 | error = devm_gpio_request(&client->dev, ts->reset_gpio, NULL); | |
192 | if (error) { | |
193 | dev_err(&client->dev, | |
194 | "Unable to request GPIO pin %d.\n", | |
195 | ts->reset_gpio); | |
196 | return error; | |
197 | } | |
198 | } | |
199 | ||
200 | st1232_ts_power(ts, true); | |
201 | ||
56a8bd6d TS |
202 | input_dev->name = "st1232-touchscreen"; |
203 | input_dev->id.bustype = BUS_I2C; | |
204 | input_dev->dev.parent = &client->dev; | |
205 | ||
206 | __set_bit(EV_SYN, input_dev->evbit); | |
207 | __set_bit(EV_KEY, input_dev->evbit); | |
208 | __set_bit(EV_ABS, input_dev->evbit); | |
209 | ||
210 | input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0); | |
211 | input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0); | |
212 | input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0); | |
213 | ||
95b24d22 LP |
214 | error = devm_request_threaded_irq(&client->dev, client->irq, |
215 | NULL, st1232_ts_irq_handler, | |
216 | IRQF_ONESHOT, | |
217 | client->name, ts); | |
56a8bd6d TS |
218 | if (error) { |
219 | dev_err(&client->dev, "Failed to register interrupt\n"); | |
95b24d22 | 220 | return error; |
56a8bd6d TS |
221 | } |
222 | ||
223 | error = input_register_device(ts->input_dev); | |
224 | if (error) { | |
225 | dev_err(&client->dev, "Unable to register %s input device\n", | |
226 | input_dev->name); | |
95b24d22 | 227 | return error; |
56a8bd6d TS |
228 | } |
229 | ||
230 | i2c_set_clientdata(client, ts); | |
231 | device_init_wakeup(&client->dev, 1); | |
232 | ||
233 | return 0; | |
56a8bd6d TS |
234 | } |
235 | ||
e2619cf7 | 236 | static int st1232_ts_remove(struct i2c_client *client) |
56a8bd6d | 237 | { |
e6a90810 BH |
238 | struct st1232_ts_data *ts = i2c_get_clientdata(client); |
239 | ||
56a8bd6d | 240 | device_init_wakeup(&client->dev, 0); |
e6a90810 | 241 | st1232_ts_power(ts, false); |
56a8bd6d TS |
242 | |
243 | return 0; | |
244 | } | |
245 | ||
02b6a58b | 246 | static int __maybe_unused st1232_ts_suspend(struct device *dev) |
56a8bd6d TS |
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 | ||
02b6a58b | 261 | static int __maybe_unused st1232_ts_resume(struct device *dev) |
56a8bd6d TS |
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 | ||
b3571400 DT |
276 | static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops, |
277 | st1232_ts_suspend, st1232_ts_resume); | |
278 | ||
56a8bd6d TS |
279 | static const struct i2c_device_id st1232_ts_id[] = { |
280 | { ST1232_TS_NAME, 0 }, | |
281 | { } | |
282 | }; | |
283 | MODULE_DEVICE_TABLE(i2c, st1232_ts_id); | |
284 | ||
e6293d2f | 285 | #ifdef CONFIG_OF |
78f50c24 | 286 | static const struct of_device_id st1232_ts_dt_ids[] = { |
e6293d2f MD |
287 | { .compatible = "sitronix,st1232", }, |
288 | { } | |
289 | }; | |
290 | MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids); | |
291 | #endif | |
292 | ||
56a8bd6d TS |
293 | static struct i2c_driver st1232_ts_driver = { |
294 | .probe = st1232_ts_probe, | |
1cb0aa88 | 295 | .remove = st1232_ts_remove, |
56a8bd6d TS |
296 | .id_table = st1232_ts_id, |
297 | .driver = { | |
298 | .name = ST1232_TS_NAME, | |
e6293d2f | 299 | .of_match_table = of_match_ptr(st1232_ts_dt_ids), |
56a8bd6d | 300 | .pm = &st1232_ts_pm_ops, |
56a8bd6d TS |
301 | }, |
302 | }; | |
303 | ||
1b92c1cf | 304 | module_i2c_driver(st1232_ts_driver); |
56a8bd6d TS |
305 | |
306 | MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>"); | |
307 | MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver"); | |
308 | MODULE_LICENSE("GPL"); |