/*
 * Copyright (c) 2016 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Imre Vadász <imre@vdsz.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/* Register GPIO device with ACPICA for ACPI-5.0 GPIO functionality */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/errno.h>
#include <sys/lock.h>
#include <sys/bus.h>

#include "opt_acpi.h"
#include "acpi.h"
#include <dev/acpica/acpivar.h>

#include "gpio_acpivar.h"

#include "gpio_if.h"

struct acpi_event_info {
        device_t dev;
        u_int pin;
        void *cookie;
        int trigger;
};

struct acpi_gpio_handler_data {
        struct acpi_connection_info info;
        device_t dev;
};

struct gpio_acpi_softc {
        device_t dev;
        device_t parent;
        struct acpi_event_info *infos;
        int num_aei;
        struct acpi_gpio_handler_data space_handler_data;
};

static int      gpio_acpi_probe(device_t dev);
static int      gpio_acpi_attach(device_t dev);
static int      gpio_acpi_detach(device_t dev);

static BOOLEAN  gpio_acpi_check_gpioint(device_t dev, ACPI_RESOURCE_GPIO *gpio);
static void     **gpioio_alloc_pins(device_t dev, device_t provider,
                    ACPI_RESOURCE_GPIO *gpio, uint16_t idx, uint16_t length,
                    void **buf);

/* GPIO Address Space Handler */
static void             gpio_acpi_install_address_space_handler(
                            struct gpio_acpi_softc *sc);
static void             gpio_acpi_remove_address_space_handler(
                            struct gpio_acpi_softc *sc);
static ACPI_STATUS      gpio_acpi_space_handler(UINT32 Function,
                            ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth,
                            UINT64 *Value, void *HandlerContext,
                            void *RegionContext);

/* ACPI Event Interrupts */
static void     gpio_acpi_do_map_aei(struct gpio_acpi_softc *sc,
                    ACPI_RESOURCE_GPIO *gpio);
static void     gpio_acpi_map_aei(struct gpio_acpi_softc *sc);
static void     gpio_acpi_unmap_aei(struct gpio_acpi_softc *sc);
static void     gpio_acpi_handle_event(void *Context);
static void     gpio_acpi_aei_handler(void *arg);

/* Sanity-Check for GpioInt resources */
static BOOLEAN
gpio_acpi_check_gpioint(device_t dev, ACPI_RESOURCE_GPIO *gpio)
{
        if (gpio->PinTableLength != 1) {
                device_printf(dev,
                    "Unexepcted GpioInt resource PinTableLength %d\n",
                    gpio->PinTableLength);
                return (FALSE);
        }
        switch (gpio->Triggering) {
        case ACPI_LEVEL_SENSITIVE:
        case ACPI_EDGE_SENSITIVE:
                break;
        default:
                device_printf(dev, "Invalid GpioInt resource Triggering: %d\n",
                    gpio->Triggering);
                return (FALSE);
        }
        switch (gpio->Polarity) {
        case ACPI_ACTIVE_HIGH:
        case ACPI_ACTIVE_LOW:
        case ACPI_ACTIVE_BOTH:
                break;
        default:
                device_printf(dev, "Invalid GpioInt resource Polarity: %d\n",
                    gpio->Polarity);
                return (FALSE);
        }

        return (TRUE);
}

/*
 * GpioIo ACPI resource handling
 */

static void **
gpioio_alloc_pins(device_t dev, device_t provider, ACPI_RESOURCE_GPIO *gpio,
    uint16_t idx, uint16_t length, void **buf)
{
        void **pins;
        int flags, i, j;

        if (buf == NULL) {
                pins = kmalloc(sizeof(*pins) * length, M_DEVBUF,
                    M_WAITOK | M_ZERO);
        } else {
                pins = buf;
        }

        if (gpio->IoRestriction == ACPI_IO_RESTRICT_INPUT) {
                flags = (1U << 0);
        } else if (gpio->IoRestriction ==
            ACPI_IO_RESTRICT_OUTPUT) {
                flags = (1U << 1);
        } else {
                flags = (1U << 0) | (1U << 1);
        }
        for (i = 0; i < length; i++) {
                if (GPIO_ALLOC_IO_PIN(provider, gpio->PinTable[idx + i], flags,
                    &pins[i]) != 0) {
                        device_printf(dev, "Failed to alloc GpioIo pin %u on "
                            "ResourceSource \"%s\"\n", gpio->PinTable[idx + i],
                            gpio->ResourceSource.StringPtr);
                        /* Release already alloc-ed pins */
                        for (j = 0; j < i; j++)
                                GPIO_RELEASE_IO_PIN(provider, pins[j]);
                        goto err;
                }
        }

        return (pins);

err:
        if (buf == NULL)
                kfree(pins, M_DEVBUF);
        return (NULL);
}

