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