Do not use ! for tests:

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

Simply write the following:

sc->running = wdatwd_action(sc, ACPI_WDAT_SET_STOPPED_STATE, 0, NULL) ? true : false;

return (sc->running);

Use &cnt[0] and &cur[0] because there is no boundary checking if you use cnt or cur.

Move wdatwd_set_stop(sc) to the top and simplify the sc->running case by grouping the statements when not running because wdatwd_reset_countdown(sc) runs unconditionally:

if ((cmd & WD_INTERVAL) == 0)
  wdatwd_set_stop(sc);
else {
  if (!sc->running) {
    wdatwd_set_countdown(sc, cmd);
    wdatwd_set_running(sc);
    /* comments here */
  }
  wdatwd_reset_countdown(sc);
}

Same here as L.316.

• addr should be in ACPI_WDAT_ENTRY *, not void *
• remaining should be in ssize_t, not int
• The return value should be in size_t, not int

With the change in L.358, you can drop (int).

-EINVAL might be better than the magic number.

Use ssize_t

With the change in L.358, cp should be typecast to ACPI_WDAT_ENTRY * here.

The logic here is hard to follow. How about the following?

if (consumed < 0) {
    device_printf(sc->dev, "inconsistent WDAT table.\n");
    break;
}
remaining -= consumed;

No return is needed for void functions.

With the change in L.445:

static int
wdat_compare_region(ACPI_GENERIC_ADDRESS *rr, int *type, uint64_t *start, uint64_t *end)

With the change in L.445:

int overlap;

How about the following? See also L.445.

if (rr->AccessWidth < 1 || rr->AccessWidth > 4)
  return (-EINVAL);
s = rr->Address;
e = s + (1 << (rr->AccessWidth - 1));

Three assignments in L.452 should be just before this conditional. And then simplify the non-overlap case with the change in L.445:

if (*type != rr->SpaceId || s > *end || e < *start)
    return (OVERLAP_NONE);

Define macros instead of using magic numbers and comments. How about the following?

#define OVERLAP_NONE    0x0 // no overlap
#define OVERLAP_SUBSET  0x1 // rr is fully covered
#define OVERLAP_START   0x2 // the start is overlaped 
#define OVERLAP_END     0x4 // the end is overlapped

And this function should return the value of overlap directly. Your implementation returns EINVAL when rr->AccessWidth is invalid, but the return value is not used actually. So returning -EINVAL or any of OVERLAP_* constants would be more consistent.

Use |= instead of =

Use |= instead of +=

These should be before L.441

Use consistent variable names. If you want to use two pointers, the should be res1 and res2 or r1 and r2.

There is no need to use found. See L.483 and L.521.

WIth the change in L.445:

overlap = wdat_compare_region(&wdat->entry.RegisterRegion, &type, &s, &e);

No need to use found here because overlap > OVERLAP_NONE means the same thing

Use a macro.

Same here

Same here

Testing a pointer against NULL should be written as:

if (res->res != NULL) {

The memory regions for res itself must be released. And entries of the sc->action queue must also be released.

Return BUS_PROBE_DEFAULT instead of 0.

Is there any specific reason to use "!!"? If you want to convert a positive value to true, use the following instead:

sc->stop_in_sleep = (sc->wdat->Flags & ACPI_WDAT_STOPPED) ? true : false;

Do not put whitespace between the type and the variable name.

This for-statement block should be under if (bootverbose) because this can slow down the normal execution flow.

Using wdat_compare_region() to fill res->{type, start, end} is difficult to undestand. Splitting wdat_compare_region() into two functions, one is to fill res->{type, start, end} and another is to detect the overlap would be better. And EINVAL must be checked before inserting the entry into the sc->res queue.

Do not return without freeing the memory regions for the sc->res and sc->action queue. And ENXIO should be used as the return value.

Use nitems(sc->action) instead of ACPI_WDAT_ACTION_RESERVED

Same here as L.617

Same here as L.617

The sysctl node name should be dev.wdatwd.%d, not dev.wdat.%d

Same as L.65

Same as L.65

Same as L.65

Above wdatwd_action() may fail returning EOPNOTSUPP. If that is the case, sc->running should be kept unmodified.

wdatwd_get_countdown() and wdatwd_get_current_countdown() may fail returning EOPNOTSUPP. If so, passed cnt and cur values are kept uninitialized in those functions.

Consitify wherever possible:

wdatwd_action(const struct wdatwd_softc *sc, const u_int action, const uint64_t val, uint64_t *ret)

Consitify wherever possible:

wdatwd_reset_countdown(const struct wdatwd_softc *sc)

/unsigned int/u_int/

Consitify wherever possible:

wdatwd_get_current_countdown(const struct wdatwd_softc *sc, uint64_t *timeout)

Consitify wherever possible:

wdatwd_get_countdown(const struct wdatwd_softc *sc, uint64_t *timeout)

Consitify wherever possible:

wdatwd_clear_status(const struct wdatwd_softc *sc)

Consitify wherever possible:

wdatwd_set_reboot(const struct wdatwd_softc *sc)

The return type should be ssize_t instead of int.

Constify wherever possible:

wdat_compare_region(const struct wdat_res *res1, const struct wdat_res *res2)

The conditional at L.695 should be handled in the head of this function like this:

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

You need to use TAILQ_FOREACH_SAFE because one or more elements may be removed inside the iteration. The necessary changes will look like this:

-       struct wdat_res         *res1, *res2;
+       struct wdat_res         *res1, *res2, *res0;

-       TAILQ_FOREACH(res1, &sc->res, link) {
+       TAILQ_FOREACH_SAFE(res1, &sc->res, link, res0) {
...

This causes an infinite loop because res1 is not updated when the conditional is true. Was the following what you wanted to mean?

if (res1->type != res2->type) {
        res1 = res2;
         continue;
}

Same as L.501

This condition should be handled by wdat_merge_region().

Use EVENTHANDLER_PRI_ANY instead of 0.

To select specific driver for the specific device, the return value may be BUS_PROBE_GENERIC or BUS_PROBE_LOW_PRIORITY.

Perhaps I found a bug here, something like the following is necessary.
res1->start = newres->start;

And here.
res1->end = newres->end;