aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/devicetree/bindings/input/touchscreen/iqs5xx.txt80
-rw-r--r--Documentation/devicetree/bindings/vendor-prefixes.txt1
-rw-r--r--drivers/input/touchscreen/Kconfig10
-rw-r--r--drivers/input/touchscreen/Makefile1
-rw-r--r--drivers/input/touchscreen/iqs5xx.c1133
5 files changed, 1225 insertions, 0 deletions
diff --git a/Documentation/devicetree/bindings/input/touchscreen/iqs5xx.txt b/Documentation/devicetree/bindings/input/touchscreen/iqs5xx.txt
new file mode 100644
index 000000000000..efa0820e2469
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/touchscreen/iqs5xx.txt
@@ -0,0 +1,80 @@
1Azoteq IQS550/572/525 Trackpad/Touchscreen Controller
2
3Required properties:
4
5- compatible : Must be equal to one of the following:
6 "azoteq,iqs550"
7 "azoteq,iqs572"
8 "azoteq,iqs525"
9
10- reg : I2C slave address for the device.
11
12- interrupts : GPIO to which the device's active-high RDY
13 output is connected (see [0]).
14
15- reset-gpios : GPIO to which the device's active-low NRST
16 input is connected (see [1]).
17
18Optional properties:
19
20- touchscreen-min-x : See [2].
21
22- touchscreen-min-y : See [2].
23
24- touchscreen-size-x : See [2]. If this property is omitted, the
25 maximum x-coordinate is specified by the
26 device's "X Resolution" register.
27
28- touchscreen-size-y : See [2]. If this property is omitted, the
29 maximum y-coordinate is specified by the
30 device's "Y Resolution" register.
31
32- touchscreen-max-pressure : See [2]. Pressure is expressed as the sum of
33 the deltas across all channels impacted by a
34 touch event. A channel's delta is calculated
35 as its count value minus a reference, where
36 the count value is inversely proportional to
37 the channel's capacitance.
38
39- touchscreen-fuzz-x : See [2].
40
41- touchscreen-fuzz-y : See [2].
42
43- touchscreen-fuzz-pressure : See [2].
44
45- touchscreen-inverted-x : See [2]. Inversion is applied relative to that
46 which may already be specified by the device's
47 FLIP_X and FLIP_Y register fields.
48
49- touchscreen-inverted-y : See [2]. Inversion is applied relative to that
50 which may already be specified by the device's
51 FLIP_X and FLIP_Y register fields.
52
53- touchscreen-swapped-x-y : See [2]. Swapping is applied relative to that
54 which may already be specified by the device's
55 SWITCH_XY_AXIS register field.
56
57[0]: Documentation/devicetree/bindings/interrupt-controller/interrupts.txt
58[1]: Documentation/devicetree/bindings/gpio/gpio.txt
59[2]: Documentation/devicetree/bindings/input/touchscreen/touchscreen.txt
60
61Example:
62
63 &i2c1 {
64 /* ... */
65
66 touchscreen@74 {
67 compatible = "azoteq,iqs550";
68 reg = <0x74>;
69 interrupt-parent = <&gpio>;
70 interrupts = <17 4>;
71 reset-gpios = <&gpio 27 1>;
72
73 touchscreen-size-x = <640>;
74 touchscreen-size-y = <480>;
75
76 touchscreen-max-pressure = <16000>;
77 };
78
79 /* ... */
80 };
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index 4b1a2a8fcc16..51f99549161e 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -53,6 +53,7 @@ avic Shanghai AVIC Optoelectronics Co., Ltd.
53avnet Avnet, Inc. 53avnet Avnet, Inc.
54axentia Axentia Technologies AB 54axentia Axentia Technologies AB
55axis Axis Communications AB 55axis Axis Communications AB
56azoteq Azoteq (Pty) Ltd
56bananapi BIPAI KEJI LIMITED 57bananapi BIPAI KEJI LIMITED
57bhf Beckhoff Automation GmbH & Co. KG 58bhf Beckhoff Automation GmbH & Co. KG
58bitmain Bitmain Technologies 59bitmain Bitmain Technologies
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 6c16aaeb4191..d8337ed50af4 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -1311,4 +1311,14 @@ config TOUCHSCREEN_ROHM_BU21023
1311 To compile this driver as a module, choose M here: the 1311 To compile this driver as a module, choose M here: the
1312 module will be called bu21023_ts. 1312 module will be called bu21023_ts.
1313 1313
1314config TOUCHSCREEN_IQS5XX
1315 tristate "Azoteq IQS550/572/525 trackpad/touchscreen controller"
1316 depends on I2C
1317 help
1318 Say Y to enable support for the Azoteq IQS550/572/525
1319 family of trackpad/touchscreen controllers.
1320
1321 To compile this driver as a module, choose M here: the
1322 module will be called iqs5xx.
1323
1314endif 1324endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index fcc7605fba8d..084a596a0c8b 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -110,3 +110,4 @@ obj-$(CONFIG_TOUCHSCREEN_ZFORCE) += zforce_ts.o
110obj-$(CONFIG_TOUCHSCREEN_COLIBRI_VF50) += colibri-vf50-ts.o 110obj-$(CONFIG_TOUCHSCREEN_COLIBRI_VF50) += colibri-vf50-ts.o
111obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023) += rohm_bu21023.o 111obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023) += rohm_bu21023.o
112obj-$(CONFIG_TOUCHSCREEN_RASPBERRYPI_FW) += raspberrypi-ts.o 112obj-$(CONFIG_TOUCHSCREEN_RASPBERRYPI_FW) += raspberrypi-ts.o
113obj-$(CONFIG_TOUCHSCREEN_IQS5XX) += iqs5xx.o
diff --git a/drivers/input/touchscreen/iqs5xx.c b/drivers/input/touchscreen/iqs5xx.c
new file mode 100644
index 000000000000..b832fe062645
--- /dev/null
+++ b/drivers/input/touchscreen/iqs5xx.c
@@ -0,0 +1,1133 @@
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Azoteq IQS550/572/525 Trackpad/Touchscreen Controller
4 *
5 * Copyright (C) 2018
6 * Author: Jeff LaBundy <jeff@labundy.com>
7 *
8 * These devices require firmware exported from a PC-based configuration tool
9 * made available by the vendor. Firmware files may be pushed to the device's
10 * nonvolatile memory by writing the filename to the 'fw_file' sysfs control.
11 *
12 * Link to PC-based configuration tool and data sheet: http://www.azoteq.com/
13 */
14
15#include <linux/delay.h>
16#include <linux/device.h>
17#include <linux/err.h>
18#include <linux/firmware.h>
19#include <linux/gpio/consumer.h>
20#include <linux/i2c.h>
21#include <linux/input.h>
22#include <linux/input/mt.h>
23#include <linux/input/touchscreen.h>
24#include <linux/interrupt.h>
25#include <linux/kernel.h>
26#include <linux/module.h>
27#include <linux/of_device.h>
28#include <linux/slab.h>
29#include <asm/unaligned.h>
30
31#define IQS5XX_FW_FILE_LEN 64
32#define IQS5XX_NUM_RETRIES 10
33#define IQS5XX_NUM_POINTS 256
34#define IQS5XX_NUM_CONTACTS 5
35#define IQS5XX_WR_BYTES_MAX 2
36
37#define IQS5XX_PROD_NUM_IQS550 40
38#define IQS5XX_PROD_NUM_IQS572 58
39#define IQS5XX_PROD_NUM_IQS525 52
40#define IQS5XX_PROJ_NUM_A000 0
41#define IQS5XX_PROJ_NUM_B000 15
42#define IQS5XX_MAJOR_VER_MIN 2
43
44#define IQS5XX_RESUME 0x00
45#define IQS5XX_SUSPEND 0x01
46
47#define IQS5XX_SW_INPUT_EVENT 0x10
48#define IQS5XX_SETUP_COMPLETE 0x40
49#define IQS5XX_EVENT_MODE 0x01
50#define IQS5XX_TP_EVENT 0x04
51
52#define IQS5XX_FLIP_X 0x01
53#define IQS5XX_FLIP_Y 0x02
54#define IQS5XX_SWITCH_XY_AXIS 0x04
55
56#define IQS5XX_PROD_NUM 0x0000
57#define IQS5XX_ABS_X 0x0016
58#define IQS5XX_ABS_Y 0x0018
59#define IQS5XX_SYS_CTRL0 0x0431
60#define IQS5XX_SYS_CTRL1 0x0432
61#define IQS5XX_SYS_CFG0 0x058E
62#define IQS5XX_SYS_CFG1 0x058F
63#define IQS5XX_TOTAL_RX 0x063D
64#define IQS5XX_TOTAL_TX 0x063E
65#define IQS5XX_XY_CFG0 0x0669
66#define IQS5XX_X_RES 0x066E
67#define IQS5XX_Y_RES 0x0670
68#define IQS5XX_CHKSM 0x83C0
69#define IQS5XX_APP 0x8400
70#define IQS5XX_CSTM 0xBE00
71#define IQS5XX_PMAP_END 0xBFFF
72#define IQS5XX_END_COMM 0xEEEE
73
74#define IQS5XX_CHKSM_LEN (IQS5XX_APP - IQS5XX_CHKSM)
75#define IQS5XX_APP_LEN (IQS5XX_CSTM - IQS5XX_APP)
76#define IQS5XX_CSTM_LEN (IQS5XX_PMAP_END + 1 - IQS5XX_CSTM)
77#define IQS5XX_PMAP_LEN (IQS5XX_PMAP_END + 1 - IQS5XX_CHKSM)
78
79#define IQS5XX_REC_HDR_LEN 4
80#define IQS5XX_REC_LEN_MAX 255
81#define IQS5XX_REC_TYPE_DATA 0x00
82#define IQS5XX_REC_TYPE_EOF 0x01
83
84#define IQS5XX_BL_ADDR_MASK 0x40
85#define IQS5XX_BL_CMD_VER 0x00
86#define IQS5XX_BL_CMD_READ 0x01
87#define IQS5XX_BL_CMD_EXEC 0x02
88#define IQS5XX_BL_CMD_CRC 0x03
89#define IQS5XX_BL_BLK_LEN_MAX 64
90#define IQS5XX_BL_ID 0x0200
91#define IQS5XX_BL_STATUS_RESET 0x00
92#define IQS5XX_BL_STATUS_AVAIL 0xA5
93#define IQS5XX_BL_STATUS_NONE 0xEE
94#define IQS5XX_BL_CRC_PASS 0x00
95#define IQS5XX_BL_CRC_FAIL 0x01
96#define IQS5XX_BL_ATTEMPTS 3
97
98struct iqs5xx_private {
99 struct i2c_client *client;
100 struct input_dev *input;
101 struct gpio_desc *reset_gpio;
102 struct mutex lock;
103 u8 bl_status;
104};
105
106struct iqs5xx_dev_id_info {
107 __be16 prod_num;
108 __be16 proj_num;
109 u8 major_ver;
110 u8 minor_ver;
111 u8 bl_status;
112} __packed;
113
114struct iqs5xx_ihex_rec {
115 char start;
116 char len[2];
117 char addr[4];
118 char type[2];
119 char data[2];
120} __packed;
121
122struct iqs5xx_touch_data {
123 __be16 abs_x;
124 __be16 abs_y;
125 __be16 strength;
126 u8 area;
127} __packed;
128
129static int iqs5xx_read_burst(struct i2c_client *client,
130 u16 reg, void *val, u16 len)
131{
132 __be16 reg_buf = cpu_to_be16(reg);
133 int ret, i;
134 struct i2c_msg msg[] = {
135 {
136 .addr = client->addr,
137 .flags = 0,
138 .len = sizeof(reg_buf),
139 .buf = (u8 *)&reg_buf,
140 },
141 {
142 .addr = client->addr,
143 .flags = I2C_M_RD,
144 .len = len,
145 .buf = (u8 *)val,
146 },
147 };
148
149 /*
150 * The first addressing attempt outside of a communication window fails
151 * and must be retried, after which the device clock stretches until it
152 * is available.
153 */
154 for (i = 0; i < IQS5XX_NUM_RETRIES; i++) {
155 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
156 if (ret == ARRAY_SIZE(msg))
157 return 0;
158
159 usleep_range(200, 300);
160 }
161
162 if (ret >= 0)
163 ret = -EIO;
164
165 dev_err(&client->dev, "Failed to read from address 0x%04X: %d\n",
166 reg, ret);
167
168 return ret;
169}
170
171static int iqs5xx_read_word(struct i2c_client *client, u16 reg, u16 *val)
172{
173 __be16 val_buf;
174 int error;
175
176 error = iqs5xx_read_burst(client, reg, &val_buf, sizeof(val_buf));
177 if (error)
178 return error;
179
180 *val = be16_to_cpu(val_buf);
181
182 return 0;
183}
184
185static int iqs5xx_read_byte(struct i2c_client *client, u16 reg, u8 *val)
186{
187 return iqs5xx_read_burst(client, reg, val, sizeof(*val));
188}
189
190static int iqs5xx_write_burst(struct i2c_client *client,
191 u16 reg, const void *val, u16 len)
192{
193 int ret, i;
194 u16 mlen = sizeof(reg) + len;
195 u8 mbuf[sizeof(reg) + IQS5XX_WR_BYTES_MAX];
196
197 if (len > IQS5XX_WR_BYTES_MAX)
198 return -EINVAL;
199
200 put_unaligned_be16(reg, mbuf);
201 memcpy(mbuf + sizeof(reg), val, len);
202
203 /*
204 * The first addressing attempt outside of a communication window fails
205 * and must be retried, after which the device clock stretches until it
206 * is available.
207 */
208 for (i = 0; i < IQS5XX_NUM_RETRIES; i++) {
209 ret = i2c_master_send(client, mbuf, mlen);
210 if (ret == mlen)
211 return 0;
212
213 usleep_range(200, 300);
214 }
215
216 if (ret >= 0)
217 ret = -EIO;
218
219 dev_err(&client->dev, "Failed to write to address 0x%04X: %d\n",
220 reg, ret);
221
222 return ret;
223}
224
225static int iqs5xx_write_word(struct i2c_client *client, u16 reg, u16 val)
226{
227 __be16 val_buf = cpu_to_be16(val);
228
229 return iqs5xx_write_burst(client, reg, &val_buf, sizeof(val_buf));
230}
231
232static int iqs5xx_write_byte(struct i2c_client *client, u16 reg, u8 val)
233{
234 return iqs5xx_write_burst(client, reg, &val, sizeof(val));
235}
236
237static void iqs5xx_reset(struct i2c_client *client)
238{
239 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
240
241 gpiod_set_value_cansleep(iqs5xx->reset_gpio, 1);
242 usleep_range(200, 300);
243
244 gpiod_set_value_cansleep(iqs5xx->reset_gpio, 0);
245}
246
247static int iqs5xx_bl_cmd(struct i2c_client *client, u8 bl_cmd, u16 bl_addr)
248{
249 struct i2c_msg msg;
250 int ret;
251 u8 mbuf[sizeof(bl_cmd) + sizeof(bl_addr)];
252
253 msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK;
254 msg.flags = 0;
255 msg.len = sizeof(bl_cmd);
256 msg.buf = mbuf;
257
258 *mbuf = bl_cmd;
259
260 switch (bl_cmd) {
261 case IQS5XX_BL_CMD_VER:
262 case IQS5XX_BL_CMD_CRC:
263 case IQS5XX_BL_CMD_EXEC:
264 break;
265 case IQS5XX_BL_CMD_READ:
266 msg.len += sizeof(bl_addr);
267 put_unaligned_be16(bl_addr, mbuf + sizeof(bl_cmd));
268 break;
269 default:
270 return -EINVAL;
271 }
272
273 ret = i2c_transfer(client->adapter, &msg, 1);
274 if (ret != 1)
275 goto msg_fail;
276
277 switch (bl_cmd) {
278 case IQS5XX_BL_CMD_VER:
279 msg.len = sizeof(u16);
280 break;
281 case IQS5XX_BL_CMD_CRC:
282 msg.len = sizeof(u8);
283 /*
284 * This delay saves the bus controller the trouble of having to
285 * tolerate a relatively long clock-stretching period while the
286 * CRC is calculated.
287 */
288 msleep(50);
289 break;
290 case IQS5XX_BL_CMD_EXEC:
291 usleep_range(10000, 10100);
292 /* fall through */
293 default:
294 return 0;
295 }
296
297 msg.flags = I2C_M_RD;
298
299 ret = i2c_transfer(client->adapter, &msg, 1);
300 if (ret != 1)
301 goto msg_fail;
302
303 if (bl_cmd == IQS5XX_BL_CMD_VER &&
304 get_unaligned_be16(mbuf) != IQS5XX_BL_ID) {
305 dev_err(&client->dev, "Unrecognized bootloader ID: 0x%04X\n",
306 get_unaligned_be16(mbuf));
307 return -EINVAL;
308 }
309
310 if (bl_cmd == IQS5XX_BL_CMD_CRC && *mbuf != IQS5XX_BL_CRC_PASS) {
311 dev_err(&client->dev, "Bootloader CRC failed\n");
312 return -EIO;
313 }
314
315 return 0;
316
317msg_fail:
318 if (ret >= 0)
319 ret = -EIO;
320
321 if (bl_cmd != IQS5XX_BL_CMD_VER)
322 dev_err(&client->dev,
323 "Unsuccessful bootloader command 0x%02X: %d\n",
324 bl_cmd, ret);
325
326 return ret;
327}
328
329static int iqs5xx_bl_open(struct i2c_client *client)
330{
331 int error, i, j;
332
333 /*
334 * The device opens a bootloader polling window for 2 ms following the
335 * release of reset. If the host cannot establish communication during
336 * this time frame, it must cycle reset again.
337 */
338 for (i = 0; i < IQS5XX_BL_ATTEMPTS; i++) {
339 iqs5xx_reset(client);
340
341 for (j = 0; j < IQS5XX_NUM_RETRIES; j++) {
342 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_VER, 0);
343 if (!error || error == -EINVAL)
344 return error;
345 }
346 }
347
348 dev_err(&client->dev, "Failed to open bootloader: %d\n", error);
349
350 return error;
351}
352
353static int iqs5xx_bl_write(struct i2c_client *client,
354 u16 bl_addr, u8 *pmap_data, u16 pmap_len)
355{
356 struct i2c_msg msg;
357 int ret, i;
358 u8 mbuf[sizeof(bl_addr) + IQS5XX_BL_BLK_LEN_MAX];
359
360 if (pmap_len % IQS5XX_BL_BLK_LEN_MAX)
361 return -EINVAL;
362
363 msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK;
364 msg.flags = 0;
365 msg.len = sizeof(mbuf);
366 msg.buf = mbuf;
367
368 for (i = 0; i < pmap_len; i += IQS5XX_BL_BLK_LEN_MAX) {
369 put_unaligned_be16(bl_addr + i, mbuf);
370 memcpy(mbuf + sizeof(bl_addr), pmap_data + i,
371 sizeof(mbuf) - sizeof(bl_addr));
372
373 ret = i2c_transfer(client->adapter, &msg, 1);
374 if (ret != 1)
375 goto msg_fail;
376
377 usleep_range(10000, 10100);
378 }
379
380 return 0;
381
382msg_fail:
383 if (ret >= 0)
384 ret = -EIO;
385
386 dev_err(&client->dev, "Failed to write block at address 0x%04X: %d\n",
387 bl_addr + i, ret);
388
389 return ret;
390}
391
392static int iqs5xx_bl_verify(struct i2c_client *client,
393 u16 bl_addr, u8 *pmap_data, u16 pmap_len)
394{
395 struct i2c_msg msg;
396 int ret, i;
397 u8 bl_data[IQS5XX_BL_BLK_LEN_MAX];
398
399 if (pmap_len % IQS5XX_BL_BLK_LEN_MAX)
400 return -EINVAL;
401
402 msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK;
403 msg.flags = I2C_M_RD;
404 msg.len = sizeof(bl_data);
405 msg.buf = bl_data;
406
407 for (i = 0; i < pmap_len; i += IQS5XX_BL_BLK_LEN_MAX) {
408 ret = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_READ, bl_addr + i);
409 if (ret)
410 return ret;
411
412 ret = i2c_transfer(client->adapter, &msg, 1);
413 if (ret != 1)
414 goto msg_fail;
415
416 if (memcmp(bl_data, pmap_data + i, sizeof(bl_data))) {
417 dev_err(&client->dev,
418 "Failed to verify block at address 0x%04X\n",
419 bl_addr + i);
420 return -EIO;
421 }
422 }
423
424 return 0;
425
426msg_fail:
427 if (ret >= 0)
428 ret = -EIO;
429
430 dev_err(&client->dev, "Failed to read block at address 0x%04X: %d\n",
431 bl_addr + i, ret);
432
433 return ret;
434}
435
436static int iqs5xx_set_state(struct i2c_client *client, u8 state)
437{
438 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
439 int error1, error2;
440
441 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET)
442 return 0;
443
444 mutex_lock(&iqs5xx->lock);
445
446 /*
447 * Addressing the device outside of a communication window prompts it
448 * to assert the RDY output, so disable the interrupt line to prevent
449 * the handler from servicing a false interrupt.
450 */
451 disable_irq(client->irq);
452
453 error1 = iqs5xx_write_byte(client, IQS5XX_SYS_CTRL1, state);
454 error2 = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0);
455
456 usleep_range(50, 100);
457 enable_irq(client->irq);
458
459 mutex_unlock(&iqs5xx->lock);
460
461 if (error1)
462 return error1;
463
464 return error2;
465}
466
467static int iqs5xx_open(struct input_dev *input)
468{
469 struct iqs5xx_private *iqs5xx = input_get_drvdata(input);
470
471 return iqs5xx_set_state(iqs5xx->client, IQS5XX_RESUME);
472}
473
474static void iqs5xx_close(struct input_dev *input)
475{
476 struct iqs5xx_private *iqs5xx = input_get_drvdata(input);
477
478 iqs5xx_set_state(iqs5xx->client, IQS5XX_SUSPEND);
479}
480
481static int iqs5xx_axis_init(struct i2c_client *client)
482{
483 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
484 struct touchscreen_properties prop;
485 struct input_dev *input;
486 int error;
487 u16 max_x, max_x_hw;
488 u16 max_y, max_y_hw;
489 u8 val;
490
491 if (!iqs5xx->input) {
492 input = devm_input_allocate_device(&client->dev);
493 if (!input)
494 return -ENOMEM;
495
496 input->name = client->name;
497 input->id.bustype = BUS_I2C;
498 input->open = iqs5xx_open;
499 input->close = iqs5xx_close;
500
501 input_set_capability(input, EV_ABS, ABS_MT_POSITION_X);
502 input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y);
503 input_set_capability(input, EV_ABS, ABS_MT_PRESSURE);
504
505 error = input_mt_init_slots(input,
506 IQS5XX_NUM_CONTACTS, INPUT_MT_DIRECT);
507 if (error) {
508 dev_err(&client->dev,
509 "Failed to initialize slots: %d\n", error);
510 return error;
511 }
512
513 input_set_drvdata(input, iqs5xx);
514 iqs5xx->input = input;
515 }
516
517 touchscreen_parse_properties(iqs5xx->input, true, &prop);
518
519 error = iqs5xx_read_byte(client, IQS5XX_TOTAL_RX, &val);
520 if (error)
521 return error;
522 max_x_hw = (val - 1) * IQS5XX_NUM_POINTS;
523
524 error = iqs5xx_read_byte(client, IQS5XX_TOTAL_TX, &val);
525 if (error)
526 return error;
527 max_y_hw = (val - 1) * IQS5XX_NUM_POINTS;
528
529 error = iqs5xx_read_byte(client, IQS5XX_XY_CFG0, &val);
530 if (error)
531 return error;
532
533 if (val & IQS5XX_SWITCH_XY_AXIS)
534 swap(max_x_hw, max_y_hw);
535
536 if (prop.swap_x_y)
537 val ^= IQS5XX_SWITCH_XY_AXIS;
538
539 if (prop.invert_x)
540 val ^= prop.swap_x_y ? IQS5XX_FLIP_Y : IQS5XX_FLIP_X;
541
542 if (prop.invert_y)
543 val ^= prop.swap_x_y ? IQS5XX_FLIP_X : IQS5XX_FLIP_Y;
544
545 error = iqs5xx_write_byte(client, IQS5XX_XY_CFG0, val);
546 if (error)
547 return error;
548
549 if (prop.max_x > max_x_hw) {
550 dev_err(&client->dev, "Invalid maximum x-coordinate: %u > %u\n",
551 prop.max_x, max_x_hw);
552 return -EINVAL;
553 } else if (prop.max_x == 0) {
554 error = iqs5xx_read_word(client, IQS5XX_X_RES, &max_x);
555 if (error)
556 return error;
557
558 input_abs_set_max(iqs5xx->input,
559 prop.swap_x_y ? ABS_MT_POSITION_Y :
560 ABS_MT_POSITION_X,
561 max_x);
562 } else {
563 max_x = (u16)prop.max_x;
564 }
565
566 if (prop.max_y > max_y_hw) {
567 dev_err(&client->dev, "Invalid maximum y-coordinate: %u > %u\n",
568 prop.max_y, max_y_hw);
569 return -EINVAL;
570 } else if (prop.max_y == 0) {
571 error = iqs5xx_read_word(client, IQS5XX_Y_RES, &max_y);
572 if (error)
573 return error;
574
575 input_abs_set_max(iqs5xx->input,
576 prop.swap_x_y ? ABS_MT_POSITION_X :
577 ABS_MT_POSITION_Y,
578 max_y);
579 } else {
580 max_y = (u16)prop.max_y;
581 }
582
583 /*
584 * Write horizontal and vertical resolution to the device in case its
585 * original defaults were overridden or swapped as per the properties
586 * specified in the device tree.
587 */
588 error = iqs5xx_write_word(client,
589 prop.swap_x_y ? IQS5XX_Y_RES : IQS5XX_X_RES,
590 max_x);
591 if (error)
592 return error;
593
594 return iqs5xx_write_word(client,
595 prop.swap_x_y ? IQS5XX_X_RES : IQS5XX_Y_RES,
596 max_y);
597}
598
599static int iqs5xx_dev_init(struct i2c_client *client)
600{
601 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
602 struct iqs5xx_dev_id_info *dev_id_info;
603 int error;
604 u8 val;
605 u8 buf[sizeof(*dev_id_info) + 1];
606
607 error = iqs5xx_read_burst(client, IQS5XX_PROD_NUM,
608 &buf[1], sizeof(*dev_id_info));
609 if (error)
610 return iqs5xx_bl_open(client);
611
612 /*
613 * A000 and B000 devices use 8-bit and 16-bit addressing, respectively.
614 * Querying an A000 device's version information with 16-bit addressing
615 * gives the appearance that the data is shifted by one byte; a nonzero
616 * leading array element suggests this could be the case (in which case
617 * the missing zero is prepended).
618 */
619 buf[0] = 0;
620 dev_id_info = (struct iqs5xx_dev_id_info *)&buf[(buf[1] > 0) ? 0 : 1];
621
622 switch (be16_to_cpu(dev_id_info->prod_num)) {
623 case IQS5XX_PROD_NUM_IQS550:
624 case IQS5XX_PROD_NUM_IQS572:
625 case IQS5XX_PROD_NUM_IQS525:
626 break;
627 default:
628 dev_err(&client->dev, "Unrecognized product number: %u\n",
629 be16_to_cpu(dev_id_info->prod_num));
630 return -EINVAL;
631 }
632
633 switch (be16_to_cpu(dev_id_info->proj_num)) {
634 case IQS5XX_PROJ_NUM_A000:
635 dev_err(&client->dev, "Unsupported project number: %u\n",
636 be16_to_cpu(dev_id_info->proj_num));
637 return iqs5xx_bl_open(client);
638 case IQS5XX_PROJ_NUM_B000:
639 break;
640 default:
641 dev_err(&client->dev, "Unrecognized project number: %u\n",
642 be16_to_cpu(dev_id_info->proj_num));
643 return -EINVAL;
644 }
645
646 if (dev_id_info->major_ver < IQS5XX_MAJOR_VER_MIN) {
647 dev_err(&client->dev, "Unsupported major version: %u\n",
648 dev_id_info->major_ver);
649 return iqs5xx_bl_open(client);
650 }
651
652 switch (dev_id_info->bl_status) {
653 case IQS5XX_BL_STATUS_AVAIL:
654 case IQS5XX_BL_STATUS_NONE:
655 break;
656 default:
657 dev_err(&client->dev,
658 "Unrecognized bootloader status: 0x%02X\n",
659 dev_id_info->bl_status);
660 return -EINVAL;
661 }
662
663 error = iqs5xx_axis_init(client);
664 if (error)
665 return error;
666
667 error = iqs5xx_read_byte(client, IQS5XX_SYS_CFG0, &val);
668 if (error)
669 return error;
670
671 val |= IQS5XX_SETUP_COMPLETE;
672 val &= ~IQS5XX_SW_INPUT_EVENT;
673 error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG0, val);
674 if (error)
675 return error;
676
677 val = IQS5XX_TP_EVENT | IQS5XX_EVENT_MODE;
678 error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG1, val);
679 if (error)
680 return error;
681
682 error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0);
683 if (error)
684 return error;
685
686 iqs5xx->bl_status = dev_id_info->bl_status;
687
688 /*
689 * Closure of the first communication window that appears following the
690 * release of reset appears to kick off an initialization period during
691 * which further communication is met with clock stretching. The return
692 * from this function is delayed so that further communication attempts
693 * avoid this period.
694 */
695 msleep(100);
696
697 return 0;
698}
699
700static irqreturn_t iqs5xx_irq(int irq, void *data)
701{
702 struct iqs5xx_private *iqs5xx = data;
703 struct iqs5xx_touch_data touch_data[IQS5XX_NUM_CONTACTS];
704 struct i2c_client *client = iqs5xx->client;
705 struct input_dev *input = iqs5xx->input;
706 int error, i;
707
708 /*
709 * This check is purely a precaution, as the device does not assert the
710 * RDY output during bootloader mode. If the device operates outside of
711 * bootloader mode, the input device is guaranteed to be allocated.
712 */
713 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET)
714 return IRQ_NONE;
715
716 error = iqs5xx_read_burst(client, IQS5XX_ABS_X,
717 touch_data, sizeof(touch_data));
718 if (error)
719 return IRQ_NONE;
720
721 for (i = 0; i < ARRAY_SIZE(touch_data); i++) {
722 u16 pressure = be16_to_cpu(touch_data[i].strength);
723
724 input_mt_slot(input, i);
725 if (input_mt_report_slot_state(input, MT_TOOL_FINGER,
726 pressure != 0)) {
727 input_report_abs(input, ABS_MT_POSITION_X,
728 be16_to_cpu(touch_data[i].abs_x));
729 input_report_abs(input, ABS_MT_POSITION_Y,
730 be16_to_cpu(touch_data[i].abs_y));
731 input_report_abs(input, ABS_MT_PRESSURE, pressure);
732 }
733 }
734
735 input_mt_sync_frame(input);
736 input_sync(input);
737
738 error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0);
739 if (error)
740 return IRQ_NONE;
741
742 /*
743 * Once the communication window is closed, a small delay is added to
744 * ensure the device's RDY output has been deasserted by the time the
745 * interrupt handler returns.
746 */
747 usleep_range(50, 100);
748
749 return IRQ_HANDLED;
750}
751
752static int iqs5xx_fw_file_parse(struct i2c_client *client,
753 const char *fw_file, u8 *pmap)
754{
755 const struct firmware *fw;
756 struct iqs5xx_ihex_rec *rec;
757 size_t pos = 0;
758 int error, i;
759 u16 rec_num = 1;
760 u16 rec_addr;
761 u8 rec_len, rec_type, rec_chksm, chksm;
762 u8 rec_hdr[IQS5XX_REC_HDR_LEN];
763 u8 rec_data[IQS5XX_REC_LEN_MAX];
764
765 /*
766 * Firmware exported from the vendor's configuration tool deviates from
767 * standard ihex as follows: (1) the checksum for records corresponding
768 * to user-exported settings is not recalculated, and (2) an address of
769 * 0xFFFF is used for the EOF record.
770 *
771 * Because the ihex2fw tool tolerates neither (1) nor (2), the slightly
772 * nonstandard ihex firmware is parsed directly by the driver.
773 */
774 error = request_firmware(&fw, fw_file, &client->dev);
775 if (error) {
776 dev_err(&client->dev, "Failed to request firmware %s: %d\n",
777 fw_file, error);
778 return error;
779 }
780
781 do {
782 if (pos + sizeof(*rec) > fw->size) {
783 dev_err(&client->dev, "Insufficient firmware size\n");
784 error = -EINVAL;
785 break;
786 }
787 rec = (struct iqs5xx_ihex_rec *)(fw->data + pos);
788 pos += sizeof(*rec);
789
790 if (rec->start != ':') {
791 dev_err(&client->dev, "Invalid start at record %u\n",
792 rec_num);
793 error = -EINVAL;
794 break;
795 }
796
797 error = hex2bin(rec_hdr, rec->len, sizeof(rec_hdr));
798 if (error) {
799 dev_err(&client->dev, "Invalid header at record %u\n",
800 rec_num);
801 break;
802 }
803
804 rec_len = *rec_hdr;
805 rec_addr = get_unaligned_be16(rec_hdr + sizeof(rec_len));
806 rec_type = *(rec_hdr + sizeof(rec_len) + sizeof(rec_addr));
807
808 if (pos + rec_len * 2 > fw->size) {
809 dev_err(&client->dev, "Insufficient firmware size\n");
810 error = -EINVAL;
811 break;
812 }
813 pos += (rec_len * 2);
814
815 error = hex2bin(rec_data, rec->data, rec_len);
816 if (error) {
817 dev_err(&client->dev, "Invalid data at record %u\n",
818 rec_num);
819 break;
820 }
821
822 error = hex2bin(&rec_chksm,
823 rec->data + rec_len * 2, sizeof(rec_chksm));
824 if (error) {
825 dev_err(&client->dev, "Invalid checksum at record %u\n",
826 rec_num);
827 break;
828 }
829
830 chksm = 0;
831 for (i = 0; i < sizeof(rec_hdr); i++)
832 chksm += rec_hdr[i];
833 for (i = 0; i < rec_len; i++)
834 chksm += rec_data[i];
835 chksm = ~chksm + 1;
836
837 if (chksm != rec_chksm && rec_addr < IQS5XX_CSTM) {
838 dev_err(&client->dev,
839 "Incorrect checksum at record %u\n",
840 rec_num);
841 error = -EINVAL;
842 break;
843 }
844
845 switch (rec_type) {
846 case IQS5XX_REC_TYPE_DATA:
847 if (rec_addr < IQS5XX_CHKSM ||
848 rec_addr > IQS5XX_PMAP_END) {
849 dev_err(&client->dev,
850 "Invalid address at record %u\n",
851 rec_num);
852 error = -EINVAL;
853 } else {
854 memcpy(pmap + rec_addr - IQS5XX_CHKSM,
855 rec_data, rec_len);
856 }
857 break;
858 case IQS5XX_REC_TYPE_EOF:
859 break;
860 default:
861 dev_err(&client->dev, "Invalid type at record %u\n",
862 rec_num);
863 error = -EINVAL;
864 }
865
866 if (error)
867 break;
868
869 rec_num++;
870 while (pos < fw->size) {
871 if (*(fw->data + pos) == ':')
872 break;
873 pos++;
874 }
875 } while (rec_type != IQS5XX_REC_TYPE_EOF);
876
877 release_firmware(fw);
878
879 return error;
880}
881
882static int iqs5xx_fw_file_write(struct i2c_client *client, const char *fw_file)
883{
884 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client);
885 int error;
886 u8 *pmap;
887
888 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_NONE)
889 return -EPERM;
890
891 pmap = kzalloc(IQS5XX_PMAP_LEN, GFP_KERNEL);
892 if (!pmap)
893 return -ENOMEM;
894
895 error = iqs5xx_fw_file_parse(client, fw_file, pmap);
896 if (error)
897 goto err_kfree;
898
899 mutex_lock(&iqs5xx->lock);
900
901 /*
902 * Disable the interrupt line in case the first attempt(s) to enter the
903 * bootloader don't happen quickly enough, in which case the device may
904 * assert the RDY output until the next attempt.
905 */
906 disable_irq(client->irq);
907
908 iqs5xx->bl_status = IQS5XX_BL_STATUS_RESET;
909
910 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_VER, 0);
911 if (error) {
912 error = iqs5xx_bl_open(client);
913 if (error)
914 goto err_reset;
915 }
916
917 error = iqs5xx_bl_write(client, IQS5XX_CHKSM, pmap, IQS5XX_PMAP_LEN);
918 if (error)
919 goto err_reset;
920
921 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_CRC, 0);
922 if (error)
923 goto err_reset;
924
925 error = iqs5xx_bl_verify(client, IQS5XX_CSTM,
926 pmap + IQS5XX_CHKSM_LEN + IQS5XX_APP_LEN,
927 IQS5XX_CSTM_LEN);
928 if (error)
929 goto err_reset;
930
931 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_EXEC, 0);
932
933err_reset:
934 if (error) {
935 iqs5xx_reset(client);
936 usleep_range(10000, 10100);
937 }
938
939 error = iqs5xx_dev_init(client);
940 if (!error && iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET)
941 error = -EINVAL;
942
943 enable_irq(client->irq);
944
945 mutex_unlock(&iqs5xx->lock);
946
947err_kfree:
948 kfree(pmap);
949
950 return error;
951}
952
953static ssize_t fw_file_store(struct device *dev, struct device_attribute *attr,
954 const char *buf, size_t count)
955{
956 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev);
957 struct i2c_client *client = iqs5xx->client;
958 size_t len = count;
959 bool input_reg = !iqs5xx->input;
960 char fw_file[IQS5XX_FW_FILE_LEN + 1];
961 int error;
962
963 if (!len)
964 return -EINVAL;
965
966 if (buf[len - 1] == '\n')
967 len--;
968
969 if (len > IQS5XX_FW_FILE_LEN)
970 return -ENAMETOOLONG;
971
972 memcpy(fw_file, buf, len);
973 fw_file[len] = '\0';
974
975 error = iqs5xx_fw_file_write(client, fw_file);
976 if (error)
977 return error;
978
979 /*
980 * If the input device was not allocated already, it is guaranteed to
981 * be allocated by this point and can finally be registered.
982 */
983 if (input_reg) {
984 error = input_register_device(iqs5xx->input);
985 if (error) {
986 dev_err(&client->dev,
987 "Failed to register device: %d\n",
988 error);
989 return error;
990 }
991 }
992
993 return count;
994}
995
996static DEVICE_ATTR_WO(fw_file);
997
998static struct attribute *iqs5xx_attrs[] = {
999 &dev_attr_fw_file.attr,
1000 NULL,
1001};
1002
1003static const struct attribute_group iqs5xx_attr_group = {
1004 .attrs = iqs5xx_attrs,
1005};
1006
1007static int __maybe_unused iqs5xx_suspend(struct device *dev)
1008{
1009 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev);
1010 struct input_dev *input = iqs5xx->input;
1011 int error = 0;
1012
1013 if (!input)
1014 return error;
1015
1016 mutex_lock(&input->mutex);
1017
1018 if (input->users)
1019 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_SUSPEND);
1020
1021 mutex_unlock(&input->mutex);
1022
1023 return error;
1024}
1025
1026static int __maybe_unused iqs5xx_resume(struct device *dev)
1027{
1028 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev);
1029 struct input_dev *input = iqs5xx->input;
1030 int error = 0;
1031
1032 if (!input)
1033 return error;
1034
1035 mutex_lock(&input->mutex);
1036
1037 if (input->users)
1038 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_RESUME);
1039
1040 mutex_unlock(&input->mutex);
1041
1042 return error;
1043}
1044
1045static SIMPLE_DEV_PM_OPS(iqs5xx_pm, iqs5xx_suspend, iqs5xx_resume);
1046
1047static int iqs5xx_probe(struct i2c_client *client,
1048 const struct i2c_device_id *id)
1049{
1050 struct iqs5xx_private *iqs5xx;
1051 int error;
1052
1053 iqs5xx = devm_kzalloc(&client->dev, sizeof(*iqs5xx), GFP_KERNEL);
1054 if (!iqs5xx)
1055 return -ENOMEM;
1056
1057 dev_set_drvdata(&client->dev, iqs5xx);
1058
1059 i2c_set_clientdata(client, iqs5xx);
1060 iqs5xx->client = client;
1061
1062 iqs5xx->reset_gpio = devm_gpiod_get(&client->dev,
1063 "reset", GPIOD_OUT_LOW);
1064 if (IS_ERR(iqs5xx->reset_gpio)) {
1065 error = PTR_ERR(iqs5xx->reset_gpio);
1066 dev_err(&client->dev, "Failed to request GPIO: %d\n", error);
1067 return error;
1068 }
1069
1070 mutex_init(&iqs5xx->lock);
1071
1072 iqs5xx_reset(client);
1073 usleep_range(10000, 10100);
1074
1075 error = iqs5xx_dev_init(client);
1076 if (error)
1077 return error;
1078
1079 error = devm_request_threaded_irq(&client->dev, client->irq,
1080 NULL, iqs5xx_irq, IRQF_ONESHOT,
1081 client->name, iqs5xx);
1082 if (error) {
1083 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
1084 return error;
1085 }
1086
1087 error = devm_device_add_group(&client->dev, &iqs5xx_attr_group);
1088 if (error) {
1089 dev_err(&client->dev, "Failed to add attributes: %d\n", error);
1090 return error;
1091 }
1092
1093 if (iqs5xx->input) {
1094 error = input_register_device(iqs5xx->input);
1095 if (error)
1096 dev_err(&client->dev,
1097 "Failed to register device: %d\n",
1098 error);
1099 }
1100
1101 return error;
1102}
1103
1104static const struct i2c_device_id iqs5xx_id[] = {
1105 { "iqs550", 0 },
1106 { "iqs572", 1 },
1107 { "iqs525", 2 },
1108 { }
1109};
1110MODULE_DEVICE_TABLE(i2c, iqs5xx_id);
1111
1112static const struct of_device_id iqs5xx_of_match[] = {
1113 { .compatible = "azoteq,iqs550" },
1114 { .compatible = "azoteq,iqs572" },
1115 { .compatible = "azoteq,iqs525" },
1116 { }
1117};
1118MODULE_DEVICE_TABLE(of, iqs5xx_of_match);
1119
1120static struct i2c_driver iqs5xx_i2c_driver = {
1121 .driver = {
1122 .name = "iqs5xx",
1123 .of_match_table = iqs5xx_of_match,
1124 .pm = &iqs5xx_pm,
1125 },
1126 .id_table = iqs5xx_id,
1127 .probe = iqs5xx_probe,
1128};
1129module_i2c_driver(iqs5xx_i2c_driver);
1130
1131MODULE_AUTHOR("Jeff LaBundy <jeff@labundy.com>");
1132MODULE_DESCRIPTION("Azoteq IQS550/572/525 Trackpad/Touchscreen Controller");
1133MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-28 18:26:09 -0500