/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2022 Tetsuya Uemura <t_uemura@macome.co.jp>
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
#include "opt_acpi.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/callout.h>
#include <sys/eventhandler.h>
#include <sys/interrupt.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/queue.h>
#include <sys/rman.h>
#include <sys/sysctl.h>
#include <sys/watchdog.h>
#include <vm/vm.h>
#include <vm/pmap.h>

#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/aclocal.h>
#include <contrib/dev/acpica/include/actables.h>

#include <dev/acpica/acpivar.h>

/*
 * Resource entry. Every instruction has the corresponding ACPI GAS but two or
 * more instructions may access the same or adjacent register region(s). So we
 * need to merge all the specified resources.
 *
 * res   Resource when allocated.
 * start Region start address.
 * end   Region end address + 1.
 * rid   Resource rid assigned when allocated.
 * type  ACPI resource type, SYS_RES_IOPORT or SYS_RES_MEMORY.
 * link  Next/previous resource entry.
 */
struct wdat_res {
        struct resource         *res;
        uint64_t                start;
        uint64_t                end;
        int                     rid;
        int                     type;
        TAILQ_ENTRY(wdat_res)   link;
};

/*
 * Instruction entry. Every instruction itself is actually a single register
 * read or write (and subsequent bit operation(s)).
 * 0 or more instructions are tied to every watchdog action and once an action
 * is kicked, the corresponding entries run sequentially.
 *
 * entry Permanent copy of ACPI_WDAT_ENTRY entry (sub-table).
 * next  Next instruction entry.
 */
struct wdat_instr {
        ACPI_WDAT_ENTRY         entry;
        STAILQ_ENTRY(wdat_instr) next;
};

/*
 * dev             Watchdog device.
 * wdat            ACPI WDAT table, can be accessed until AcpiPutTable().
 * default_timeout BIOS configured watchdog ticks to fire.
 * timeout         User configured timeout in millisecond or 0 if isn't set.
 * max             Max. supported watchdog ticks to be set.
 * min             Min. supported watchdog ticks to be set.
 * period          Milliseconds per watchdog tick.
 * running         True if this watchdog is running or false if stopped.
 * stop_in_sleep   False if this watchdog keeps counting down during sleep.
 * ev_tag          Tag for EVENTHANDLER_*().
 * action          Array of watchdog instruction sets, each indexed by action.
 */
struct wdatwd_softc {
        device_t                dev;
        ACPI_TABLE_WDAT         *wdat;
        uint64_t                default_timeout;
        uint64_t                timeout;
        u_int                   max;
        u_int                   min;
        u_int                   period;
        bool                    running;
        bool                    stop_in_sleep;
        eventhandler_tag        ev_tag;
        STAILQ_HEAD(, wdat_instr) action[ACPI_WDAT_ACTION_RESERVED];
        TAILQ_HEAD(res_head, wdat_res) res;
};

#define WDATWD_VERBOSE_PRINTF(dev, ...)                                 \
        do {                                                            \
                if (bootverbose)                                        \
                        device_printf(dev, __VA_ARGS__);                \
        } while (0)

/*
 * Do requested action.
 */