/*
 * GPIO Address space handler
 */

static void
gpio_acpi_install_address_space_handler(struct gpio_acpi_softc *sc)
{
        struct acpi_gpio_handler_data *data = &sc->space_handler_data;
        ACPI_HANDLE handle;
        ACPI_STATUS s;

        handle = acpi_get_handle(sc->parent);
        data->dev = sc->parent;
        s = AcpiInstallAddressSpaceHandler(handle, ACPI_ADR_SPACE_GPIO,
            &gpio_acpi_space_handler, NULL, data);
        if (ACPI_FAILURE(s)) {
                device_printf(sc->dev,
                    "Failed to install GPIO Address Space Handler in ACPI\n");
        }
}

static void
gpio_acpi_remove_address_space_handler(struct gpio_acpi_softc *sc)
{
        ACPI_HANDLE handle;
        ACPI_STATUS s;

        handle = acpi_get_handle(sc->parent);
        s = AcpiRemoveAddressSpaceHandler(handle, ACPI_ADR_SPACE_GPIO,
            &gpio_acpi_space_handler);
        if (ACPI_FAILURE(s)) {
                device_printf(sc->dev,
                    "Failed to remove GPIO Address Space Handler from ACPI\n");
        }
}

static ACPI_STATUS
gpio_acpi_space_handler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address,
    UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
{
        struct acpi_gpio_handler_data *data = HandlerContext;
        device_t dev = data->dev;
        struct acpi_connection_info *info = &data->info;
        struct acpi_resource_gpio *gpio;
        UINT64 val;
        UINT8 action = Function & ACPI_IO_MASK;
        ACPI_RESOURCE *Resource;
        ACPI_STATUS s = AE_OK;
        void **pins;
        int i;

        if (Value == NULL)
                return (AE_BAD_PARAMETER);

        /* XXX probably unnecessary */
        if (BitWidth == 0 || BitWidth > 64)
                return (AE_BAD_PARAMETER);

        s = AcpiBufferToResource(info->Connection, info->Length, &Resource);
        if (ACPI_FAILURE(s)) {
                device_printf(dev, "AcpiBufferToResource failed\n");
                return (s);
        }
        if (Resource->Type != ACPI_RESOURCE_TYPE_GPIO) {
                device_printf(dev, "Resource->Type is wrong\n");
                s = AE_BAD_PARAMETER;
                goto err;
        }
        gpio = &Resource->Data.Gpio;
        if (gpio->ConnectionType != ACPI_RESOURCE_GPIO_TYPE_IO) {
                device_printf(dev, "gpio->ConnectionType is wrong\n");
                s = AE_BAD_PARAMETER;
                goto err;
        }

        if (Address + BitWidth > gpio->PinTableLength) {
                device_printf(dev, "Address + BitWidth out of range\n");
                s = AE_BAD_ADDRESS;
                goto err;
        }

        if (gpio->IoRestriction == ACPI_IO_RESTRICT_OUTPUT &&
            action == ACPI_READ) {
                device_printf(dev,
                    "IoRestriction is output only, but action is ACPI_READ\n");
                s = AE_BAD_PARAMETER;
                goto err;
        }
        if (gpio->IoRestriction == ACPI_IO_RESTRICT_INPUT &&
            action == ACPI_WRITE) {
                device_printf(dev,
                    "IoRestriction is input only, but action is ACPI_WRITE\n");
                s = AE_BAD_PARAMETER;
                goto err;
        }

        /* Make sure we can access all pins, before trying actual read/write */
        pins = gpioio_alloc_pins(dev, dev, gpio, Address, BitWidth, NULL);
        if (pins == NULL) {
                s = AE_BAD_PARAMETER;
                goto err;
        }

        if (action == ACPI_READ) {
                *Value = 0;
                for (i = 0; i < BitWidth; i++) {
                        val = GPIO_READ_PIN(dev, pins[i]);
                        *Value |= val << i;
                }
        } else {
                for (i = 0; i < BitWidth; i++) {
                        GPIO_WRITE_PIN(dev, pins[i],
                            (*Value & (1ULL << i)) ? 1 : 0);
                }
        }
        for (i = 0; i < BitWidth; i++)
                GPIO_RELEASE_IO_PIN(dev, pins[i]);
        kfree(pins, M_DEVBUF);

err:
        ACPI_FREE(Resource);
        return (s);
}

