1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Rohm BU21029 touchscreen controller driver |
4 | * |
5 | * Copyright (C) 2015-2018 Bosch Sicherheitssysteme GmbH |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify |
8 | * it under the terms of the GNU General Public License version 2 as |
9 | * published by the Free Software Foundation. |
10 | */ |
11 | |
12 | #include <linux/delay.h> |
13 | #include <linux/gpio/consumer.h> |
14 | #include <linux/i2c.h> |
15 | #include <linux/input.h> |
16 | #include <linux/input/touchscreen.h> |
17 | #include <linux/interrupt.h> |
18 | #include <linux/irq.h> |
19 | #include <linux/module.h> |
20 | #include <linux/regulator/consumer.h> |
21 | #include <linux/timer.h> |
22 | |
23 | /* |
24 | * HW_ID1 Register (PAGE=0, ADDR=0x0E, Reset value=0x02, Read only) |
25 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
26 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
27 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
28 | * | HW_IDH | |
29 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
30 | * HW_ID2 Register (PAGE=0, ADDR=0x0F, Reset value=0x29, Read only) |
31 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
32 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
33 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
34 | * | HW_IDL | |
35 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
36 | * HW_IDH: high 8bits of IC's ID |
37 | * HW_IDL: low 8bits of IC's ID |
38 | */ |
39 | #define BU21029_HWID_REG (0x0E << 3) |
40 | #define SUPPORTED_HWID 0x0229 |
41 | |
42 | /* |
43 | * CFR0 Register (PAGE=0, ADDR=0x00, Reset value=0x20) |
44 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
45 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
46 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
47 | * | 0 | 0 | CALIB | INTRM | 0 | 0 | 0 | 0 | |
48 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
49 | * CALIB: 0 = not to use calibration result (*) |
50 | * 1 = use calibration result |
51 | * INTRM: 0 = INT output depend on "pen down" (*) |
52 | * 1 = INT output always "0" |
53 | */ |
54 | #define BU21029_CFR0_REG (0x00 << 3) |
55 | #define CFR0_VALUE 0x00 |
56 | |
57 | /* |
58 | * CFR1 Register (PAGE=0, ADDR=0x01, Reset value=0xA6) |
59 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
60 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
61 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
62 | * | MAV | AVE[2:0] | 0 | SMPL[2:0] | |
63 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
64 | * MAV: 0 = median average filter off |
65 | * 1 = median average filter on (*) |
66 | * AVE: AVE+1 = number of average samples for MAV, |
67 | * if AVE>SMPL, then AVE=SMPL (=3) |
68 | * SMPL: SMPL+1 = number of conversion samples for MAV (=7) |
69 | */ |
70 | #define BU21029_CFR1_REG (0x01 << 3) |
71 | #define CFR1_VALUE 0xA6 |
72 | |
73 | /* |
74 | * CFR2 Register (PAGE=0, ADDR=0x02, Reset value=0x04) |
75 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
76 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
77 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
78 | * | INTVL_TIME[3:0] | TIME_ST_ADC[3:0] | |
79 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
80 | * INTVL_TIME: waiting time between completion of conversion |
81 | * and start of next conversion, only usable in |
82 | * autoscan mode (=20.480ms) |
83 | * TIME_ST_ADC: waiting time between application of voltage |
84 | * to panel and start of A/D conversion (=100us) |
85 | */ |
86 | #define BU21029_CFR2_REG (0x02 << 3) |
87 | #define CFR2_VALUE 0xC9 |
88 | |
89 | /* |
90 | * CFR3 Register (PAGE=0, ADDR=0x0B, Reset value=0x72) |
91 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
92 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
93 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
94 | * | RM8 | STRETCH| PU90K | DUAL | PIDAC_OFS[3:0] | |
95 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
96 | * RM8: 0 = coordinate resolution is 12bit (*) |
97 | * 1 = coordinate resolution is 8bit |
98 | * STRETCH: 0 = SCL_STRETCH function off |
99 | * 1 = SCL_STRETCH function on (*) |
100 | * PU90K: 0 = internal pull-up resistance for touch detection is ~50kohms (*) |
101 | * 1 = internal pull-up resistance for touch detection is ~90kohms |
102 | * DUAL: 0 = dual touch detection off (*) |
103 | * 1 = dual touch detection on |
104 | * PIDAC_OFS: dual touch detection circuit adjustment, it is not necessary |
105 | * to change this from initial value |
106 | */ |
107 | #define BU21029_CFR3_REG (0x0B << 3) |
108 | #define CFR3_VALUE 0x42 |
109 | |
110 | /* |
111 | * LDO Register (PAGE=0, ADDR=0x0C, Reset value=0x00) |
112 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
113 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
114 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
115 | * | 0 | PVDD[2:0] | 0 | AVDD[2:0] | |
116 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
117 | * PVDD: output voltage of panel output regulator (=2.000V) |
118 | * AVDD: output voltage of analog circuit regulator (=2.000V) |
119 | */ |
120 | #define BU21029_LDO_REG (0x0C << 3) |
121 | #define LDO_VALUE 0x77 |
122 | |
123 | /* |
124 | * Serial Interface Command Byte 1 (CID=1) |
125 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
126 | * | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | |
127 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
128 | * | 1 | CF | CMSK | PDM | STP | |
129 | * +--------+--------+--------+--------+--------+--------+--------+--------+ |
130 | * CF: conversion function, see table 3 in datasheet p6 (=0000, automatic scan) |
131 | * CMSK: 0 = executes convert function (*) |
132 | * 1 = reads the convert result |
133 | * PDM: 0 = power down after convert function stops (*) |
134 | * 1 = keep power on after convert function stops |
135 | * STP: 1 = abort current conversion and power down, set to "0" automatically |
136 | */ |
137 | #define BU21029_AUTOSCAN 0x80 |
138 | |
139 | /* |
140 | * The timeout value needs to be larger than INTVL_TIME + tConv4 (sample and |
141 | * conversion time), where tConv4 is calculated by formula: |
142 | * tPON + tDLY1 + (tTIME_ST_ADC + (tADC * tSMPL) * 2 + tDLY2) * 3 |
143 | * see figure 8 in datasheet p15 for details of each field. |
144 | */ |
145 | #define PEN_UP_TIMEOUT_MS 50 |
146 | |
147 | #define STOP_DELAY_MIN_US 50 |
148 | #define STOP_DELAY_MAX_US 1000 |
149 | #define START_DELAY_MS 2 |
150 | #define BUF_LEN 8 |
151 | #define SCALE_12BIT (1 << 12) |
152 | #define MAX_12BIT ((1 << 12) - 1) |
153 | #define DRIVER_NAME "bu21029" |
154 | |
155 | struct bu21029_ts_data { |
156 | struct i2c_client *client; |
157 | struct input_dev *in_dev; |
158 | struct timer_list timer; |
159 | struct regulator *vdd; |
160 | struct gpio_desc *reset_gpios; |
161 | u32 x_plate_ohms; |
162 | struct touchscreen_properties prop; |
163 | }; |
164 | |
165 | static void bu21029_touch_report(struct bu21029_ts_data *bu21029, const u8 *buf) |
166 | { |
167 | u16 x, y, z1, z2; |
168 | u32 rz; |
169 | s32 max_pressure = input_abs_get_max(dev: bu21029->in_dev, ABS_PRESSURE); |
170 | |
171 | /* |
172 | * compose upper 8 and lower 4 bits into a 12bit value: |
173 | * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
174 | * | ByteH | ByteL | |
175 | * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
176 | * |b07|b06|b05|b04|b03|b02|b01|b00|b07|b06|b05|b04|b03|b02|b01|b00| |
177 | * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
178 | * |v11|v10|v09|v08|v07|v06|v05|v04|v03|v02|v01|v00| 0 | 0 | 0 | 0 | |
179 | * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
180 | */ |
181 | x = (buf[0] << 4) | (buf[1] >> 4); |
182 | y = (buf[2] << 4) | (buf[3] >> 4); |
183 | z1 = (buf[4] << 4) | (buf[5] >> 4); |
184 | z2 = (buf[6] << 4) | (buf[7] >> 4); |
185 | |
186 | if (z1 && z2) { |
187 | /* |
188 | * calculate Rz (pressure resistance value) by equation: |
189 | * Rz = Rx * (x/Q) * ((z2/z1) - 1), where |
190 | * Rx is x-plate resistance, |
191 | * Q is the touch screen resolution (8bit = 256, 12bit = 4096) |
192 | * x, z1, z2 are the measured positions. |
193 | */ |
194 | rz = z2 - z1; |
195 | rz *= x; |
196 | rz *= bu21029->x_plate_ohms; |
197 | rz /= z1; |
198 | rz = DIV_ROUND_CLOSEST(rz, SCALE_12BIT); |
199 | if (rz <= max_pressure) { |
200 | touchscreen_report_pos(input: bu21029->in_dev, prop: &bu21029->prop, |
201 | x, y, multitouch: false); |
202 | input_report_abs(dev: bu21029->in_dev, ABS_PRESSURE, |
203 | value: max_pressure - rz); |
204 | input_report_key(dev: bu21029->in_dev, BTN_TOUCH, value: 1); |
205 | input_sync(dev: bu21029->in_dev); |
206 | } |
207 | } |
208 | } |
209 | |
210 | static void bu21029_touch_release(struct timer_list *t) |
211 | { |
212 | struct bu21029_ts_data *bu21029 = from_timer(bu21029, t, timer); |
213 | |
214 | input_report_abs(dev: bu21029->in_dev, ABS_PRESSURE, value: 0); |
215 | input_report_key(dev: bu21029->in_dev, BTN_TOUCH, value: 0); |
216 | input_sync(dev: bu21029->in_dev); |
217 | } |
218 | |
219 | static irqreturn_t bu21029_touch_soft_irq(int irq, void *data) |
220 | { |
221 | struct bu21029_ts_data *bu21029 = data; |
222 | u8 buf[BUF_LEN]; |
223 | int error; |
224 | |
225 | /* |
226 | * Read touch data and deassert interrupt (will assert again after |
227 | * INTVL_TIME + tConv4 for continuous touch) |
228 | */ |
229 | error = i2c_smbus_read_i2c_block_data(client: bu21029->client, BU21029_AUTOSCAN, |
230 | length: sizeof(buf), values: buf); |
231 | if (error < 0) |
232 | goto out; |
233 | |
234 | bu21029_touch_report(bu21029, buf); |
235 | |
236 | /* reset timer for pen up detection */ |
237 | mod_timer(timer: &bu21029->timer, |
238 | expires: jiffies + msecs_to_jiffies(PEN_UP_TIMEOUT_MS)); |
239 | |
240 | out: |
241 | return IRQ_HANDLED; |
242 | } |
243 | |
244 | static void bu21029_put_chip_in_reset(struct bu21029_ts_data *bu21029) |
245 | { |
246 | if (bu21029->reset_gpios) { |
247 | gpiod_set_value_cansleep(desc: bu21029->reset_gpios, value: 1); |
248 | usleep_range(STOP_DELAY_MIN_US, STOP_DELAY_MAX_US); |
249 | } |
250 | } |
251 | |
252 | static int bu21029_start_chip(struct input_dev *dev) |
253 | { |
254 | struct bu21029_ts_data *bu21029 = input_get_drvdata(dev); |
255 | struct i2c_client *i2c = bu21029->client; |
256 | struct { |
257 | u8 reg; |
258 | u8 value; |
259 | } init_table[] = { |
260 | {BU21029_CFR0_REG, CFR0_VALUE}, |
261 | {BU21029_CFR1_REG, CFR1_VALUE}, |
262 | {BU21029_CFR2_REG, CFR2_VALUE}, |
263 | {BU21029_CFR3_REG, CFR3_VALUE}, |
264 | {BU21029_LDO_REG, LDO_VALUE} |
265 | }; |
266 | int error, i; |
267 | __be16 hwid; |
268 | |
269 | error = regulator_enable(regulator: bu21029->vdd); |
270 | if (error) { |
271 | dev_err(&i2c->dev, "failed to power up chip: %d" , error); |
272 | return error; |
273 | } |
274 | |
275 | /* take chip out of reset */ |
276 | if (bu21029->reset_gpios) { |
277 | gpiod_set_value_cansleep(desc: bu21029->reset_gpios, value: 0); |
278 | msleep(START_DELAY_MS); |
279 | } |
280 | |
281 | error = i2c_smbus_read_i2c_block_data(client: i2c, BU21029_HWID_REG, |
282 | length: sizeof(hwid), values: (u8 *)&hwid); |
283 | if (error < 0) { |
284 | dev_err(&i2c->dev, "failed to read HW ID\n" ); |
285 | goto err_out; |
286 | } |
287 | |
288 | if (be16_to_cpu(hwid) != SUPPORTED_HWID) { |
289 | dev_err(&i2c->dev, |
290 | "unsupported HW ID 0x%x\n" , be16_to_cpu(hwid)); |
291 | error = -ENODEV; |
292 | goto err_out; |
293 | } |
294 | |
295 | for (i = 0; i < ARRAY_SIZE(init_table); ++i) { |
296 | error = i2c_smbus_write_byte_data(client: i2c, |
297 | command: init_table[i].reg, |
298 | value: init_table[i].value); |
299 | if (error < 0) { |
300 | dev_err(&i2c->dev, |
301 | "failed to write %#02x to register %#02x: %d\n" , |
302 | init_table[i].value, init_table[i].reg, |
303 | error); |
304 | goto err_out; |
305 | } |
306 | } |
307 | |
308 | error = i2c_smbus_write_byte(client: i2c, BU21029_AUTOSCAN); |
309 | if (error < 0) { |
310 | dev_err(&i2c->dev, "failed to start autoscan\n" ); |
311 | goto err_out; |
312 | } |
313 | |
314 | enable_irq(irq: bu21029->client->irq); |
315 | return 0; |
316 | |
317 | err_out: |
318 | bu21029_put_chip_in_reset(bu21029); |
319 | regulator_disable(regulator: bu21029->vdd); |
320 | return error; |
321 | } |
322 | |
323 | static void bu21029_stop_chip(struct input_dev *dev) |
324 | { |
325 | struct bu21029_ts_data *bu21029 = input_get_drvdata(dev); |
326 | |
327 | disable_irq(irq: bu21029->client->irq); |
328 | del_timer_sync(timer: &bu21029->timer); |
329 | |
330 | bu21029_put_chip_in_reset(bu21029); |
331 | regulator_disable(regulator: bu21029->vdd); |
332 | } |
333 | |
334 | static int bu21029_probe(struct i2c_client *client) |
335 | { |
336 | struct device *dev = &client->dev; |
337 | struct bu21029_ts_data *bu21029; |
338 | struct input_dev *in_dev; |
339 | int error; |
340 | |
341 | if (!i2c_check_functionality(adap: client->adapter, |
342 | I2C_FUNC_SMBUS_WRITE_BYTE | |
343 | I2C_FUNC_SMBUS_WRITE_BYTE_DATA | |
344 | I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { |
345 | dev_err(dev, "i2c functionality support is not sufficient\n" ); |
346 | return -EIO; |
347 | } |
348 | |
349 | bu21029 = devm_kzalloc(dev, size: sizeof(*bu21029), GFP_KERNEL); |
350 | if (!bu21029) |
351 | return -ENOMEM; |
352 | |
353 | error = device_property_read_u32(dev, propname: "rohm,x-plate-ohms" , val: &bu21029->x_plate_ohms); |
354 | if (error) { |
355 | dev_err(dev, "invalid 'x-plate-ohms' supplied: %d\n" , error); |
356 | return error; |
357 | } |
358 | |
359 | bu21029->vdd = devm_regulator_get(dev, id: "vdd" ); |
360 | if (IS_ERR(ptr: bu21029->vdd)) |
361 | return dev_err_probe(dev, err: PTR_ERR(ptr: bu21029->vdd), |
362 | fmt: "failed to acquire 'vdd' supply\n" ); |
363 | |
364 | bu21029->reset_gpios = devm_gpiod_get_optional(dev, con_id: "reset" , flags: GPIOD_OUT_HIGH); |
365 | if (IS_ERR(ptr: bu21029->reset_gpios)) |
366 | return dev_err_probe(dev, err: PTR_ERR(ptr: bu21029->reset_gpios), |
367 | fmt: "failed to acquire 'reset' gpio\n" ); |
368 | |
369 | in_dev = devm_input_allocate_device(dev); |
370 | if (!in_dev) { |
371 | dev_err(dev, "unable to allocate input device\n" ); |
372 | return -ENOMEM; |
373 | } |
374 | |
375 | bu21029->client = client; |
376 | bu21029->in_dev = in_dev; |
377 | timer_setup(&bu21029->timer, bu21029_touch_release, 0); |
378 | |
379 | in_dev->name = DRIVER_NAME; |
380 | in_dev->id.bustype = BUS_I2C; |
381 | in_dev->open = bu21029_start_chip; |
382 | in_dev->close = bu21029_stop_chip; |
383 | |
384 | input_set_capability(dev: in_dev, EV_KEY, BTN_TOUCH); |
385 | input_set_abs_params(dev: in_dev, ABS_X, min: 0, MAX_12BIT, fuzz: 0, flat: 0); |
386 | input_set_abs_params(dev: in_dev, ABS_Y, min: 0, MAX_12BIT, fuzz: 0, flat: 0); |
387 | input_set_abs_params(dev: in_dev, ABS_PRESSURE, min: 0, MAX_12BIT, fuzz: 0, flat: 0); |
388 | touchscreen_parse_properties(input: in_dev, multitouch: false, prop: &bu21029->prop); |
389 | |
390 | input_set_drvdata(dev: in_dev, data: bu21029); |
391 | |
392 | error = devm_request_threaded_irq(dev, irq: client->irq, NULL, |
393 | thread_fn: bu21029_touch_soft_irq, |
394 | IRQF_ONESHOT | IRQF_NO_AUTOEN, |
395 | DRIVER_NAME, dev_id: bu21029); |
396 | if (error) { |
397 | dev_err(dev, "unable to request touch irq: %d\n" , error); |
398 | return error; |
399 | } |
400 | |
401 | error = input_register_device(in_dev); |
402 | if (error) { |
403 | dev_err(dev, "unable to register input device: %d\n" , error); |
404 | return error; |
405 | } |
406 | |
407 | i2c_set_clientdata(client, data: bu21029); |
408 | |
409 | return 0; |
410 | } |
411 | |
412 | static int bu21029_suspend(struct device *dev) |
413 | { |
414 | struct i2c_client *i2c = to_i2c_client(dev); |
415 | struct bu21029_ts_data *bu21029 = i2c_get_clientdata(client: i2c); |
416 | |
417 | if (!device_may_wakeup(dev)) { |
418 | mutex_lock(&bu21029->in_dev->mutex); |
419 | if (input_device_enabled(dev: bu21029->in_dev)) |
420 | bu21029_stop_chip(dev: bu21029->in_dev); |
421 | mutex_unlock(lock: &bu21029->in_dev->mutex); |
422 | } |
423 | |
424 | return 0; |
425 | } |
426 | |
427 | static int bu21029_resume(struct device *dev) |
428 | { |
429 | struct i2c_client *i2c = to_i2c_client(dev); |
430 | struct bu21029_ts_data *bu21029 = i2c_get_clientdata(client: i2c); |
431 | |
432 | if (!device_may_wakeup(dev)) { |
433 | mutex_lock(&bu21029->in_dev->mutex); |
434 | if (input_device_enabled(dev: bu21029->in_dev)) |
435 | bu21029_start_chip(dev: bu21029->in_dev); |
436 | mutex_unlock(lock: &bu21029->in_dev->mutex); |
437 | } |
438 | |
439 | return 0; |
440 | } |
441 | static DEFINE_SIMPLE_DEV_PM_OPS(bu21029_pm_ops, bu21029_suspend, bu21029_resume); |
442 | |
443 | static const struct i2c_device_id bu21029_ids[] = { |
444 | { DRIVER_NAME, 0 }, |
445 | { /* sentinel */ } |
446 | }; |
447 | MODULE_DEVICE_TABLE(i2c, bu21029_ids); |
448 | |
449 | #ifdef CONFIG_OF |
450 | static const struct of_device_id bu21029_of_ids[] = { |
451 | { .compatible = "rohm,bu21029" }, |
452 | { /* sentinel */ } |
453 | }; |
454 | MODULE_DEVICE_TABLE(of, bu21029_of_ids); |
455 | #endif |
456 | |
457 | static struct i2c_driver bu21029_driver = { |
458 | .driver = { |
459 | .name = DRIVER_NAME, |
460 | .of_match_table = of_match_ptr(bu21029_of_ids), |
461 | .pm = pm_sleep_ptr(&bu21029_pm_ops), |
462 | }, |
463 | .id_table = bu21029_ids, |
464 | .probe = bu21029_probe, |
465 | }; |
466 | module_i2c_driver(bu21029_driver); |
467 | |
468 | MODULE_AUTHOR("Zhu Yi <yi.zhu5@cn.bosch.com>" ); |
469 | MODULE_DESCRIPTION("Rohm BU21029 touchscreen controller driver" ); |
470 | MODULE_LICENSE("GPL v2" ); |
471 | |