static int
wdatwd_action(const struct wdatwd_softc *sc, const u_int action, const uint64_t val, uint64_t *ret)
{
        struct wdat_instr       *wdat;
        const char              *rw = NULL;
        ACPI_STATUS             status;

        if (STAILQ_EMPTY(&sc->action[action])) {
                WDATWD_VERBOSE_PRINTF(sc->dev,
                    "action not supported: 0x%02x\n", action);
                return (EOPNOTSUPP);
        }

        STAILQ_FOREACH(wdat, &sc->action[action], next) {
                ACPI_GENERIC_ADDRESS    *gas = &wdat->entry.RegisterRegion;
                uint64_t                x, y;

                switch (wdat->entry.Instruction
                    & ~ACPI_WDAT_PRESERVE_REGISTER) {
                    case ACPI_WDAT_READ_VALUE:
                        status = AcpiRead(&x, gas);
                        if (ACPI_FAILURE(status)) {
                                rw = "AcpiRead";
                                goto fail;
                        }
                        x >>= gas->BitOffset;
                        x &= wdat->entry.Mask;
                        *ret = (x == wdat->entry.Value) ? 1 : 0;
                        break;
                    case ACPI_WDAT_READ_COUNTDOWN:
                        status = AcpiRead(&x, gas);
                        if (ACPI_FAILURE(status)) {
                                rw = "AcpiRead";
                                goto fail;
                        }
                        x >>= gas->BitOffset;
                        x &= wdat->entry.Mask;
                        *ret = x;
                        break;
                    case ACPI_WDAT_WRITE_VALUE:
                        x = wdat->entry.Value & wdat->entry.Mask;
                        x <<= gas->BitOffset;
                        if (wdat->entry.Instruction
                            & ACPI_WDAT_PRESERVE_REGISTER) {
                                status = AcpiRead(&y, gas);
                                if (ACPI_FAILURE(status)) {
                                        rw = "AcpiRead";
                                        goto fail;
                                }
                                y &= ~(wdat->entry.Mask << gas->BitOffset);
                                x |= y;
                        }
                        status = AcpiWrite(x, gas);
                        if (ACPI_FAILURE(status)) {
                                rw = "AcpiWrite";
                                goto fail;
                        }
                        break;
                    case ACPI_WDAT_WRITE_COUNTDOWN:
                        x = val & wdat->entry.Mask;
                        x <<= gas->BitOffset;
                        if (wdat->entry.Instruction
                            & ACPI_WDAT_PRESERVE_REGISTER) {
                                status = AcpiRead(&y, gas);
                                if (ACPI_FAILURE(status)) {
                                        rw = "AcpiRead";
                                        goto fail;
                                }
                                y &= ~(wdat->entry.Mask << gas->BitOffset);
                                x |= y;
                        }
                        status = AcpiWrite(x, gas);
                        if (ACPI_FAILURE(status)) {
                                rw = "AcpiWrite";
                                goto fail;
                        }
                        break;
                    default:
                        return (EINVAL);
                }
        }

        return (0);

fail:
        device_printf(sc->dev, "action: 0x%02x, %s() returned: %d\n",
            action, rw, status);
        return (ENXIO);
}

/*
 * Reset the watchdog countdown.
 */
static int
wdatwd_reset_countdown(const struct wdatwd_softc *sc)
{
        return wdatwd_action(sc, ACPI_WDAT_RESET, 0, NULL);
}

/*
 * Set the watchdog countdown value. In WDAT specification, this is optional.
 */
static int
wdatwd_set_countdown(struct wdatwd_softc *sc, u_int cmd)
{
        uint64_t                timeout;
        int                     e;

        cmd &= WD_INTERVAL;
        timeout = ((uint64_t) 1 << cmd) / 1000000 / sc->period;
        if (timeout > sc->max)
                timeout = sc->max;
        else if (timeout < sc->min)
                timeout = sc->min;

        e = wdatwd_action(sc, ACPI_WDAT_SET_COUNTDOWN, timeout, NULL);
        if (e == 0)
                sc->timeout = timeout * sc->period;

        return (e);
}

/*
 * Get the watchdog current countdown value.
 */
static int
wdatwd_get_current_countdown(const struct wdatwd_softc *sc, uint64_t *timeout)
{
        return wdatwd_action(sc, ACPI_WDAT_GET_CURRENT_COUNTDOWN, 0, timeout);
}

/*
 * Get the watchdog countdown value the watchdog is configured to fire.
 */
static int
wdatwd_get_countdown(const struct wdatwd_softc *sc, uint64_t *timeout)
{
        return wdatwd_action(sc, ACPI_WDAT_GET_COUNTDOWN, 0, timeout);
}

/*
 * Set the watchdog to running state.
 */
static int
wdatwd_set_running(struct wdatwd_softc *sc)
{
        int                     e;

        e = wdatwd_action(sc, ACPI_WDAT_SET_RUNNING_STATE, 0, NULL);
        if (e == 0)
                sc->running = true;
        return (e);
}

/*
 * Set the watchdog to stopped state.
 */