/*
 * ACPI Event Interrupts
 */

static void
gpio_acpi_handle_event(void *Context)
{
        struct acpi_event_info *info = (struct acpi_event_info *)Context;
        ACPI_HANDLE handle, h;
        ACPI_STATUS s;
        char buf[5];

        handle = acpi_get_handle(device_get_parent(info->dev));
        if (info->trigger == ACPI_EDGE_SENSITIVE) {
                ksnprintf(buf, sizeof(buf), "_E%02X", info->pin);
        } else {
                ksnprintf(buf, sizeof(buf), "_L%02X", info->pin);
        }
        if (info->pin <= 255 && ACPI_SUCCESS(AcpiGetHandle(handle, buf, &h))) {
                s = AcpiEvaluateObject(handle, buf, NULL, NULL);
                if (ACPI_FAILURE(s))
                        device_printf(info->dev, "evaluating %s failed\n", buf);
        } else {
                ACPI_OBJECT_LIST arglist;
                ACPI_OBJECT arg;

                arglist.Pointer = &arg;
                arglist.Count = 1;
                arg.Type = ACPI_TYPE_INTEGER;
                arg.Integer.Value = info->pin;
                s = AcpiEvaluateObject(handle, "_EVT", &arglist, NULL);
                if (ACPI_FAILURE(s))
                        device_printf(info->dev, "evaluating _EVT failed\n");
        }
}

static void
gpio_acpi_aei_handler(void *arg)
{
        struct acpi_event_info *info = (struct acpi_event_info *)arg;
        ACPI_STATUS s;

        s = AcpiOsExecute(OSL_GPE_HANDLER, gpio_acpi_handle_event, arg);
        if (ACPI_FAILURE(s)) {
                device_printf(info->dev,
                    "AcpiOsExecute for Acpi Event handler failed\n");
        }
}

static void
gpio_acpi_do_map_aei(struct gpio_acpi_softc *sc, ACPI_RESOURCE_GPIO *gpio)
{
        struct acpi_event_info *info = &sc->infos[sc->num_aei];
        uint16_t pin;
        void *cookie;

        if (gpio->ConnectionType != ACPI_RESOURCE_GPIO_TYPE_INT) {
                device_printf(sc->dev, "Unexpected gpio type %d\n",
                    gpio->ConnectionType);
                return;
        }

        /* sc->dev is correct here, since it's only used for device_printf */
        if (!gpio_acpi_check_gpioint(sc->dev, gpio))
                return;

        pin = gpio->PinTable[0];

        if (GPIO_ALLOC_INTR(sc->parent, pin, gpio->Triggering, gpio->Polarity,
            gpio->PinConfig, &cookie) != 0) {
                device_printf(sc->dev,
                    "Failed to allocate AEI interrupt on pin %d\n", pin);
                return;
        }

        info->dev = sc->dev;
        info->pin = pin;
        info->trigger = gpio->Triggering;
        info->cookie = cookie;

        GPIO_SETUP_INTR(sc->parent, cookie, info, gpio_acpi_aei_handler);
        sc->num_aei++;
}

