/* $OpenBSD: acpials.c,v 1.4 2020/08/26 03:29:06 visa Exp $ */
/*
 * Ambient Light Sensor device driver
 * ACPI 5.0 spec section 9.2
 *
 * Copyright (c) 2016 joshua stein <jcs@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 <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/acpidev.h>
#include <dev/acpi/amltypes.h>
#include <dev/acpi/dsdt.h>

#include <sys/sensors.h>

/* #define ACPIALS_DEBUG */

#ifdef ACPIALS_DEBUG
#define DPRINTF(x) printf x
#else
#define DPRINTF(x)
#endif

struct acpials_softc {
        struct device           sc_dev;

        bus_space_tag_t         sc_iot;
        bus_space_handle_t      sc_ioh;

        struct acpi_softc       *sc_acpi;
        struct aml_node         *sc_devnode;

        struct ksensor          sc_sensor;
        struct ksensordev       sc_sensordev;
        struct sensor_task      *sc_sensor_task;
};

int     acpials_match(struct device *, void *, void *);
void    acpials_attach(struct device *, struct device *, void *);
int     acpials_read(struct acpials_softc *);
int     acpials_notify(struct aml_node *, int, void *);
void    acpials_addtask(void *);
void    acpials_update(void *, int);

const struct cfattach acpials_ca = {
        sizeof(struct acpials_softc),
        acpials_match,
        acpials_attach,
};

struct cfdriver acpials_cd = {
        NULL, "acpials", DV_DULL
};

const char *acpials_hids[] = {
        "ACPI0008",
        NULL
};

int
acpials_match(struct device *parent, void *match, void *aux)
{
        struct acpi_attach_args *aa = aux;
        struct cfdata *cf = match;

        /*
         * Apple hardware will most likely have asmc(4) which also provides an
         * illuminance sensor.
         */
        if (hw_vendor != NULL && strncmp(hw_vendor, "Apple", 5) == 0)
                return 0;

        return (acpi_matchhids(aa, acpials_hids, cf->cf_driver->cd_name));
}

void
acpials_attach(struct device *parent, struct device *self, void *aux)
{
        struct acpials_softc *sc = (struct acpials_softc *)self;
        struct acpi_attach_args *aa = aux;
        int64_t st;

        sc->sc_acpi = (struct acpi_softc *)parent;
        sc->sc_devnode = aa->aaa_node;

        printf(": %s\n", sc->sc_devnode->name);

        if (aml_evalinteger(sc->sc_acpi, sc->sc_devnode, "_STA", 0, NULL, &st))
                st = STA_PRESENT | STA_ENABLED | STA_DEV_OK;
        if ((st & (STA_PRESENT | STA_ENABLED | STA_DEV_OK)) !=
            (STA_PRESENT | STA_ENABLED | STA_DEV_OK))
                return;

        if (acpials_read(sc))
                return;

        strlcpy(sc->sc_sensordev.xname, DEVNAME(sc),
            sizeof(sc->sc_sensordev.xname));
        strlcpy(sc->sc_sensor.desc, "ambient light sensor",
            sizeof(sc->sc_sensor.desc));
        sc->sc_sensor.type = SENSOR_LUX;
        sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);

        /*
         * aml_register_notify with ACPIDEV_POLL is too slow (10 second
         * intervals), so register the task with sensors so we can specify the
         * interval, which will then just inject an acpi task and tell it to
         * wakeup to handle the task.
         */
        if (!(sc->sc_sensor_task = sensor_task_register(sc, acpials_addtask,
            1))) {
                printf("%s: unable to register task\n", sc->sc_dev.dv_xname);
                return;
        }

        /*
         * But also install an event handler in case AML Notify()s us of any
         * large changes - 9.2.7
         */
        aml_register_notify(sc->sc_devnode, aa->aaa_dev, acpials_notify,
            sc, ACPIDEV_NOPOLL);

        sensordev_install(&sc->sc_sensordev);
}

int
acpials_read(struct acpials_softc *sc)
{
        int64_t ali = 0;

        /* 9.2.2 - "Current ambient light illuminance reading in lux" */
        if (aml_evalinteger(sc->sc_acpi, sc->sc_devnode, "_ALI", 0, NULL,
            &ali))
                return 1;

        sc->sc_sensor.value = (ali * 1000000);

        return 0;
}

int
acpials_notify(struct aml_node *node, int notify_type, void *arg)
{
        struct acpials_softc *sc = arg;

        DPRINTF(("%s: %s: %d\n", sc->sc_dev.dv_xname, __func__, notify_type));

        if (notify_type == 0x80)
                acpials_read(sc);

        return 0;
}

void
acpials_addtask(void *arg)
{
        struct acpials_softc *sc = arg;

        acpi_addtask(sc->sc_acpi, acpials_update, sc, 0);
        acpi_wakeup(sc->sc_acpi);
}

void
acpials_update(void *arg0, int arg1)
{
        struct acpials_softc *sc = arg0;

        if (acpials_read(sc) == 0) {
                DPRINTF(("%s: %s: %lld\n", sc->sc_dev.dv_xname, __func__,
                    sc->sc_sensor.value));
                sc->sc_sensor.flags &= ~SENSOR_FINVALID;
        } else
                sc->sc_sensor.flags |= SENSOR_FINVALID;
}