static int
wdatwd_set_stop(struct wdatwd_softc *sc)
{
        int                     e;

        e = wdatwd_action(sc, ACPI_WDAT_SET_STOPPED_STATE, 0, NULL);
        if (e == 0)
                sc->running = false;
        return (e);
}

/*
 * Clear the watchdog's boot status if the current boot was caused by the
 * watchdog firing.
 */
static int
wdatwd_clear_status(const struct wdatwd_softc *sc)
{
        return wdatwd_action(sc, ACPI_WDAT_SET_STATUS, 0, NULL);
}

/*
 * Set the watchdog to reboot when it is fired.
 */
static int
wdatwd_set_reboot(const struct wdatwd_softc *sc)
{
        return wdatwd_action(sc, ACPI_WDAT_SET_REBOOT, 0, NULL);
}

/*
 * Watchdog event handler.
 */
static void
wdatwd_event(void *private, u_int cmd, int *error)
{
        struct wdatwd_softc     *sc = private;
        uint64_t                cur[2], cnt[2];
        bool                    run[2];

        if (bootverbose) {
                run[0] = sc->running;
                if (wdatwd_get_countdown(sc, &cnt[0]) != 0) 
                        cnt[0] = 0;
                if (wdatwd_get_current_countdown(sc, &cur[0]) != 0)
                        cur[0] = 0;
        }

        if ((cmd & WD_INTERVAL) == 0)
                wdatwd_set_stop(sc);
        else {
                if (!sc->running) {
                        /* ACPI_WDAT_SET_COUNTDOWN may not be implemented. */
                        wdatwd_set_countdown(sc, cmd);
                        wdatwd_set_running(sc);
                        /*
                         * In the first wdatwd_event() call, it sets the
                         * watchdog timeout to a considerably larger value such
                         * as 137 seconds, then kicks the watchdog to start
                         * counting down. Weirdly though, on a Dell R210 BIOS
                         * 1.12.0, a supplemental reset action must be
                         * triggered for the newly set timeout value to take
                         * effect. Without it, the watchdog fires 2.4 seconds
                         * after starting, where 2.4 seconds is its initially
                         * set timeout. This failure scenario is seen by first
                         * starting watchdogd(8) without wdatwd registered then
                         * kldload it. In steady state, watchdogd pats the
                         * watchdog every 10 or so seconds which is much longer
                         * than 2.4 seconds timeout.
                         */
                }
                wdatwd_reset_countdown(sc);
        }

        if (bootverbose) {
                run[1] = sc->running;
                if (wdatwd_get_countdown(sc, &cnt[1]) != 0)
                        cnt[1] = 0;
                if (wdatwd_get_current_countdown(sc, &cur[1]) != 0)
                        cur[1] = 0;
                WDATWD_VERBOSE_PRINTF(sc->dev, "cmd: %u, sc->running: "
                    "%d -> %d, cnt: %llu -> %llu, cur: %llu -> %llu\n", cmd,
                                      run[0], run[1], 
                                      (unsigned long long) cnt[0],
                                      (unsigned long long) cnt[1],
                                      (unsigned long long)cur[0],
                                      (unsigned long long)cur[1]);
        }

        return;
}

static ssize_t
wdat_set_action(struct wdatwd_softc *sc, ACPI_WDAT_ENTRY *addr, ssize_t remaining)
{
        ACPI_WDAT_ENTRY         *entry = addr;
        struct wdat_instr       *wdat;

        if (remaining < sizeof(ACPI_WDAT_ENTRY))
                return (-EINVAL);

        /* Skip actions beyond specification. */
        if (entry->Action < nitems(sc->action)) {
                wdat = malloc(sizeof(*wdat), M_DEVBUF, M_WAITOK | M_ZERO);
                wdat->entry = *entry;
                STAILQ_INSERT_TAIL(&sc->action[entry->Action], wdat, next);
        }
        return sizeof(ACPI_WDAT_ENTRY);
}

/*
 * Transform every ACPI_WDAT_ENTRY to wdat_instr by calling wdat_set_action().
 */
