/*	$OpenBSD: pwmleds.c,v 1.2 2023/04/25 11:12:38 tobhe Exp $	*/
/*
 * Copyright (c) 2022 Mark Kettenis <kettenis@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/malloc.h>

#include <machine/bus.h>
#include <machine/fdt.h>

#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_misc.h>
#include <dev/ofw/fdt.h>

#include <dev/wscons/wsconsio.h>

extern int (*wskbd_get_backlight)(struct wskbd_backlight *);
extern int (*wskbd_set_backlight)(struct wskbd_backlight *);

struct pwmleds_softc {
	struct device		sc_dev;

	/* Keyboard backlight. */
	uint32_t		*sc_pwm;
	int			 sc_pwm_len;
	uint32_t		 sc_max_brightness;
	struct pwm_state	 sc_ps_saved;
};

int	pwmleds_match(struct device *, void *, void *);
void	pwmleds_attach(struct device *, struct device *, void *);
int	pwmleds_activate(struct device *, int);

const struct cfattach pwmleds_ca = {
	sizeof (struct pwmleds_softc), pwmleds_match, pwmleds_attach, NULL,
	pwmleds_activate
};

struct cfdriver pwmleds_cd = {
	NULL, "pwmleds", DV_DULL
};

int pwmleds_get_kbd_backlight(struct wskbd_backlight *);
int pwmleds_set_kbd_backlight(struct wskbd_backlight *);

int
pwmleds_match(struct device *parent, void *match, void *aux)
{
	const struct fdt_attach_args	*faa = aux;

	return OF_is_compatible(faa->fa_node, "pwm-leds");
}

void
pwmleds_attach(struct device *parent, struct device *self, void *aux)
{
	struct pwmleds_softc *sc = (struct pwmleds_softc *)self;
	struct fdt_attach_args	*faa = aux;
	char *function;
	int len, node;

	printf("\n");

	for (node = OF_child(faa->fa_node); node; node = OF_peer(node)) {
		len = OF_getproplen(node, "function");
		if (len <= 0)
			continue;

		function = malloc(len, M_TEMP, M_WAITOK);
		OF_getprop(node, "function", function, len);
		if (strcmp(function, "kbd_backlight") != 0) {
			free(function, M_TEMP, len);
			continue;
		}
		free(function, M_TEMP, len);

		len = OF_getproplen(node, "pwms");
		if (len <= 0)
			continue;

		sc->sc_pwm = malloc(len, M_DEVBUF, M_WAITOK);
		OF_getpropintarray(node, "pwms", sc->sc_pwm, len);
		sc->sc_pwm_len = len;

		sc->sc_max_brightness =
		    OF_getpropint(node, "max-brightness", 0);
		wskbd_get_backlight = pwmleds_get_kbd_backlight;
		wskbd_set_backlight = pwmleds_set_kbd_backlight;
	}
}

int
pwmleds_activate(struct device *self, int act)
{
	struct pwmleds_softc *sc = (struct pwmleds_softc *)self;
	struct pwm_state ps;
	int error;

	switch (act) {
	case DVACT_QUIESCE:
		error = pwm_get_state(sc->sc_pwm, &sc->sc_ps_saved);
		if (error)
			return error;

		pwm_init_state(sc->sc_pwm, &ps);
		ps.ps_pulse_width = 0;
		ps.ps_enabled = 0;
		return pwm_set_state(sc->sc_pwm, &ps);
	case DVACT_WAKEUP:
		return pwm_set_state(sc->sc_pwm, &sc->sc_ps_saved);
	}
	return 0;
}

struct pwmleds_softc *
pwmleds_kbd_backlight(void)
{
	struct pwmleds_softc *sc;
	int i;

	for (i = 0; i < pwmleds_cd.cd_ndevs; i++) {
		sc = pwmleds_cd.cd_devs[i];
		if (sc == NULL)
			continue;
		if (sc->sc_max_brightness > 0)
			return sc;
	}

	return NULL;
}

int
pwmleds_get_kbd_backlight(struct wskbd_backlight *kbl)
{
	struct pwmleds_softc *sc;
	struct pwm_state ps;
	int error;

	sc = pwmleds_kbd_backlight();
	if (sc == NULL)
		return ENOTTY;

	error = pwm_get_state(sc->sc_pwm, &ps);
	if (error)
		return error;

	kbl->min = 0;
	kbl->max = sc->sc_max_brightness;
	kbl->curval = (ps.ps_enabled) ?
	    ((uint64_t)ps.ps_pulse_width * kbl->max) / ps.ps_period : 0;
	return 0;
}

int
pwmleds_set_kbd_backlight(struct wskbd_backlight *kbl)
{
	struct pwmleds_softc *sc;
	struct pwm_state ps;

	sc = pwmleds_kbd_backlight();
	if (sc == NULL)
		return ENOTTY;

	if (kbl->curval < 0 || kbl->curval > sc->sc_max_brightness)
		return EINVAL;

	pwm_init_state(sc->sc_pwm, &ps);
	ps.ps_pulse_width =
	    ((uint64_t)kbl->curval * ps.ps_period) / sc->sc_max_brightness;
	ps.ps_enabled = (ps.ps_pulse_width > 0);
	return pwm_set_state(sc->sc_pwm, &ps);
}