1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2020 Marek Vasut <marex@denx.de> |
4 | * |
5 | * Based on rpi_touchscreen.c by Eric Anholt <eric@anholt.net> |
6 | */ |
7 | |
8 | #include <linux/backlight.h> |
9 | #include <linux/err.h> |
10 | #include <linux/gpio/driver.h> |
11 | #include <linux/i2c.h> |
12 | #include <linux/init.h> |
13 | #include <linux/interrupt.h> |
14 | #include <linux/module.h> |
15 | #include <linux/regmap.h> |
16 | #include <linux/regulator/driver.h> |
17 | #include <linux/regulator/machine.h> |
18 | #include <linux/regulator/of_regulator.h> |
19 | #include <linux/slab.h> |
20 | |
21 | /* I2C registers of the Atmel microcontroller. */ |
22 | #define REG_ID 0x80 |
23 | #define REG_PORTA 0x81 |
24 | #define REG_PORTB 0x82 |
25 | #define REG_PORTC 0x83 |
26 | #define REG_POWERON 0x85 |
27 | #define REG_PWM 0x86 |
28 | #define REG_ADDR_L 0x8c |
29 | #define REG_ADDR_H 0x8d |
30 | #define REG_WRITE_DATA_H 0x90 |
31 | #define REG_WRITE_DATA_L 0x91 |
32 | |
33 | #define PA_LCD_DITHB BIT(0) |
34 | #define PA_LCD_MODE BIT(1) |
35 | #define PA_LCD_LR BIT(2) |
36 | #define PA_LCD_UD BIT(3) |
37 | |
38 | #define PB_BRIDGE_PWRDNX_N BIT(0) |
39 | #define PB_LCD_VCC_N BIT(1) |
40 | #define PB_LCD_MAIN BIT(7) |
41 | |
42 | #define PC_LED_EN BIT(0) |
43 | #define PC_RST_TP_N BIT(1) |
44 | #define PC_RST_LCD_N BIT(2) |
45 | #define PC_RST_BRIDGE_N BIT(3) |
46 | |
47 | enum gpio_signals { |
48 | RST_BRIDGE_N, /* TC358762 bridge reset */ |
49 | RST_TP_N, /* Touch controller reset */ |
50 | NUM_GPIO |
51 | }; |
52 | |
53 | struct gpio_signal_mappings { |
54 | unsigned int reg; |
55 | unsigned int mask; |
56 | }; |
57 | |
58 | static const struct gpio_signal_mappings mappings[NUM_GPIO] = { |
59 | [RST_BRIDGE_N] = { REG_PORTC, PC_RST_BRIDGE_N | PC_RST_LCD_N }, |
60 | [RST_TP_N] = { REG_PORTC, PC_RST_TP_N }, |
61 | }; |
62 | |
63 | struct attiny_lcd { |
64 | /* lock to serialise overall accesses to the Atmel */ |
65 | struct mutex lock; |
66 | struct regmap *regmap; |
67 | bool gpio_states[NUM_GPIO]; |
68 | u8 port_states[3]; |
69 | |
70 | struct gpio_chip gc; |
71 | }; |
72 | |
73 | static const struct regmap_config attiny_regmap_config = { |
74 | .reg_bits = 8, |
75 | .val_bits = 8, |
76 | .disable_locking = 1, |
77 | .max_register = REG_WRITE_DATA_L, |
78 | .cache_type = REGCACHE_RBTREE, |
79 | }; |
80 | |
81 | static int attiny_set_port_state(struct attiny_lcd *state, int reg, u8 val) |
82 | { |
83 | state->port_states[reg - REG_PORTA] = val; |
84 | return regmap_write(map: state->regmap, reg, val); |
85 | }; |
86 | |
87 | static u8 attiny_get_port_state(struct attiny_lcd *state, int reg) |
88 | { |
89 | return state->port_states[reg - REG_PORTA]; |
90 | }; |
91 | |
92 | static int attiny_lcd_power_enable(struct regulator_dev *rdev) |
93 | { |
94 | struct attiny_lcd *state = rdev_get_drvdata(rdev); |
95 | |
96 | mutex_lock(&state->lock); |
97 | |
98 | /* Ensure bridge, and tp stay in reset */ |
99 | attiny_set_port_state(state, REG_PORTC, val: 0); |
100 | usleep_range(min: 5000, max: 10000); |
101 | |
102 | /* Default to the same orientation as the closed source |
103 | * firmware used for the panel. Runtime rotation |
104 | * configuration will be supported using VC4's plane |
105 | * orientation bits. |
106 | */ |
107 | attiny_set_port_state(state, REG_PORTA, PA_LCD_LR); |
108 | usleep_range(min: 5000, max: 10000); |
109 | /* Main regulator on, and power to the panel (LCD_VCC_N) */ |
110 | attiny_set_port_state(state, REG_PORTB, PB_LCD_MAIN); |
111 | usleep_range(min: 5000, max: 10000); |
112 | /* Bring controllers out of reset */ |
113 | attiny_set_port_state(state, REG_PORTC, PC_LED_EN); |
114 | |
115 | msleep(msecs: 80); |
116 | |
117 | mutex_unlock(lock: &state->lock); |
118 | |
119 | return 0; |
120 | } |
121 | |
122 | static int attiny_lcd_power_disable(struct regulator_dev *rdev) |
123 | { |
124 | struct attiny_lcd *state = rdev_get_drvdata(rdev); |
125 | |
126 | mutex_lock(&state->lock); |
127 | |
128 | regmap_write(map: rdev->regmap, REG_PWM, val: 0); |
129 | usleep_range(min: 5000, max: 10000); |
130 | |
131 | attiny_set_port_state(state, REG_PORTA, val: 0); |
132 | usleep_range(min: 5000, max: 10000); |
133 | attiny_set_port_state(state, REG_PORTB, PB_LCD_VCC_N); |
134 | usleep_range(min: 5000, max: 10000); |
135 | attiny_set_port_state(state, REG_PORTC, val: 0); |
136 | msleep(msecs: 30); |
137 | |
138 | mutex_unlock(lock: &state->lock); |
139 | |
140 | return 0; |
141 | } |
142 | |
143 | static int attiny_lcd_power_is_enabled(struct regulator_dev *rdev) |
144 | { |
145 | struct attiny_lcd *state = rdev_get_drvdata(rdev); |
146 | unsigned int data; |
147 | int ret, i; |
148 | |
149 | mutex_lock(&state->lock); |
150 | |
151 | for (i = 0; i < 10; i++) { |
152 | ret = regmap_read(map: rdev->regmap, REG_PORTC, val: &data); |
153 | if (!ret) |
154 | break; |
155 | usleep_range(min: 10000, max: 12000); |
156 | } |
157 | |
158 | mutex_unlock(lock: &state->lock); |
159 | |
160 | if (ret < 0) |
161 | return ret; |
162 | |
163 | return data & PC_RST_BRIDGE_N; |
164 | } |
165 | |
166 | static const struct regulator_init_data attiny_regulator_default = { |
167 | .constraints = { |
168 | .valid_ops_mask = REGULATOR_CHANGE_STATUS, |
169 | }, |
170 | }; |
171 | |
172 | static const struct regulator_ops attiny_regulator_ops = { |
173 | .enable = attiny_lcd_power_enable, |
174 | .disable = attiny_lcd_power_disable, |
175 | .is_enabled = attiny_lcd_power_is_enabled, |
176 | }; |
177 | |
178 | static const struct regulator_desc attiny_regulator = { |
179 | .name = "tc358762-power" , |
180 | .ops = &attiny_regulator_ops, |
181 | .type = REGULATOR_VOLTAGE, |
182 | .owner = THIS_MODULE, |
183 | }; |
184 | |
185 | static int attiny_update_status(struct backlight_device *bl) |
186 | { |
187 | struct attiny_lcd *state = bl_get_data(bl_dev: bl); |
188 | struct regmap *regmap = state->regmap; |
189 | int brightness = backlight_get_brightness(bd: bl); |
190 | int ret, i; |
191 | |
192 | mutex_lock(&state->lock); |
193 | |
194 | for (i = 0; i < 10; i++) { |
195 | ret = regmap_write(map: regmap, REG_PWM, val: brightness); |
196 | if (!ret) |
197 | break; |
198 | } |
199 | |
200 | mutex_unlock(lock: &state->lock); |
201 | |
202 | return ret; |
203 | } |
204 | |
205 | static const struct backlight_ops attiny_bl = { |
206 | .update_status = attiny_update_status, |
207 | }; |
208 | |
209 | static int attiny_gpio_get_direction(struct gpio_chip *gc, unsigned int off) |
210 | { |
211 | return GPIO_LINE_DIRECTION_OUT; |
212 | } |
213 | |
214 | static void attiny_gpio_set(struct gpio_chip *gc, unsigned int off, int val) |
215 | { |
216 | struct attiny_lcd *state = gpiochip_get_data(gc); |
217 | u8 last_val; |
218 | |
219 | if (off >= NUM_GPIO) |
220 | return; |
221 | |
222 | mutex_lock(&state->lock); |
223 | |
224 | last_val = attiny_get_port_state(state, reg: mappings[off].reg); |
225 | if (val) |
226 | last_val |= mappings[off].mask; |
227 | else |
228 | last_val &= ~mappings[off].mask; |
229 | |
230 | attiny_set_port_state(state, reg: mappings[off].reg, val: last_val); |
231 | |
232 | if (off == RST_BRIDGE_N && val) { |
233 | usleep_range(min: 5000, max: 8000); |
234 | regmap_write(map: state->regmap, REG_ADDR_H, val: 0x04); |
235 | usleep_range(min: 5000, max: 8000); |
236 | regmap_write(map: state->regmap, REG_ADDR_L, val: 0x7c); |
237 | usleep_range(min: 5000, max: 8000); |
238 | regmap_write(map: state->regmap, REG_WRITE_DATA_H, val: 0x00); |
239 | usleep_range(min: 5000, max: 8000); |
240 | regmap_write(map: state->regmap, REG_WRITE_DATA_L, val: 0x00); |
241 | |
242 | msleep(msecs: 100); |
243 | } |
244 | |
245 | mutex_unlock(lock: &state->lock); |
246 | } |
247 | |
248 | static int attiny_i2c_read(struct i2c_client *client, u8 reg, unsigned int *buf) |
249 | { |
250 | struct i2c_msg msgs[1]; |
251 | u8 addr_buf[1] = { reg }; |
252 | u8 data_buf[1] = { 0, }; |
253 | int ret; |
254 | |
255 | /* Write register address */ |
256 | msgs[0].addr = client->addr; |
257 | msgs[0].flags = 0; |
258 | msgs[0].len = ARRAY_SIZE(addr_buf); |
259 | msgs[0].buf = addr_buf; |
260 | |
261 | ret = i2c_transfer(adap: client->adapter, msgs, ARRAY_SIZE(msgs)); |
262 | if (ret != ARRAY_SIZE(msgs)) |
263 | return -EIO; |
264 | |
265 | usleep_range(min: 5000, max: 10000); |
266 | |
267 | /* Read data from register */ |
268 | msgs[0].addr = client->addr; |
269 | msgs[0].flags = I2C_M_RD; |
270 | msgs[0].len = 1; |
271 | msgs[0].buf = data_buf; |
272 | |
273 | ret = i2c_transfer(adap: client->adapter, msgs, ARRAY_SIZE(msgs)); |
274 | if (ret != ARRAY_SIZE(msgs)) |
275 | return -EIO; |
276 | |
277 | *buf = data_buf[0]; |
278 | return 0; |
279 | } |
280 | |
281 | /* |
282 | * I2C driver interface functions |
283 | */ |
284 | static int attiny_i2c_probe(struct i2c_client *i2c) |
285 | { |
286 | struct backlight_properties props = { }; |
287 | struct regulator_config config = { }; |
288 | struct backlight_device *bl; |
289 | struct regulator_dev *rdev; |
290 | struct attiny_lcd *state; |
291 | struct regmap *regmap; |
292 | unsigned int data; |
293 | int ret; |
294 | |
295 | state = devm_kzalloc(dev: &i2c->dev, size: sizeof(*state), GFP_KERNEL); |
296 | if (!state) |
297 | return -ENOMEM; |
298 | |
299 | mutex_init(&state->lock); |
300 | i2c_set_clientdata(client: i2c, data: state); |
301 | |
302 | regmap = devm_regmap_init_i2c(i2c, &attiny_regmap_config); |
303 | if (IS_ERR(ptr: regmap)) { |
304 | ret = PTR_ERR(ptr: regmap); |
305 | dev_err(&i2c->dev, "Failed to allocate register map: %d\n" , |
306 | ret); |
307 | goto error; |
308 | } |
309 | |
310 | ret = attiny_i2c_read(client: i2c, REG_ID, buf: &data); |
311 | if (ret < 0) { |
312 | dev_err(&i2c->dev, "Failed to read REG_ID reg: %d\n" , ret); |
313 | goto error; |
314 | } |
315 | |
316 | switch (data) { |
317 | case 0xde: /* ver 1 */ |
318 | case 0xc3: /* ver 2 */ |
319 | break; |
320 | default: |
321 | dev_err(&i2c->dev, "Unknown Atmel firmware revision: 0x%02x\n" , data); |
322 | ret = -ENODEV; |
323 | goto error; |
324 | } |
325 | |
326 | regmap_write(map: regmap, REG_POWERON, val: 0); |
327 | msleep(msecs: 30); |
328 | regmap_write(map: regmap, REG_PWM, val: 0); |
329 | |
330 | config.dev = &i2c->dev; |
331 | config.regmap = regmap; |
332 | config.of_node = i2c->dev.of_node; |
333 | config.init_data = &attiny_regulator_default; |
334 | config.driver_data = state; |
335 | |
336 | rdev = devm_regulator_register(dev: &i2c->dev, regulator_desc: &attiny_regulator, config: &config); |
337 | if (IS_ERR(ptr: rdev)) { |
338 | dev_err(&i2c->dev, "Failed to register ATTINY regulator\n" ); |
339 | ret = PTR_ERR(ptr: rdev); |
340 | goto error; |
341 | } |
342 | |
343 | props.type = BACKLIGHT_RAW; |
344 | props.max_brightness = 0xff; |
345 | |
346 | state->regmap = regmap; |
347 | |
348 | bl = devm_backlight_device_register(dev: &i2c->dev, name: dev_name(dev: &i2c->dev), |
349 | parent: &i2c->dev, devdata: state, ops: &attiny_bl, |
350 | props: &props); |
351 | if (IS_ERR(ptr: bl)) { |
352 | ret = PTR_ERR(ptr: bl); |
353 | goto error; |
354 | } |
355 | |
356 | bl->props.brightness = 0xff; |
357 | |
358 | state->gc.parent = &i2c->dev; |
359 | state->gc.label = i2c->name; |
360 | state->gc.owner = THIS_MODULE; |
361 | state->gc.base = -1; |
362 | state->gc.ngpio = NUM_GPIO; |
363 | |
364 | state->gc.set = attiny_gpio_set; |
365 | state->gc.get_direction = attiny_gpio_get_direction; |
366 | state->gc.can_sleep = true; |
367 | |
368 | ret = devm_gpiochip_add_data(&i2c->dev, &state->gc, state); |
369 | if (ret) { |
370 | dev_err(&i2c->dev, "Failed to create gpiochip: %d\n" , ret); |
371 | goto error; |
372 | } |
373 | |
374 | return 0; |
375 | |
376 | error: |
377 | mutex_destroy(lock: &state->lock); |
378 | |
379 | return ret; |
380 | } |
381 | |
382 | static void attiny_i2c_remove(struct i2c_client *client) |
383 | { |
384 | struct attiny_lcd *state = i2c_get_clientdata(client); |
385 | |
386 | mutex_destroy(lock: &state->lock); |
387 | } |
388 | |
389 | static const struct of_device_id attiny_dt_ids[] = { |
390 | { .compatible = "raspberrypi,7inch-touchscreen-panel-regulator" }, |
391 | {}, |
392 | }; |
393 | MODULE_DEVICE_TABLE(of, attiny_dt_ids); |
394 | |
395 | static struct i2c_driver attiny_regulator_driver = { |
396 | .driver = { |
397 | .name = "rpi_touchscreen_attiny" , |
398 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
399 | .of_match_table = attiny_dt_ids, |
400 | }, |
401 | .probe = attiny_i2c_probe, |
402 | .remove = attiny_i2c_remove, |
403 | }; |
404 | |
405 | module_i2c_driver(attiny_regulator_driver); |
406 | |
407 | MODULE_AUTHOR("Marek Vasut <marex@denx.de>" ); |
408 | MODULE_DESCRIPTION("Regulator device driver for Raspberry Pi 7-inch touchscreen" ); |
409 | MODULE_LICENSE("GPL v2" ); |
410 | |