static void
wdat_parse_action_table(struct wdatwd_softc *sc)
{
        ACPI_TABLE_WDAT         *wdat = sc->wdat;
        ssize_t                 remaining, consumed;
        char                    *cp;

        remaining = wdat->Header.Length - sizeof(ACPI_TABLE_WDAT);
        while (remaining > 0) {
                cp = (char *)wdat + wdat->Header.Length - remaining;
                consumed = wdat_set_action(sc, (ACPI_WDAT_ENTRY *)cp,
                    remaining);
                if (consumed < 0) {
                        device_printf(sc->dev, "inconsistent WDAT table.\n");
                        break;
                }
                        remaining -= consumed;
        }
}

/*
 * Decode the given GAS rr and set its type, start and end (actually end + 1)
 * in the newly malloc()'ed res.
 */
static struct wdat_res *
wdat_alloc_region(ACPI_GENERIC_ADDRESS *rr)
{
        struct wdat_res *res;

        if (rr->AccessWidth < 1 || rr->AccessWidth > 4)
                return (NULL);

        res = malloc(sizeof(*res),
            M_DEVBUF, M_WAITOK | M_ZERO);
        if (res != NULL) {
                res->start = rr->Address;
                res->end   = res->start + (1 << (rr->AccessWidth - 1));
                res->type  = rr->SpaceId;
        }
        return (res);
}

#define OVERLAP_NONE    0x0 // no overlap.
#define OVERLAP_SUBSET  0x1 // res2 is fully covered by res1.
#define OVERLAP_START   0x2 // the start of res2 is overlaped.
#define OVERLAP_END     0x4 // the end of res2 is overlapped.

/*
 * Compare the given res1 and res2, and one of the above OVERLAP_* constant, or
 * in case res2 is larger than res1 at both the start and the end,
 * OVERLAP_START | OVERLAP_END, is returned.
 */
static int
wdat_compare_region(const struct wdat_res *res1, const struct wdat_res *res2)
{
        int overlap;

        /*
         * a) both have different resource type. == OVERLAP_NONE
         * b) res2 and res1 have no overlap.     == OVERLAP_NONE
         * c) res2 is fully covered by res1.     == OVERLAP_SUBSET
         * d) res2 and res1 overlap partially.   == OVERLAP_START or
         *                                          OVERLAP_END
         * e) res2 fully covers res1.            == OVERLAP_START | OVERLAP_END
         */
        overlap = 0;

        if (res1->type != res2->type || res1->start > res2->end
            || res1->end < res2->start)
                overlap |= OVERLAP_NONE;
        else {
                if (res1->start <= res2->start && res1->end >= res2->end)
                        overlap |= OVERLAP_SUBSET;
                if (res1->start > res2->start)
                        overlap |= OVERLAP_START;
                if (res1->end < res2->end)
                        overlap |= OVERLAP_END;
        }

        return (overlap);
}

/*
 * Try to merge the given newres with the existing sc->res.
 */
