write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/input/touchscreen/st1232.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0
1
2
 /*
2
3
  * ST1232 Touchscreen Controller Driver
3
4
  *
..
..
@@ -7,125 +8,127 @@
7
8
  * Using code from:
8
9
  *  - android.git.kernel.org: projects/kernel/common.git: synaptics_i2c_rmi.c
9
10
  *	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
11
  */
20
12
 
21
13
 #include <linux/delay.h>
22
-#include <linux/gpio.h>
14
+#include <linux/gpio/consumer.h>
23
15
 #include <linux/i2c.h>
24
16
 #include <linux/input.h>
17
+#include <linux/input/mt.h>
18
+#include <linux/input/touchscreen.h>
25
19
 #include <linux/interrupt.h>
26
20
 #include <linux/module.h>
27
21
 #include <linux/of.h>
28
-#include <linux/of_gpio.h>
29
22
 #include <linux/pm_qos.h>
30
23
 #include <linux/slab.h>
31
24
 #include <linux/types.h>
32
25
 
33
26
 #define ST1232_TS_NAME	"st1232-ts"
27
+#define ST1633_TS_NAME	"st1633-ts"
34
28
 
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
29
+#define ST_TS_MAX_FINGERS	10
41
30
 
42
-struct st1232_ts_finger {
43
-	u16 x;
44
-	u16 y;
45
-	u8 t;
46
-	bool is_valid;
31
+struct st_chip_info {
32
+	bool	have_z;
33
+	u16	max_x;
34
+	u16	max_y;
35
+	u16	max_area;
36
+	u16	max_fingers;
37
+	u8	start_reg;
47
38
 };
48
39
 
49
40
 struct st1232_ts_data {
50
41
 	struct i2c_client *client;
51
42
 	struct input_dev *input_dev;
52
-	struct st1232_ts_finger finger[MAX_FINGERS];
43
+	struct touchscreen_properties prop;
53
44
 	struct dev_pm_qos_request low_latency_req;
54
-	int reset_gpio;
45
+	struct gpio_desc *reset_gpio;
46
+	const struct st_chip_info *chip_info;
47
+	int read_buf_len;
48
+	u8 *read_buf;
55
49
 };
56
50
 
57
51
 static int st1232_ts_read_data(struct st1232_ts_data *ts)
58
52
 {
59
-	struct st1232_ts_finger *finger = ts->finger;
60
53
 	struct i2c_client *client = ts->client;
61
-	struct i2c_msg msg[2];
62
-	int error;
63
-	u8 start_reg;
64
-	u8 buf[10];
54
+	u8 start_reg = ts->chip_info->start_reg;
55
+	struct i2c_msg msg[] = {
56
+		{
57
+			.addr	= client->addr,
58
+			.len	= sizeof(start_reg),
59
+			.buf	= &start_reg,
60
+		},
61
+		{
62
+			.addr	= client->addr,
63
+			.flags	= I2C_M_RD | I2C_M_DMA_SAFE,
64
+			.len	= ts->read_buf_len,
65
+			.buf	= ts->read_buf,
66
+		}
67
+	};
68
+	int ret;
65
69
 
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
-	}
70
+	ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
71
+	if (ret != ARRAY_SIZE(msg))
72
+		return ret < 0 ? ret : -EIO;
98
73
 
99
74
 	return 0;
75
+}
76
+
77
+static int st1232_ts_parse_and_report(struct st1232_ts_data *ts)
78
+{
79
+	struct input_dev *input = ts->input_dev;
80
+	struct input_mt_pos pos[ST_TS_MAX_FINGERS];
81
+	u8 z[ST_TS_MAX_FINGERS];
82
+	int slots[ST_TS_MAX_FINGERS];
83
+	int n_contacts = 0;
84
+	int i;
85
+
86
+	for (i = 0; i < ts->chip_info->max_fingers; i++) {
87
+		u8 *buf = &ts->read_buf[i * 4];
88
+
89
+		if (buf[0] & BIT(7)) {
90
+			unsigned int x = ((buf[0] & 0x70) << 4) | buf[1];
91
+			unsigned int y = ((buf[0] & 0x07) << 8) | buf[2];
92
+
93
+			touchscreen_set_mt_pos(&pos[n_contacts],
94
+					       &ts->prop, x, y);
95
+
96
+			/* st1232 includes a z-axis / touch strength */
97
+			if (ts->chip_info->have_z)
98
+				z[n_contacts] = ts->read_buf[i + 6];
99
+
100
+			n_contacts++;
101
+		}
102
+	}
103
+
104
+	input_mt_assign_slots(input, slots, pos, n_contacts, 0);
105
+	for (i = 0; i < n_contacts; i++) {
106
+		input_mt_slot(input, slots[i]);
107
+		input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
108
+		input_report_abs(input, ABS_MT_POSITION_X, pos[i].x);
109
+		input_report_abs(input, ABS_MT_POSITION_Y, pos[i].y);
110
+		if (ts->chip_info->have_z)
111
+			input_report_abs(input, ABS_MT_TOUCH_MAJOR, z[i]);
112
+	}
113
+
114
+	input_mt_sync_frame(input);
115
+	input_sync(input);
116
+
117
+	return n_contacts;
100
118
 }
