1 /*
2  * Driver for ChipOne icn8318 i2c touchscreen controller
3  *
4  * Copyright (c) 2015 Red Hat Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * Red Hat authors:
12  * Hans de Goede <hdegoede@redhat.com>
13  */
14 
15 #include <linux/gpio/consumer.h>
16 #include <linux/interrupt.h>
17 #include <linux/i2c.h>
18 #include <linux/input.h>
19 #include <linux/input/mt.h>
20 #include <linux/module.h>
21 #include <linux/of.h>
22 
23 #define ICN8318_REG_POWER		4
24 #define ICN8318_REG_TOUCHDATA		16
25 
26 #define ICN8318_POWER_ACTIVE		0
27 #define ICN8318_POWER_MONITOR		1
28 #define ICN8318_POWER_HIBERNATE		2
29 
30 #define ICN8318_MAX_TOUCHES		5
31 
32 struct icn8318_touch {
33 	__u8 slot;
34 	__be16 x;
35 	__be16 y;
36 	__u8 pressure;	/* Seems more like finger width then pressure really */
37 	__u8 event;
38 /* The difference between 2 and 3 is unclear */
39 #define ICN8318_EVENT_NO_DATA	1 /* No finger seen yet since wakeup */
40 #define ICN8318_EVENT_UPDATE1	2 /* New or updated coordinates */
41 #define ICN8318_EVENT_UPDATE2	3 /* New or updated coordinates */
42 #define ICN8318_EVENT_END	4 /* Finger lifted */
43 } __packed;
44 
45 struct icn8318_touch_data {
46 	__u8 softbutton;
47 	__u8 touch_count;
48 	struct icn8318_touch touches[ICN8318_MAX_TOUCHES];
49 } __packed;
50 
51 struct icn8318_data {
52 	struct i2c_client *client;
53 	struct input_dev *input;
54 	struct gpio_desc *wake_gpio;
55 	u32 max_x;
56 	u32 max_y;
57 	bool invert_x;
58 	bool invert_y;
59 	bool swap_x_y;
60 };
61 
62 static int icn8318_read_touch_data(struct i2c_client *client,
63 				   struct icn8318_touch_data *touch_data)
64 {
65 	u8 reg = ICN8318_REG_TOUCHDATA;
66 	struct i2c_msg msg[2] = {
67 		{
68 			.addr = client->addr,
69 			.len = 1,
70 			.buf = &reg
71 		},
72 		{
73 			.addr = client->addr,
74 			.flags = I2C_M_RD,
75 			.len = sizeof(struct icn8318_touch_data),
76 			.buf = (u8 *)touch_data
77 		}
78 	};
79 
80 	return i2c_transfer(client->adapter, msg, 2);
81 }
82 
83 static inline bool icn8318_touch_active(u8 event)
84 {
85 	return (event == ICN8318_EVENT_UPDATE1) ||
86 	       (event == ICN8318_EVENT_UPDATE2);
87 }
88 
89 static irqreturn_t icn8318_irq(int irq, void *dev_id)
90 {
91 	struct icn8318_data *data = dev_id;
92 	struct device *dev = &data->client->dev;
93 	struct icn8318_touch_data touch_data;
94 	int i, ret, x, y;
95 
96 	ret = icn8318_read_touch_data(data->client, &touch_data);
97 	if (ret < 0) {
98 		dev_err(dev, "Error reading touch data: %d\n", ret);
99 		return IRQ_HANDLED;
100 	}
101 
102 	if (touch_data.softbutton) {
103 		/*
104 		 * Other data is invalid when a softbutton is pressed.
105 		 * This needs some extra devicetree bindings to map the icn8318
106 		 * softbutton codes to evdev codes. Currently no known devices
107 		 * use this.
108 		 */
109 		return IRQ_HANDLED;
110 	}
111 
112 	if (touch_data.touch_count > ICN8318_MAX_TOUCHES) {
113 		dev_warn(dev, "Too much touches %d > %d\n",
114 			 touch_data.touch_count, ICN8318_MAX_TOUCHES);
115 		touch_data.touch_count = ICN8318_MAX_TOUCHES;
116 	}
117 
118 	for (i = 0; i < touch_data.touch_count; i++) {
119 		struct icn8318_touch *touch = &touch_data.touches[i];
120 		bool act = icn8318_touch_active(touch->event);
121 
122 		input_mt_slot(data->input, touch->slot);
123 		input_mt_report_slot_state(data->input, MT_TOOL_FINGER, act);
124 		if (!act)
125 			continue;
126 
127 		x = be16_to_cpu(touch->x);
128 		y = be16_to_cpu(touch->y);
129 
130 		if (data->invert_x)
131 			x = data->max_x - x;
132 
133 		if (data->invert_y)
134 			y = data->max_y - y;
135 
136 		if (!data->swap_x_y) {
137 			input_event(data->input, EV_ABS, ABS_MT_POSITION_X, x);
138 			input_event(data->input, EV_ABS, ABS_MT_POSITION_Y, y);
139 		} else {
140 			input_event(data->input, EV_ABS, ABS_MT_POSITION_X, y);
141 			input_event(data->input, EV_ABS, ABS_MT_POSITION_Y, x);
142 		}
143 	}
144 
145 	input_mt_sync_frame(data->input);
146 	input_sync(data->input);
147 
148 	return IRQ_HANDLED;
149 }
150 
151 static int icn8318_start(struct input_dev *dev)
152 {
153 	struct icn8318_data *data = input_get_drvdata(dev);
154 
155 	enable_irq(data->client->irq);
156 	gpiod_set_value_cansleep(data->wake_gpio, 1);
157 
158 	return 0;
159 }
160 
161 static void icn8318_stop(struct input_dev *dev)
162 {
163 	struct icn8318_data *data = input_get_drvdata(dev);
164 
165 	disable_irq(data->client->irq);
166 	i2c_smbus_write_byte_data(data->client, ICN8318_REG_POWER,
167 				  ICN8318_POWER_HIBERNATE);
168 	gpiod_set_value_cansleep(data->wake_gpio, 0);
169 }
170 
171 #ifdef CONFIG_PM_SLEEP
172 static int icn8318_suspend(struct device *dev)
173 {
174 	struct icn8318_data *data = i2c_get_clientdata(to_i2c_client(dev));
175 
176 	mutex_lock(&data->input->mutex);
177 	if (data->input->users)
178 		icn8318_stop(data->input);
179 	mutex_unlock(&data->input->mutex);
180 
181 	return 0;
182 }
183 
184 static int icn8318_resume(struct device *dev)
185 {
186 	struct icn8318_data *data = i2c_get_clientdata(to_i2c_client(dev));
187 
188 	mutex_lock(&data->input->mutex);
189 	if (data->input->users)
190 		icn8318_start(data->input);
191 	mutex_unlock(&data->input->mutex);
192 
193 	return 0;
194 }
195 #endif
196 
197 static SIMPLE_DEV_PM_OPS(icn8318_pm_ops, icn8318_suspend, icn8318_resume);
198 
199 static int icn8318_probe(struct i2c_client *client,
200 			 const struct i2c_device_id *id)
201 {
202 	struct device *dev = &client->dev;
203 	struct device_node *np = dev->of_node;
204 	struct icn8318_data *data;
205 	struct input_dev *input;
206 	u32 fuzz_x = 0, fuzz_y = 0;
207 	int error;
208 
209 	if (!client->irq) {
210 		dev_err(dev, "Error no irq specified\n");
211 		return -EINVAL;
212 	}
213 
214 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
215 	if (!data)
216 		return -ENOMEM;
217 
218 	data->wake_gpio = devm_gpiod_get(dev, "wake", GPIOD_OUT_LOW);
219 	if (IS_ERR(data->wake_gpio)) {
220 		error = PTR_ERR(data->wake_gpio);
221 		if (error != -EPROBE_DEFER)
222 			dev_err(dev, "Error getting wake gpio: %d\n", error);
223 		return error;
224 	}
225 
226 	if (of_property_read_u32(np, "touchscreen-size-x", &data->max_x) ||
227 	    of_property_read_u32(np, "touchscreen-size-y", &data->max_y)) {
228 		dev_err(dev, "Error touchscreen-size-x and/or -y missing\n");
229 		return -EINVAL;
230 	}
231 
232 	/* Optional */
233 	of_property_read_u32(np, "touchscreen-fuzz-x", &fuzz_x);
234 	of_property_read_u32(np, "touchscreen-fuzz-y", &fuzz_y);
235 	data->invert_x = of_property_read_bool(np, "touchscreen-inverted-x");
236 	data->invert_y = of_property_read_bool(np, "touchscreen-inverted-y");
237 	data->swap_x_y = of_property_read_bool(np, "touchscreen-swapped-x-y");
238 
239 	input = devm_input_allocate_device(dev);
240 	if (!input)
241 		return -ENOMEM;
242 
243 	input->name = client->name;
244 	input->id.bustype = BUS_I2C;
245 	input->open = icn8318_start;
246 	input->close = icn8318_stop;
247 	input->dev.parent = dev;
248 
249 	if (!data->swap_x_y) {
250 		input_set_abs_params(input, ABS_MT_POSITION_X, 0,
251 				     data->max_x, fuzz_x, 0);
252 		input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
253 				     data->max_y, fuzz_y, 0);
254 	} else {
255 		input_set_abs_params(input, ABS_MT_POSITION_X, 0,
256 				     data->max_y, fuzz_y, 0);
257 		input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
258 				     data->max_x, fuzz_x, 0);
259 	}
260 
261 	error = input_mt_init_slots(input, ICN8318_MAX_TOUCHES,
262 				    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
263 	if (error)
264 		return error;
265 
266 	data->client = client;
267 	data->input = input;
268 	input_set_drvdata(input, data);
269 
270 	error = devm_request_threaded_irq(dev, client->irq, NULL, icn8318_irq,
271 					  IRQF_ONESHOT, client->name, data);
272 	if (error) {
273 		dev_err(dev, "Error requesting irq: %d\n", error);
274 		return error;
275 	}
276 
277 	/* Stop device till opened */
278 	icn8318_stop(data->input);
279 
280 	error = input_register_device(input);
281 	if (error)
282 		return error;
283 
284 	i2c_set_clientdata(client, data);
285 
286 	return 0;
287 }
288 
289 static const struct of_device_id icn8318_of_match[] = {
290 	{ .compatible = "chipone,icn8318" },
291 	{ }
292 };
293 MODULE_DEVICE_TABLE(of, icn8318_of_match);
294 
295 /* This is useless for OF-enabled devices, but it is needed by I2C subsystem */
296 static const struct i2c_device_id icn8318_i2c_id[] = {
297 	{ },
298 };
299 MODULE_DEVICE_TABLE(i2c, icn8318_i2c_id);
300 
301 static struct i2c_driver icn8318_driver = {
302 	.driver = {
303 		.name	= "chipone_icn8318",
304 		.pm	= &icn8318_pm_ops,
305 		.of_match_table = icn8318_of_match,
306 	},
307 	.probe = icn8318_probe,
308 	.id_table = icn8318_i2c_id,
309 };
310 
311 module_i2c_driver(icn8318_driver);
312 
313 MODULE_DESCRIPTION("ChipOne icn8318 I2C Touchscreen Driver");
314 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
315 MODULE_LICENSE("GPL");
316