]>
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> | |
32 | ||
33 | #define ST1232_TS_NAME "st1232-ts" | |
34 | ||
35 | #define MIN_X 0x00 | |
36 | #define MIN_Y 0x00 | |
37 | #define MAX_X 0x31f /* (800 - 1) */ | |
38 | #define MAX_Y 0x1df /* (480 - 1) */ | |
39 | #define MAX_AREA 0xff | |
40 | #define MAX_FINGERS 2 | |
41 | ||
42 | struct st1232_ts_finger { | |
43 | u16 x; | |
44 | u16 y; | |
45 | u8 t; | |
46 | bool is_valid; | |
47 | }; | |
48 | ||
49 | struct st1232_ts_data { | |
50 | struct i2c_client *client; | |
51 | struct input_dev *input_dev; | |
52 | struct st1232_ts_finger finger[MAX_FINGERS]; | |
9ee27ffb | 53 | struct dev_pm_qos_request low_latency_req; |
e6a90810 | 54 | int reset_gpio; |
56a8bd6d TS |
55 | }; |
56 | ||
57 | static int st1232_ts_read_data(struct st1232_ts_data *ts) | |
58 | { | |
59 | struct st1232_ts_finger *finger = ts->finger; | |
60 | struct i2c_client *client = ts->client; | |
61 | struct i2c_msg msg[2]; | |
62 | int error; | |
63 | u8 start_reg; | |
64 | u8 buf[10]; | |
65 | ||
66 | /* read touchscreen data from ST1232 */ | |
67 | msg[0].addr = client->addr; | |
68 | msg[0].flags = 0; | |
69 | msg[0].len = 1; | |
70 | msg[0].buf = &start_reg; | |
71 | start_reg = 0x10; | |
72 | ||
73 | msg[1].addr = ts->client->addr; | |
74 | msg[1].flags = I2C_M_RD; | |
75 | msg[1].len = sizeof(buf); | |
76 | msg[1].buf = buf; | |
77 | ||
78 | error = i2c_transfer(client->adapter, msg, 2); | |
79 | if (error < 0) | |
80 | return error; | |
81 | ||
82 | /* get "valid" bits */ | |
83 | finger[0].is_valid = buf[2] >> 7; | |
84 | finger[1].is_valid = buf[5] >> 7; | |
85 | ||
86 | /* get xy coordinate */ | |
87 | if (finger[0].is_valid) { | |
88 | finger[0].x = ((buf[2] & 0x0070) << 4) | buf[3]; | |
89 | finger[0].y = ((buf[2] & 0x0007) << 8) | buf[4]; | |
90 | finger[0].t = buf[8]; | |
91 | } | |
92 | ||
93 | if (finger[1].is_valid) { | |
94 | finger[1].x = ((buf[5] & 0x0070) << 4) | buf[6]; | |
95 | finger[1].y = ((buf[5] & 0x0007) << 8) | buf[7]; | |
96 | finger[1].t = buf[9]; | |
97 | } | |
98 | ||
99 | return 0; | |
100 | } | |
101 | ||
102 | static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id) | |
103 | { | |
104 | struct st1232_ts_data *ts = dev_id; | |
105 | struct st1232_ts_finger *finger = ts->finger; | |
106 | struct input_dev *input_dev = ts->input_dev; | |
107 | int count = 0; | |
108 | int i, ret; | |
109 | ||
110 | ret = st1232_ts_read_data(ts); | |
111 | if (ret < 0) | |
112 | goto end; | |
113 | ||
114 | /* multi touch protocol */ | |
115 | for (i = 0; i < MAX_FINGERS; i++) { | |
116 | if (!finger[i].is_valid) | |
117 | continue; | |
118 | ||
119 | input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t); | |
120 | input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x); | |
121 | input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y); | |
122 | input_mt_sync(input_dev); | |
123 | count++; | |
124 | } | |
125 | ||
126 | /* SYN_MT_REPORT only if no contact */ | |
9ee27ffb | 127 | if (!count) { |
56a8bd6d | 128 | input_mt_sync(input_dev); |
9ee27ffb RW |
129 | if (ts->low_latency_req.dev) { |
130 | dev_pm_qos_remove_request(&ts->low_latency_req); | |
131 | ts->low_latency_req.dev = NULL; | |
132 | } | |
133 | } else if (!ts->low_latency_req.dev) { | |
134 | /* First contact, request 100 us latency. */ | |
135 | dev_pm_qos_add_ancestor_request(&ts->client->dev, | |
71d821fd RW |
136 | &ts->low_latency_req, |
137 | DEV_PM_QOS_RESUME_LATENCY, 100); | |
9ee27ffb | 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, |
4a1a57df | 154 | const struct i2c_device_id *id) |
56a8bd6d TS |
155 | { |
156 | struct st1232_ts_data *ts; | |
157 | struct input_dev *input_dev; | |
158 | int error; | |
159 | ||
160 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { | |
161 | dev_err(&client->dev, "need I2C_FUNC_I2C\n"); | |
162 | return -EIO; | |
163 | } | |
164 | ||
165 | if (!client->irq) { | |
166 | dev_err(&client->dev, "no IRQ?\n"); | |
167 | return -EINVAL; | |
168 | } | |
169 | ||
95b24d22 LP |
170 | ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); |
171 | if (!ts) | |
172 | return -ENOMEM; | |
56a8bd6d | 173 | |
95b24d22 LP |
174 | input_dev = devm_input_allocate_device(&client->dev); |
175 | if (!input_dev) | |
176 | return -ENOMEM; | |
56a8bd6d TS |
177 | |
178 | ts->client = client; | |
179 | ts->input_dev = input_dev; | |
180 | ||
4a1a57df | 181 | ts->reset_gpio = of_get_gpio(client->dev.of_node, 0); |
e6a90810 BH |
182 | if (gpio_is_valid(ts->reset_gpio)) { |
183 | error = devm_gpio_request(&client->dev, ts->reset_gpio, NULL); | |
184 | if (error) { | |
185 | dev_err(&client->dev, | |
186 | "Unable to request GPIO pin %d.\n", | |
187 | ts->reset_gpio); | |
188 | return error; | |
189 | } | |
190 | } | |
191 | ||
192 | st1232_ts_power(ts, true); | |
193 | ||
56a8bd6d TS |
194 | input_dev->name = "st1232-touchscreen"; |
195 | input_dev->id.bustype = BUS_I2C; | |
196 | input_dev->dev.parent = &client->dev; | |
197 | ||
7458616b | 198 | __set_bit(INPUT_PROP_DIRECT, input_dev->propbit); |
56a8bd6d TS |
199 | __set_bit(EV_SYN, input_dev->evbit); |
200 | __set_bit(EV_KEY, input_dev->evbit); | |
201 | __set_bit(EV_ABS, input_dev->evbit); | |
202 | ||
203 | input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0); | |
204 | input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0); | |
205 | input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0); | |
206 | ||
95b24d22 LP |
207 | error = devm_request_threaded_irq(&client->dev, client->irq, |
208 | NULL, st1232_ts_irq_handler, | |
209 | IRQF_ONESHOT, | |
210 | client->name, ts); | |
56a8bd6d TS |
211 | if (error) { |
212 | dev_err(&client->dev, "Failed to register interrupt\n"); | |
95b24d22 | 213 | return error; |
56a8bd6d TS |
214 | } |
215 | ||
216 | error = input_register_device(ts->input_dev); | |
217 | if (error) { | |
218 | dev_err(&client->dev, "Unable to register %s input device\n", | |
219 | input_dev->name); | |
95b24d22 | 220 | return error; |
56a8bd6d TS |
221 | } |
222 | ||
223 | i2c_set_clientdata(client, ts); | |
224 | device_init_wakeup(&client->dev, 1); | |
225 | ||
226 | return 0; | |
56a8bd6d TS |
227 | } |
228 | ||
e2619cf7 | 229 | static int st1232_ts_remove(struct i2c_client *client) |
56a8bd6d | 230 | { |
e6a90810 BH |
231 | struct st1232_ts_data *ts = i2c_get_clientdata(client); |
232 | ||
e6a90810 | 233 | st1232_ts_power(ts, false); |
56a8bd6d TS |
234 | |
235 | return 0; | |
236 | } | |
237 | ||
02b6a58b | 238 | static int __maybe_unused st1232_ts_suspend(struct device *dev) |
56a8bd6d TS |
239 | { |
240 | struct i2c_client *client = to_i2c_client(dev); | |
e6a90810 | 241 | struct st1232_ts_data *ts = i2c_get_clientdata(client); |
56a8bd6d | 242 | |
e6a90810 | 243 | if (device_may_wakeup(&client->dev)) { |
56a8bd6d | 244 | enable_irq_wake(client->irq); |
e6a90810 | 245 | } else { |
56a8bd6d | 246 | disable_irq(client->irq); |
e6a90810 BH |
247 | st1232_ts_power(ts, false); |
248 | } | |
56a8bd6d TS |
249 | |
250 | return 0; | |
251 | } | |
252 | ||
02b6a58b | 253 | static int __maybe_unused st1232_ts_resume(struct device *dev) |
56a8bd6d TS |
254 | { |
255 | struct i2c_client *client = to_i2c_client(dev); | |
e6a90810 | 256 | struct st1232_ts_data *ts = i2c_get_clientdata(client); |
56a8bd6d | 257 | |
e6a90810 | 258 | if (device_may_wakeup(&client->dev)) { |
56a8bd6d | 259 | disable_irq_wake(client->irq); |
e6a90810 BH |
260 | } else { |
261 | st1232_ts_power(ts, true); | |
56a8bd6d | 262 | enable_irq(client->irq); |
e6a90810 | 263 | } |
56a8bd6d TS |
264 | |
265 | return 0; | |
266 | } | |
267 | ||
b3571400 DT |
268 | static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops, |
269 | st1232_ts_suspend, st1232_ts_resume); | |
270 | ||
56a8bd6d TS |
271 | static const struct i2c_device_id st1232_ts_id[] = { |
272 | { ST1232_TS_NAME, 0 }, | |
273 | { } | |
274 | }; | |
275 | MODULE_DEVICE_TABLE(i2c, st1232_ts_id); | |
276 | ||
78f50c24 | 277 | static const struct of_device_id st1232_ts_dt_ids[] = { |
e6293d2f MD |
278 | { .compatible = "sitronix,st1232", }, |
279 | { } | |
280 | }; | |
281 | MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids); | |
e6293d2f | 282 | |
56a8bd6d TS |
283 | static struct i2c_driver st1232_ts_driver = { |
284 | .probe = st1232_ts_probe, | |
1cb0aa88 | 285 | .remove = st1232_ts_remove, |
56a8bd6d TS |
286 | .id_table = st1232_ts_id, |
287 | .driver = { | |
288 | .name = ST1232_TS_NAME, | |
4a1a57df | 289 | .of_match_table = st1232_ts_dt_ids, |
56a8bd6d | 290 | .pm = &st1232_ts_pm_ops, |
56a8bd6d TS |
291 | }, |
292 | }; | |
293 | ||
1b92c1cf | 294 | module_i2c_driver(st1232_ts_driver); |
56a8bd6d TS |
295 | |
296 | MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>"); | |
297 | MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver"); | |
298 | MODULE_LICENSE("GPL"); |