101
119
 
102
120
 static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id)
103
121
 {
104
122
 	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;
123
+	int count;
124
+	int error;
109
125
 
110
-	ret = st1232_ts_read_data(ts);
111
-	if (ret < 0)
112
-		goto end;
126
+	error = st1232_ts_read_data(ts);
127
+	if (error)
128
+		goto out;
113
129
 
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 */
130
+	count = st1232_ts_parse_and_report(ts);
127
131
 	if (!count) {
128
-		input_mt_sync(input_dev);
129
132
 		if (ts->low_latency_req.dev) {
130
133
 			dev_pm_qos_remove_request(&ts->low_latency_req);
131
134
 			ts->low_latency_req.dev = NULL;
..
..
@@ -137,25 +140,54 @@
137
140
 						DEV_PM_QOS_RESUME_LATENCY, 100);
138
141
 	}
139
142
 
140
-	/* SYN_REPORT */
141
-	input_sync(input_dev);
142
-
143
-end:
143
+out:
144
144
 	return IRQ_HANDLED;
145
145
 }
146
146
 
147
147
 static void st1232_ts_power(struct st1232_ts_data *ts, bool poweron)
148
148
 {
149
-	if (gpio_is_valid(ts->reset_gpio))
150
-		gpio_direction_output(ts->reset_gpio, poweron);
149
+	if (ts->reset_gpio)
150
+		gpiod_set_value_cansleep(ts->reset_gpio, !poweron);
151
151
 }
152
+
153
+static void st1232_ts_power_off(void *data)
154
+{
155
+	st1232_ts_power(data, false);
156
+}
157
+
158
+static const struct st_chip_info st1232_chip_info = {
159
+	.have_z		= true,
160
+	.max_x		= 0x31f, /* 800 - 1 */
161
+	.max_y		= 0x1df, /* 480 -1 */
162
+	.max_area	= 0xff,
163
+	.max_fingers	= 2,
164
+	.start_reg	= 0x12,
165
+};
166
+
167
+static const struct st_chip_info st1633_chip_info = {
168
+	.have_z		= false,
169
+	.max_x		= 0x13f, /* 320 - 1 */
170
+	.max_y		= 0x1df, /* 480 -1 */
171
+	.max_area	= 0x00,
172
+	.max_fingers	= 5,
173
+	.start_reg	= 0x12,
174
+};
152
175
 
153
176
 static int st1232_ts_probe(struct i2c_client *client,
154
177
 			   const struct i2c_device_id *id)
155
178
 {
179
+	const struct st_chip_info *match;
156
180
 	struct st1232_ts_data *ts;
157
181
 	struct input_dev *input_dev;
158
182
 	int error;
183
+
184
+	match = device_get_match_data(&client->dev);
185
+	if (!match && id)
186
+		match = (const void *)id->driver_data;
187
+	if (!match) {
188
+		dev_err(&client->dev, "unknown device model\n");
189
+		return -ENODEV;
190
+	}
159
191
 
160
192
 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
161
193
 		dev_err(&client->dev, "need I2C_FUNC_I2C\n");
..
..
@@ -171,6 +203,14 @@
171
203
 	if (!ts)
172
204
 		return -ENOMEM;
173
205
 
206
+	ts->chip_info = match;
207
+
208
+	/* allocate a buffer according to the number of registers to read */
209
+	ts->read_buf_len = ts->chip_info->max_fingers * 4;
210
+	ts->read_buf = devm_kzalloc(&client->dev, ts->read_buf_len, GFP_KERNEL);
211
+	if (!ts->read_buf)
212
+		return -ENOMEM;
213
+
174
214
 	input_dev = devm_input_allocate_device(&client->dev);
175
215
 	if (!input_dev)
176
216
 		return -ENOMEM;
..
..
@@ -178,31 +218,45 @@
178
218
 	ts->client = client;
179
219
 	ts->input_dev = input_dev;
180
220
 
181
-	ts->reset_gpio = of_get_gpio(client->dev.of_node, 0);
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
-		}
221
+	ts->reset_gpio = devm_gpiod_get_optional(&client->dev, NULL,
222
+						 GPIOD_OUT_HIGH);
223
+	if (IS_ERR(ts->reset_gpio)) {
224
+		error = PTR_ERR(ts->reset_gpio);
225
+		dev_err(&client->dev, "Unable to request GPIO pin: %d.\n",
226
+			error);
227
+		return error;
190
228
 	}
191
229
 
192
230
 	st1232_ts_power(ts, true);
193
231
 