static void
wdat_merge_region(struct wdatwd_softc *sc, struct wdat_res *newres)
{
        struct wdat_res         *res1, *res2, *res_safe, *res_itr;
        int                     overlap;

        if (TAILQ_EMPTY(&sc->res)) {
                TAILQ_INSERT_HEAD(&sc->res, newres, link);
                return;
        }

        overlap = OVERLAP_NONE;

        TAILQ_FOREACH_SAFE(res1, &sc->res, link, res_safe) {
                overlap = wdat_compare_region(res1, newres);

                /* Try next res if newres isn't mergeable. */
                if (overlap == OVERLAP_NONE)
                        continue;

                /* This res fully covers newres. */
                if (overlap == OVERLAP_SUBSET)
                        break;

                /* Newres extends the existing res res1 to lower. */
                if ((overlap & OVERLAP_START)) {
                        res1->start = newres->start;
                        res_itr = res1;
                        /* Try to merge more res if possible. */
                        while ((res2 = TAILQ_PREV(res_itr, res_head, link))) {
                                if (res1->type != res2->type) {
                                        res_itr = res2;
                                        continue;
                                } else if (res1->start <= res2->end) {
                                        res1->start = res2->start;
                                        TAILQ_REMOVE(&sc->res, res2, link);
                                        free(res2, M_DEVBUF);
                                } else
                                        break;
                        }
                }
                /* Newres extends the existing res res1 to upper. */
                if ((overlap & OVERLAP_END)) {
                        res1->end = newres->end;
                        res_itr = res1;
                        /* Try to merge more res if possible. */
                        while ((res2 = TAILQ_NEXT(res_itr, link))) {
                                if (res1->type != res2->type) {
                                        res_itr = res2;
                                        continue;
                                } else if (res1->end >= res2->start) {
                                        res1->end = res2->end;
                                        TAILQ_REMOVE(&sc->res, res2, link);
                                        free(res2, M_DEVBUF);
                                } else
                                        break;
                        }
                }
                break;
        }

        /*
         * If newres extends the existing res, newres must be free()'ed.
         * Otherwise insert newres into sc->res at appropriate position
         * (the lowest address region appears first).
         */
        if (overlap > OVERLAP_NONE)
                free(newres, M_DEVBUF);
        else {
                TAILQ_FOREACH(res1, &sc->res, link) {
                        if (newres->type != res1->type)
                                continue;
                        if (newres->start < res1->start) {
                                TAILQ_INSERT_BEFORE(res1, newres, link);
                                break;
                        }
                }
                if (res1 == NULL)
                        TAILQ_INSERT_TAIL(&sc->res, newres, link);
        }
}

/*
 * Release the already allocated resource.
 */
static void
wdat_release_resource(device_t dev)
{
        struct wdatwd_softc     *sc;
        struct wdat_instr       *wdat;
        struct wdat_res         *res;
        int                     i;

        sc = device_get_softc(dev);

        TAILQ_FOREACH(res, &sc->res, link)
                if (res->res != NULL) {
                        bus_release_resource(dev, res->type,
                            res->rid, res->res);
                        bus_delete_resource(dev, res->type, res->rid);
                        res->res = NULL;
                }

        for (i = 0; i < nitems(sc->action); ++i)
                while (!STAILQ_EMPTY(&sc->action[i])) {
                        wdat = STAILQ_FIRST(&sc->action[i]);
                        STAILQ_REMOVE_HEAD(&sc->action[i], next);
                        free(wdat, M_DEVBUF);
                }

        while (!TAILQ_EMPTY(&sc->res)) {
                res = TAILQ_FIRST(&sc->res);
                TAILQ_REMOVE(&sc->res, res, link);
                free(res, M_DEVBUF);
        }
}

static int
wdatwd_probe(device_t dev)
{
        ACPI_TABLE_WDAT         *wdat;
        ACPI_STATUS             status;

        /* Without WDAT table we have nothing to do. */
        status = AcpiGetTable(ACPI_SIG_WDAT, 0, (ACPI_TABLE_HEADER **)&wdat);
        if (ACPI_FAILURE(status))
                return (ENXIO);

        /* Try to allocate one resource and assume wdatwd is already attached
         * if it fails. */
        {
                int             type, rid = 0;
                struct resource *res;

                if (acpi_bus_alloc_gas(dev, &type, rid,
                    &((ACPI_WDAT_ENTRY *)(wdat + 1))->RegisterRegion,
                    &res, 0))
                        return (ENXIO);
                bus_release_resource(dev, type, rid, res);
                bus_delete_resource(dev, type, rid);
        }

        WDATWD_VERBOSE_PRINTF(dev, "Flags: 0x%x, TimerPeriod: %d ms/cnt, "
            "MaxCount: %d cnt (%d ms), MinCount: %d cnt (%d ms)\n",
            (int)wdat->Flags, (int)wdat->TimerPeriod,
            (int)wdat->MaxCount, (int)(wdat->MaxCount * wdat->TimerPeriod),
            (int)wdat->MinCount, (int)(wdat->MinCount * wdat->TimerPeriod));
        /* WDAT timer consistency. */
        if ((wdat->TimerPeriod < 1) || (wdat->MinCount > wdat->MaxCount)) {
                device_printf(dev, "inconsistent timer variables.\n");
                return (EINVAL);
        }

        AcpiPutTable((ACPI_TABLE_HEADER *)wdat);

        device_set_desc(dev, "ACPI WDAT Watchdog Interface");
        return (BUS_PROBE_DEFAULT);
}