/* Map ACPI events */
static void
gpio_acpi_map_aei(struct gpio_acpi_softc *sc)
{
        ACPI_HANDLE handle = acpi_get_handle(sc->parent);
        ACPI_RESOURCE_GPIO *gpio;
        ACPI_RESOURCE *res, *end;
        ACPI_BUFFER b;
        ACPI_STATUS s;
        int n;

        sc->infos = NULL;
        sc->num_aei = 0;

        b.Pointer = NULL;
        b.Length = ACPI_ALLOCATE_BUFFER;
        s = AcpiGetEventResources(handle, &b);
        if (ACPI_FAILURE(s))
                return;

        end = (ACPI_RESOURCE *)((char *)b.Pointer + b.Length);
        /* Count Gpio connections */
        n = 0;
        for (res = (ACPI_RESOURCE *)b.Pointer; res < end;
            res = ACPI_NEXT_RESOURCE(res)) {
                if (res->Type == ACPI_RESOURCE_TYPE_END_TAG) {
                        break;
                } else if (res->Type == ACPI_RESOURCE_TYPE_GPIO) {
                        n++;
                } else {
                        device_printf(sc->dev, "Unexpected resource type %d\n",
                            res->Type);
                }
        }
        if (n <= 0) {
                AcpiOsFree(b.Pointer);
                return;
        }
        sc->infos = kmalloc(n*sizeof(*sc->infos), M_DEVBUF, M_WAITOK | M_ZERO);
        for (res = (ACPI_RESOURCE *)b.Pointer; res < end && sc->num_aei < n;
            res = ACPI_NEXT_RESOURCE(res)) {
                if (res->Type == ACPI_RESOURCE_TYPE_END_TAG)
                        break;
                if (res->Type == ACPI_RESOURCE_TYPE_GPIO) {
                        gpio = (ACPI_RESOURCE_GPIO *)&res->Data;
                        gpio_acpi_do_map_aei(sc, gpio);
                }
        }
        AcpiOsFree(b.Pointer);
}

/*  Unmap ACPI events */
static void
gpio_acpi_unmap_aei(struct gpio_acpi_softc *sc)
{
        struct acpi_event_info *info;
        int i;

        for (i = 0; i < sc->num_aei; i++) {
                info = &sc->infos[i];
                KKASSERT(info->dev != NULL);
                GPIO_TEARDOWN_INTR(sc->parent, info->cookie);
                GPIO_FREE_INTR(sc->parent, info->cookie);
                /* XXX Wait until ACPI Event handler has finished */
                memset(info, 0, sizeof(*info));
        }
        kfree(sc->infos, M_DEVBUF);
        sc->infos = NULL;
        sc->num_aei = 0;
}

static int
gpio_acpi_probe(device_t dev)
{
        if (acpi_get_handle(device_get_parent(dev)) == NULL)
                return (ENXIO);

        device_set_desc(dev, "ACPI GeneralPurposeIo backend");

        return (0);
}

static int
gpio_acpi_attach(device_t dev)
{
        struct gpio_acpi_softc *sc = device_get_softc(dev);

        sc->dev = dev;
        sc->parent = device_get_parent(dev);

        gpio_acpi_install_address_space_handler(sc);

        gpio_acpi_map_aei(sc);

        return (0);
}

static int
gpio_acpi_detach(device_t dev)
{
        struct gpio_acpi_softc *sc = device_get_softc(dev);

        if (sc->infos != NULL)
                gpio_acpi_unmap_aei(sc);

        gpio_acpi_remove_address_space_handler(sc);

        return (0);
}


static device_method_t gpio_acpi_methods[] = {
        /* Device interface */
        DEVMETHOD(device_probe, gpio_acpi_probe),
        DEVMETHOD(device_attach, gpio_acpi_attach),
        DEVMETHOD(device_detach, gpio_acpi_detach),

        DEVMETHOD_END
};

static driver_t gpio_acpi_driver = {
        "gpio_acpi",
        gpio_acpi_methods,
        sizeof(struct gpio_acpi_softc)
};

static devclass_t gpio_acpi_devclass;

DRIVER_MODULE(gpio_acpi, gpio_intel, gpio_acpi_driver, gpio_acpi_devclass,
    NULL, NULL);
MODULE_DEPEND(gpio_acpi, acpi, 1, 1, 1);
MODULE_VERSION(gpio_acpi, 1);