232
+	error = devm_add_action_or_reset(&client->dev, st1232_ts_power_off, ts);
233
+	if (error) {
234
+		dev_err(&client->dev,
235
+			"Failed to install power off action: %d\n", error);
236
+		return error;
237
+	}
238
+
194
239
 	input_dev->name = "st1232-touchscreen";
195
240
 	input_dev->id.bustype = BUS_I2C;
196
-	input_dev->dev.parent = &client->dev;
197
241
 
198
-	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
199
-	__set_bit(EV_SYN, input_dev->evbit);
200
-	__set_bit(EV_KEY, input_dev->evbit);
201
-	__set_bit(EV_ABS, input_dev->evbit);
242
+	if (ts->chip_info->have_z)
243
+		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
244
+				     ts->chip_info->max_area, 0, 0);
202
245
 
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);
246
+	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
247
+			     0, ts->chip_info->max_x, 0, 0);
248
+	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
249
+			     0, ts->chip_info->max_y, 0, 0);
250
+
251
+	touchscreen_parse_properties(input_dev, true, &ts->prop);
252
+
253
+	error = input_mt_init_slots(input_dev, ts->chip_info->max_fingers,
254
+				    INPUT_MT_DIRECT | INPUT_MT_TRACK |
255
+					INPUT_MT_DROP_UNUSED);
256
+	if (error) {
257
+		dev_err(&client->dev, "failed to initialize MT slots\n");
258
+		return error;
259
+	}
206
260
 
207
261
 	error = devm_request_threaded_irq(&client->dev, client->irq,
208
262
 					  NULL, st1232_ts_irq_handler,
..
..
@@ -221,16 +275,6 @@
221
275
 	}
222
276
 
223
277
 	i2c_set_clientdata(client, ts);
224
-	device_init_wakeup(&client->dev, 1);
225
-
226
-	return 0;
227
-}
228
-
229
-static int st1232_ts_remove(struct i2c_client *client)
230
-{
231
-	struct st1232_ts_data *ts = i2c_get_clientdata(client);
232
-
233
-	st1232_ts_power(ts, false);
234
278
 
235
279
 	return 0;
236
280
 }
..
..
@@ -240,12 +284,10 @@
240
284
 	struct i2c_client *client = to_i2c_client(dev);
241
285
 	struct st1232_ts_data *ts = i2c_get_clientdata(client);
242
286
 
243
-	if (device_may_wakeup(&client->dev)) {
244
-		enable_irq_wake(client->irq);
245
-	} else {
246
-		disable_irq(client->irq);
287
+	disable_irq(client->irq);
288
+
289
+	if (!device_may_wakeup(&client->dev))
247
290
 		st1232_ts_power(ts, false);
248
-	}
249
291
 
250
292
 	return 0;
251
293
 }
..
..
@@ -255,12 +297,10 @@
255
297
 	struct i2c_client *client = to_i2c_client(dev);
256
298
 	struct st1232_ts_data *ts = i2c_get_clientdata(client);
257
299
 
258
-	if (device_may_wakeup(&client->dev)) {
259
-		disable_irq_wake(client->irq);
260
-	} else {
300
+	if (!device_may_wakeup(&client->dev))
261
301
 		st1232_ts_power(ts, true);
262
-		enable_irq(client->irq);
263
-	}
302
+
303
+	enable_irq(client->irq);
264
304
 
265
305
 	return 0;
266
306
 }
..
..
@@ -269,20 +309,21 @@
269
309
 			 st1232_ts_suspend, st1232_ts_resume);
270
310
 
271
311
 static const struct i2c_device_id st1232_ts_id[] = {
272
-	{ ST1232_TS_NAME, 0 },
312
+	{ ST1232_TS_NAME, (unsigned long)&st1232_chip_info },
313
+	{ ST1633_TS_NAME, (unsigned long)&st1633_chip_info },
273
314
 	{ }
274
315
 };
275
316
 MODULE_DEVICE_TABLE(i2c, st1232_ts_id);
276
317
 
277
318
 static const struct of_device_id st1232_ts_dt_ids[] = {
278
-	{ .compatible = "sitronix,st1232", },
319
+	{ .compatible = "sitronix,st1232", .data = &st1232_chip_info },
320
+	{ .compatible = "sitronix,st1633", .data = &st1633_chip_info },
279
321
 	{ }
280
322
 };
281
323
 MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids);
282
324
 
283
325
 static struct i2c_driver st1232_ts_driver = {
284
326
 	.probe		= st1232_ts_probe,
285
-	.remove		= st1232_ts_remove,
286
327
 	.id_table	= st1232_ts_id,
287
328
 	.driver = {
288
329
 		.name	= ST1232_TS_NAME,
..
..
@@ -294,5 +335,6 @@
294
335
 module_i2c_driver(st1232_ts_driver);
295
336
 
296
337
 MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>");
338
+MODULE_AUTHOR("Martin Kepplinger <martin.kepplinger@ginzinger.com>");
297
339
 MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver");
298
-MODULE_LICENSE("GPL");
340
+MODULE_LICENSE("GPL v2");