static int
wdatwd_attach(device_t dev)
{
        struct wdatwd_softc     *sc;
        struct wdat_instr       *wdat;
        struct wdat_res         *res;
        struct sysctl_ctx_list  *sctx;
        struct sysctl_oid       *soid;
        ACPI_STATUS             status;
        int                     e, i, rid;

        sc = device_get_softc(dev);
        sc->dev = dev;

        for (i = 0; i < nitems(sc->action); ++i)
                STAILQ_INIT(&sc->action[i]);

        /* Search and parse WDAT table. */
        status = AcpiGetTable(ACPI_SIG_WDAT, 0,
            (ACPI_TABLE_HEADER **)&sc->wdat);
        if (ACPI_FAILURE(status))
                return (ENXIO);

        /* Parse watchdog variables. */
        sc->period = sc->wdat->TimerPeriod;
        sc->max = sc->wdat->MaxCount;
        sc->min = sc->wdat->MinCount;
        sc->stop_in_sleep = (sc->wdat->Flags & ACPI_WDAT_STOPPED)
            ? true : false;
        /* Parse defined watchdog actions. */
        wdat_parse_action_table(sc);

        AcpiPutTable((ACPI_TABLE_HEADER *)sc->wdat);

        /* Verbose logging. */
        if (bootverbose) {
                for (i = 0; i < nitems(sc->action); ++i)
                        STAILQ_FOREACH(wdat, &sc->action[i], next) {
                                WDATWD_VERBOSE_PRINTF(dev, "action: 0x%02x, "
                                    "%s %s at 0x%llx (%d bit(s), offset %d bit(s))\n",
                                    i,
                                    wdat->entry.RegisterRegion.SpaceId
                                        == ACPI_ADR_SPACE_SYSTEM_MEMORY
                                        ? "mem"
                                        : wdat->entry.RegisterRegion.SpaceId
                                            == ACPI_ADR_SPACE_SYSTEM_IO
                                            ? "io "
                                            : "???",
                                    wdat->entry.RegisterRegion.AccessWidth == 1
                                        ? "byte "
                                        : wdat->entry.RegisterRegion.AccessWidth == 2
                                            ? "word "
                                            : wdat->entry.RegisterRegion.AccessWidth == 3
                                                ? "dword"
                                                : wdat->entry.RegisterRegion.AccessWidth == 4
                                                    ? "qword"
                                                    : "undef",
                                    (unsigned long long )
                                    wdat->entry.RegisterRegion.Address,
                                    wdat->entry.RegisterRegion.BitWidth,
                                    wdat->entry.RegisterRegion.BitOffset);
                }
        }

        /* Canonicalize the requested resources. */
        TAILQ_INIT(&sc->res);
        for (i = 0; i < nitems(sc->action); ++i)
                STAILQ_FOREACH(wdat, &sc->action[i], next) {
                        res = wdat_alloc_region(&wdat->entry.RegisterRegion);
                        if (res == NULL)
                                goto fail;
                        wdat_merge_region(sc, res);
                }

        /* Resource allocation. */
        rid = 0;
        TAILQ_FOREACH(res, &sc->res, link) {
                switch (res->type) {
                    case ACPI_ADR_SPACE_SYSTEM_MEMORY:
                        res->type = SYS_RES_MEMORY;
                        break;
                    case ACPI_ADR_SPACE_SYSTEM_IO:
                        res->type = SYS_RES_IOPORT;
                        break;
                    default:
                        goto fail;
                }

                res->rid = rid++;
                bus_set_resource(dev, res->type, res->rid,
                    res->start, res->end - res->start);
                res->res = bus_alloc_resource_any(
                    dev, res->type, &res->rid, RF_ACTIVE);
                if (res->res == NULL) {
                        bus_delete_resource(dev, res->type, res->rid);
                        device_printf(dev, "%s at 0x%llx (%lld byte(s)): "
                            "alloc' failed\n",
                            res->type == SYS_RES_MEMORY ? "mem" : "io ",
                            (unsigned long long )res->start,
                            (unsigned long long )(res->end - res->start));
                        goto fail;
                }
                WDATWD_VERBOSE_PRINTF(dev, "%s at 0x%llx (%lld byte(s)): "
                    "alloc'ed\n",
                    res->type == SYS_RES_MEMORY ? "mem" : "io ",
                    (unsigned long long )res->start,
                    (unsigned long long) (res->end - res->start));
        }

        /* Initialize the watchdog hardware. */
        if (wdatwd_set_stop(sc) != 0)
                goto fail;
        if ((e = wdatwd_clear_status(sc)) && e != EOPNOTSUPP)
                goto fail;
        if ((e = wdatwd_set_reboot(sc)) && e != EOPNOTSUPP)
                goto fail;
        if ((e = wdatwd_get_countdown(sc, &sc->default_timeout))
            && e != EOPNOTSUPP)
                goto fail;
        WDATWD_VERBOSE_PRINTF(dev, "initialized.\n");

        /* Some sysctls. Most of them should go to WDATWD_VERBOSE_PRINTF(). */
        sctx = device_get_sysctl_ctx(dev);
        soid = device_get_sysctl_tree(dev);
        SYSCTL_ADD_U64(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
            "timeout_default", CTLFLAG_RD, SYSCTL_NULL_U64_PTR,
            sc->default_timeout * sc->period,
            "The default watchdog timeout in millisecond.");
        SYSCTL_ADD_BOOL(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
            "timeout_configurable", CTLFLAG_RD, SYSCTL_NULL_BOOL_PTR,
            STAILQ_EMPTY(&sc->action[ACPI_WDAT_SET_COUNTDOWN]) ? false : true,
            "Whether the watchdog timeout is configurable or not.");
        SYSCTL_ADD_U64(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
            "timeout", CTLFLAG_RD, &sc->timeout, 0,
            "The current watchdog timeout in millisecond. "
            "If 0, the default timeout is used.");
        SYSCTL_ADD_BOOL(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
            "running", CTLFLAG_RD, &sc->running, 0,
            "Whether the watchdog timer is running or not.");

        sc->ev_tag = EVENTHANDLER_REGISTER(watchdog_list, wdatwd_event, sc,
            EVENTHANDLER_PRI_ANY);
        WDATWD_VERBOSE_PRINTF(dev, "watchdog registered.\n");

        return (0);

fail:
        wdat_release_resource(dev);

        return (ENXIO);
}

