1/* $NetBSD: pwm_backlight.c,v 1.10 2021/11/07 17:14:09 jmcneill Exp $ */
2
3/*-
4 * Copyright (c) 2018 Jared McNeill <jmcneill@invisible.ca>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__KERNEL_RCSID(0, "$NetBSD: pwm_backlight.c,v 1.10 2021/11/07 17:14:09 jmcneill Exp $");
31
32#include <sys/param.h>
33#include <sys/bus.h>
34#include <sys/device.h>
35#include <sys/systm.h>
36#include <sys/sysctl.h>
37#include <sys/kmem.h>
38#include <sys/gpio.h>
39
40#include <dev/pwm/pwmvar.h>
41
42#include <dev/fdt/fdtvar.h>
43
44struct pwm_backlight_softc {
45	device_t		sc_dev;
46	pwm_tag_t		sc_pwm;
47	struct fdtbus_gpio_pin *sc_pin;
48
49	u_int			*sc_levels;
50	u_int			sc_nlevels;
51	u_int			sc_curlevel;
52
53	char			*sc_levelstr;
54
55	bool			sc_lid_state;
56};
57
58static int	pwm_backlight_match(device_t, cfdata_t, void *);
59static void	pwm_backlight_attach(device_t, device_t, void *);
60
61static void	pwm_backlight_sysctl_init(struct pwm_backlight_softc *);
62static void	pwm_backlight_pmf_init(struct pwm_backlight_softc *);
63static void	pwm_backlight_set(struct pwm_backlight_softc *, u_int, bool);
64static u_int	pwm_backlight_get(struct pwm_backlight_softc *);
65
66static const struct device_compatible_entry compat_data[] = {
67	{ .compat = "pwm-backlight" },
68	DEVICE_COMPAT_EOL
69};
70
71CFATTACH_DECL_NEW(pwmbacklight, sizeof(struct pwm_backlight_softc),
72	pwm_backlight_match, pwm_backlight_attach, NULL, NULL);
73
74static int
75pwm_backlight_match(device_t parent, cfdata_t cf, void *aux)
76{
77	struct fdt_attach_args * const faa = aux;
78
79	return of_compatible_match(faa->faa_phandle, compat_data);
80}
81
82static void
83pwm_backlight_attach(device_t parent, device_t self, void *aux)
84{
85	struct pwm_backlight_softc * const sc = device_private(self);
86	struct fdt_attach_args * const faa = aux;
87	const int phandle = faa->faa_phandle;
88	const u_int *levels;
89	u_int default_level = 0;
90	u_int n;
91	int len;
92
93	sc->sc_dev = self;
94	sc->sc_pwm = fdtbus_pwm_acquire(phandle, "pwms");
95	if (sc->sc_pwm == NULL) {
96		aprint_error(": couldn't acquire pwm\n");
97		return;
98	}
99	if (of_hasprop(phandle, "enable-gpios")) {
100		sc->sc_pin = fdtbus_gpio_acquire(phandle, "enable-gpios",
101		    GPIO_PIN_OUTPUT);
102		if (!sc->sc_pin) {
103			aprint_error(": couldn't acquire enable gpio\n");
104			return;
105		}
106		fdtbus_gpio_write(sc->sc_pin, 1);
107	}
108
109	levels = fdtbus_get_prop(phandle, "brightness-levels", &len);
110	if (levels != NULL) {
111		sc->sc_nlevels = len / 4;
112		sc->sc_levels = kmem_alloc(len, KM_SLEEP);
113		for (n = 0; n < sc->sc_nlevels; n++)
114			sc->sc_levels[n] = be32toh(levels[n]);
115	} else {
116		sc->sc_nlevels = 256;
117		sc->sc_levels = kmem_alloc(sc->sc_nlevels * 4, KM_SLEEP);
118		for (n = 0; n < sc->sc_nlevels; n++)
119			sc->sc_levels[n] = n;
120		default_level = 200;
121	}
122
123	aprint_naive("\n");
124	aprint_normal(": PWM Backlight");
125	if (sc->sc_nlevels > 1) {
126		aprint_normal(", %u-%u (%u steps)",
127		    sc->sc_levels[0], sc->sc_levels[sc->sc_nlevels - 1],
128		    sc->sc_nlevels);
129	}
130	aprint_normal("\n");
131
132	sc->sc_lid_state = true;
133
134	of_getprop_uint32(phandle, "default-brightness-level", &default_level);
135	if (default_level != 0) {
136		/* set the default level now */
137		pwm_backlight_set(sc, default_level, true);
138	}
139
140	sc->sc_curlevel = pwm_backlight_get(sc);
141
142	pwm_backlight_sysctl_init(sc);
143	pwm_backlight_pmf_init(sc);
144}
145
146static void
147pwm_backlight_set(struct pwm_backlight_softc *sc, u_int index, bool set_cur)
148{
149	struct pwm_config conf;
150
151	if (index >= sc->sc_nlevels)
152		return;
153
154	KASSERT(sc->sc_levels[sc->sc_nlevels - 1] != 0);
155	aprint_debug_dev(sc->sc_dev, "set duty cycle to %u%%\n",
156	    (100 * sc->sc_levels[index]) / sc->sc_levels[sc->sc_nlevels - 1]);
157
158	pwm_disable(sc->sc_pwm);
159	pwm_get_config(sc->sc_pwm, &conf);
160	conf.duty_cycle = (conf.period * sc->sc_levels[index]) / sc->sc_levels[sc->sc_nlevels - 1];
161	pwm_set_config(sc->sc_pwm, &conf);
162	pwm_enable(sc->sc_pwm);
163
164	if (set_cur)
165		sc->sc_curlevel = index;
166}
167
168static u_int
169pwm_backlight_get(struct pwm_backlight_softc *sc)
170{
171	struct pwm_config conf;
172	u_int raw_val, n;
173
174	pwm_get_config(sc->sc_pwm, &conf);
175
176	raw_val = (conf.duty_cycle * sc->sc_levels[sc->sc_nlevels - 1]) / conf.period;
177
178	/* Return the closest setting to the raw value */
179	for (n = 0; n < sc->sc_nlevels; n++) {
180		if (raw_val <= sc->sc_levels[n])
181			break;
182	}
183	return n;
184}
185
186static int
187pwm_backlight_sysctl_helper(SYSCTLFN_ARGS)
188{
189	struct pwm_backlight_softc * const sc = rnode->sysctl_data;
190	struct sysctlnode node;
191	int error;
192	u_int level, n;
193
194	node = *rnode;
195	node.sysctl_data = &level;
196
197	n = pwm_backlight_get(sc);
198	level = sc->sc_levels[n];
199
200	error = sysctl_lookup(SYSCTLFN_CALL(&node));
201	if (error || newp == NULL)
202		return error;
203
204	for (n = 0; n < sc->sc_nlevels; n++) {
205		if (sc->sc_levels[n] == level) {
206			pwm_backlight_set(sc, n, true);
207			return 0;
208		}
209	}
210
211	return EINVAL;
212}
213
214static void
215pwm_backlight_sysctl_init(struct pwm_backlight_softc *sc)
216{
217	const struct sysctlnode *node, *pwmnode;
218	struct sysctllog *log = NULL;
219	int error;
220	u_int n;
221
222	sc->sc_levelstr = kmem_zalloc(strlen("XXXXX ") * sc->sc_nlevels, KM_SLEEP);
223	for (n = 0; n < sc->sc_nlevels; n++) {
224		char buf[7];
225		snprintf(buf, sizeof(buf), n ? " %u" : "%u", sc->sc_levels[n]);
226		strcat(sc->sc_levelstr, buf);
227	}
228
229	error = sysctl_createv(&log, 0, NULL, &node,
230	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
231	    NULL, 0, NULL, 0, CTL_HW, CTL_EOL);
232	if (error)
233		goto failed;
234
235	error = sysctl_createv(&log, 0, &node, &pwmnode,
236	    0, CTLTYPE_NODE, device_xname(sc->sc_dev), NULL,
237	    NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
238	if (error)
239		goto failed;
240
241	error = sysctl_createv(&log, 0, &pwmnode, NULL,
242	    0, CTLTYPE_STRING, "levels", NULL,
243	    NULL, 0, sc->sc_levelstr, 0,
244	    CTL_CREATE, CTL_EOL);
245	if (error)
246		goto failed;
247
248	error = sysctl_createv(&log, 0, &pwmnode, NULL,
249	    CTLFLAG_READWRITE, CTLTYPE_INT, "level", NULL,
250	    pwm_backlight_sysctl_helper, 0, (void *)sc, 0,
251	    CTL_CREATE, CTL_EOL);
252	if (error)
253		goto failed;
254
255	return;
256
257failed:
258	aprint_error_dev(sc->sc_dev, "couldn't create sysctl nodes: %d\n", error);
259	sysctl_teardown(&log);
260}
261
262static void
263pwm_backlight_enable(struct pwm_backlight_softc *sc, int enable)
264{
265	if (sc->sc_pin)
266		fdtbus_gpio_write(sc->sc_pin, enable);
267	else
268		pwm_backlight_set(sc, enable ? sc->sc_curlevel : 0, false);
269}
270
271static void
272pwm_backlight_display_on(device_t dev)
273{
274	struct pwm_backlight_softc * const sc = device_private(dev);
275
276	if (sc->sc_lid_state)
277		pwm_backlight_enable(sc, 1);
278}
279
280static void
281pwm_backlight_display_off(device_t dev)
282{
283	struct pwm_backlight_softc * const sc = device_private(dev);
284
285	pwm_backlight_enable(sc, 0);
286}
287
288static void
289pwm_backlight_chassis_lid_open(device_t dev)
290{
291	struct pwm_backlight_softc * const sc = device_private(dev);
292
293	sc->sc_lid_state = true;
294
295	pwm_backlight_enable(sc, 1);
296}
297
298static void
299pwm_backlight_chassis_lid_close(device_t dev)
300{
301	struct pwm_backlight_softc * const sc = device_private(dev);
302
303	sc->sc_lid_state = false;
304
305	pwm_backlight_enable(sc, 0);
306}
307
308static void
309pwm_backlight_display_brightness_up(device_t dev)
310{
311	struct pwm_backlight_softc * const sc = device_private(dev);
312	u_int n;
313
314	n = pwm_backlight_get(sc);
315	if (n < sc->sc_nlevels - 1)
316		pwm_backlight_set(sc, n + 1, true);
317}
318
319static void
320pwm_backlight_display_brightness_down(device_t dev)
321{
322	struct pwm_backlight_softc * const sc = device_private(dev);
323	u_int n;
324
325	n = pwm_backlight_get(sc);
326	if (n > 0)
327		pwm_backlight_set(sc, n - 1, true);
328}
329
330static void
331pwm_backlight_pmf_init(struct pwm_backlight_softc *sc)
332{
333	pmf_event_register(sc->sc_dev, PMFE_DISPLAY_ON,
334	    pwm_backlight_display_on, true);
335	pmf_event_register(sc->sc_dev, PMFE_DISPLAY_OFF,
336	    pwm_backlight_display_off, true);
337	pmf_event_register(sc->sc_dev, PMFE_CHASSIS_LID_OPEN,
338	    pwm_backlight_chassis_lid_open, true);
339	pmf_event_register(sc->sc_dev, PMFE_CHASSIS_LID_CLOSE,
340	    pwm_backlight_chassis_lid_close, true);
341	pmf_event_register(sc->sc_dev, PMFE_DISPLAY_BRIGHTNESS_UP,
342	    pwm_backlight_display_brightness_up, true);
343	pmf_event_register(sc->sc_dev, PMFE_DISPLAY_BRIGHTNESS_DOWN,
344	    pwm_backlight_display_brightness_down, true);
345}
346