static int
wdatwd_detach(device_t dev)
{
        struct wdatwd_softc     *sc;
        int                     e;

        sc = device_get_softc(dev);

        EVENTHANDLER_DEREGISTER(watchdog_list, sc->ev_tag);
        e = wdatwd_set_stop(sc);
        wdat_release_resource(dev);

        return (e);
}

static int
wdatwd_suspend(device_t dev)
{
        struct wdatwd_softc     *sc;

        sc = device_get_softc(dev);

        if (!sc->stop_in_sleep)
                return (0);

        return wdatwd_set_stop(sc);
}

static int
wdatwd_resume(device_t dev)
{
        struct wdatwd_softc     *sc;

        sc = device_get_softc(dev);

        if (!sc->stop_in_sleep)
                return (0);

        return (wdatwd_reset_countdown(sc) || wdatwd_set_running(sc));
}

static device_method_t wdatwd_methods[] = {
        /* Device interface */
        DEVMETHOD(device_probe, wdatwd_probe),
        DEVMETHOD(device_attach, wdatwd_attach),
        DEVMETHOD(device_detach, wdatwd_detach),
        DEVMETHOD(device_shutdown, wdatwd_detach),
        DEVMETHOD(device_suspend, wdatwd_suspend),
        DEVMETHOD(device_resume, wdatwd_resume),
        DEVMETHOD_END
};

static driver_t wdatwd_driver = {
        "wdatwd",
        wdatwd_methods,
        sizeof(struct wdatwd_softc),
};

DRIVER_MODULE(wdatwd, acpi, wdatwd_driver, 0, 0);
MODULE_DEPEND(wdatwd, acpi, 1, 1, 1);