/*      $NetBSD: vald_acpi.c,v 1.8 2021/12/07 21:37:36 andvar Exp $ */

/*-
 * Copyright (c) 2002 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Masanori Kanaoka.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

/*
 * Copyright 2001 Bill Sommerfeld.
 * All rights reserved.
 *
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed for the NetBSD Project by
 *      Wasabi Systems, Inc.
 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
 *    or promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
 * 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.
 */

/*
 * ACPI VALD Driver for Toshiba Libretto L3.
 *      This driver is based on acpibat driver.
 */

/*
 * Obtain information of Toshiba "GHCI" Method from next URL.
 *           http://www.buzzard.org.uk/toshiba/docs.html
 *           http://memebeam.org/toys/ToshibaAcpiDriver
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: vald_acpi.c,v 1.8 2021/12/07 21:37:36 andvar Exp $");

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

#include <dev/acpi/acpica.h>
#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>

#define _COMPONENT          ACPI_RESOURCE_COMPONENT
ACPI_MODULE_NAME            ("vald_acpi")

#define GHCI_WORDS 6
#define GHCI_FIFO_EMPTY  0x8c00
#define GHCI_NOT_SUPPORT  0x8000

#define GHCI_BACKLIGHT          0x0002
#define GHCI_ACADAPTOR          0x0003
#define GHCI_FAN                0x0004
#define GHCI_SYSTEM_EVENT_FIFO  0x0016
#define GHCI_DISPLAY_DEVICE     0x001C
#define GHCI_HOTKEY_EVENT       0x001E

#define GHCI_ON                 0x0001
#define GHCI_OFF                0x0000
#define GHCI_ENABLE             0x0001
#define GHCI_DISABLE            0x0000

#define GHCI_CRT                0x0002
#define GHCI_LCD                0x0001


struct vald_acpi_softc {
        device_t sc_dev;                /* base device glue */
        struct acpi_devnode *sc_node;   /* our ACPI devnode */
        int sc_flags;                   /* see below */

        ACPI_HANDLE lcd_handle;         /* lcd handle */
        int *lcd_level;                 /* lcd brightness table */
        int lcd_num;                    /* size of lcd brightness table */
        int lcd_index;                  /* index of lcd brightness table */

        ACPI_INTEGER sc_ac_status;      /* AC adaptor status when attach */
};

static const struct device_compatible_entry compat_data[] = {
        { .compat = "TOS6200" },
        DEVICE_COMPAT_EOL
};

#define LIBRIGHT_HOLD   0x00
#define LIBRIGHT_UP     0x01
#define LIBRIGHT_DOWN   0x02

static int      vald_acpi_match(device_t, cfdata_t, void *);
static void     vald_acpi_attach(device_t, device_t, void *);

static void     vald_acpi_event(void *);
static void     vald_acpi_notify_handler(ACPI_HANDLE, uint32_t, void *);

#define ACPI_NOTIFY_ValdStatusChanged   0x80


static ACPI_STATUS      vald_acpi_ghci_get(struct vald_acpi_softc *, uint32_t,
                                        uint32_t *, uint32_t *);
static ACPI_STATUS      vald_acpi_ghci_set(struct vald_acpi_softc *, uint32_t,
                                        uint32_t, uint32_t *);

static ACPI_STATUS      vald_acpi_libright_get_bus(ACPI_HANDLE, uint32_t,
                                        void *, void **);
static void             vald_acpi_libright_get(struct vald_acpi_softc *);
static void             vald_acpi_libright_set(struct vald_acpi_softc *, int);

static void             vald_acpi_video_switch(struct vald_acpi_softc *);
static void             vald_acpi_fan_switch(struct vald_acpi_softc *);

static ACPI_STATUS      vald_acpi_bcm_set(ACPI_HANDLE, uint32_t);
static ACPI_STATUS      vald_acpi_dssx_set(uint32_t);

CFATTACH_DECL_NEW(vald_acpi, sizeof(struct vald_acpi_softc),
    vald_acpi_match, vald_acpi_attach, NULL, NULL);

/*
 * vald_acpi_match:
 *
 *      Autoconfiguration `match' routine.
 */
static int
vald_acpi_match(device_t parent, cfdata_t match, void *aux)
{
        struct acpi_attach_args *aa = aux;

        return acpi_compatible_match(aa, compat_data);
}

/*
 * vald_acpi_attach:
 *
 *      Autoconfiguration `attach' routine.
 */
static void
vald_acpi_attach(device_t parent, device_t self, void *aux)
{
        struct vald_acpi_softc *sc = device_private(self);
        struct acpi_attach_args *aa = aux;
        ACPI_STATUS rv;
        uint32_t value, result;

        aprint_naive(": Toshiba VALD\n");
        aprint_normal(": Toshiba VALD\n");

        sc->sc_node = aa->aa_node;
        sc->sc_dev = self;

        /* Get AC adaptor status via _PSR. */
        rv = acpi_eval_integer(ACPI_ROOT_OBJECT, "\\_SB_.ADP1._PSR",
            &sc->sc_ac_status);
        if (ACPI_FAILURE(rv))
                aprint_error_dev(self, "Unable to evaluate _PSR: %s\n",
                    AcpiFormatException(rv));
        else
                aprint_verbose_dev(self, "AC adaptor %sconnected\n",
                    (sc->sc_ac_status == 0 ? "not ": ""));

        /* Get LCD backlight status. */
        rv = vald_acpi_ghci_get(sc, GHCI_BACKLIGHT, &value, &result);
        if (ACPI_SUCCESS(rv)) {
                if (result != 0)
                        aprint_error_dev(self,
                            "can't get backlight status error=%d\n", result);
                else
                        aprint_verbose_dev(self, "LCD backlight %s\n",
                            ((value == GHCI_ON) ? "on" : "off"));
        }

        /* Enable SystemEventFIFO,HotkeyEvent */
        rv = vald_acpi_ghci_set(sc, GHCI_SYSTEM_EVENT_FIFO, GHCI_ENABLE,
            &result);
        if (ACPI_SUCCESS(rv) && result != 0)
                aprint_error_dev(self,
                    "can't enable SystemEventFIFO error=%d\n", result);

        rv = vald_acpi_ghci_set(sc, GHCI_HOTKEY_EVENT, GHCI_ENABLE, &result);
        if (ACPI_SUCCESS(rv) && result != 0)
                aprint_error_dev(self, "can't enable HotkeyEvent error=%d\n",
                    result);

        /* Check SystemFIFO events. */
        vald_acpi_event(sc);

        /* Get LCD brightness level via _BCL. */
        vald_acpi_libright_get(sc);

        /* Set LCD brightness level via _BCM. */
        vald_acpi_libright_set(sc, LIBRIGHT_HOLD);

        /* enable vald notify */
        rv = AcpiEvaluateObject(sc->sc_node->ad_handle, "ENAB", NULL, NULL);

        if (ACPI_SUCCESS(rv))
                (void)acpi_register_notify(sc->sc_node,
                    vald_acpi_notify_handler);
}

/*
 * vald_acpi_notify_handler:
 *
 *      Notify handler.
 */
static void
vald_acpi_notify_handler(ACPI_HANDLE handle, uint32_t notify, void *context)
{
        struct vald_acpi_softc *sc;
        device_t self = context;

        sc = device_private(self);

        switch (notify) {

        case ACPI_NOTIFY_ValdStatusChanged:
                (void)AcpiOsExecute(OSL_NOTIFY_HANDLER, vald_acpi_event, sc);
                break;

        default:
                aprint_error_dev(sc->sc_dev,
                    "unknown notify 0x%02X\n", notify);
                break;
        }
}

/*
 * vald_acpi_event:
 *
 *      Check hotkey event and do it, if event occur.
 */
static void
vald_acpi_event(void *arg)
{
        struct vald_acpi_softc *sc = arg;
        ACPI_STATUS rv;
        uint32_t value, result;

        while(1) {
                rv = vald_acpi_ghci_get(sc, GHCI_SYSTEM_EVENT_FIFO, &value,
                    &result);
                if (ACPI_SUCCESS(rv) && result == 0) {

                        switch (value) {
                        case 0x1c3: /* Fn + F9 */
                                break;
                        case 0x1c2: /* Fn + F8 */
                                vald_acpi_fan_switch(sc);
                                break;
                        case 0x1c1: /* Fn + F7 */
                                vald_acpi_libright_set(sc, LIBRIGHT_UP);
                                break;
                        case 0x1c0: /* Fn + F6 */
                                vald_acpi_libright_set(sc, LIBRIGHT_DOWN);
                                break;
                        case 0x1bf: /* Fn + F5 */
                                vald_acpi_video_switch(sc);
                                break;
                        default:
                                break;
                        }
                }
                if (ACPI_FAILURE(rv) || result == GHCI_FIFO_EMPTY)
                        break;
        }
}

/*
 * vald_acpi_ghci_get:
 *
 *      Get value via "GHCI" Method.
 */
static ACPI_STATUS
vald_acpi_ghci_get(struct vald_acpi_softc *sc,
    uint32_t reg, uint32_t *value, uint32_t *result)
{
        ACPI_STATUS rv;
        ACPI_OBJECT Arg[GHCI_WORDS];
        ACPI_OBJECT_LIST ArgList;
        ACPI_OBJECT *param, *PrtElement;
        ACPI_BUFFER buf;
        int             i;

        for (i = 0; i < GHCI_WORDS; i++) {
                Arg[i].Type = ACPI_TYPE_INTEGER;
                Arg[i].Integer.Value = 0;
        }

        Arg[0].Integer.Value = 0xfe00;
        Arg[1].Integer.Value = reg;
        Arg[2].Integer.Value = 0;

        ArgList.Count = GHCI_WORDS;
        ArgList.Pointer = Arg;

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_LOCAL_BUFFER;

        rv = AcpiEvaluateObject(sc->sc_node->ad_handle,
            "GHCI", &ArgList, &buf);
        if (ACPI_FAILURE(rv)) {
                aprint_error_dev(sc->sc_dev, "failed to evaluate GHCI: %s\n",
                    AcpiFormatException(rv));
                return (rv);
        }

        *result = GHCI_NOT_SUPPORT;
        *value = 0;
        param = buf.Pointer;
        if (param->Type == ACPI_TYPE_PACKAGE) {
                PrtElement = param->Package.Elements;
                if (PrtElement->Type == ACPI_TYPE_INTEGER)
                        *result = PrtElement->Integer.Value;
                PrtElement++;
                PrtElement++;
                if (PrtElement->Type == ACPI_TYPE_INTEGER)
                        *value = PrtElement->Integer.Value;
        }

        if (buf.Pointer)
                ACPI_FREE(buf.Pointer);
        return (rv);
}

/*
 * vald_acpi_ghci_set:
 *
 *      Set value via "GHCI" Method.
 */
static ACPI_STATUS
vald_acpi_ghci_set(struct vald_acpi_softc *sc,
    uint32_t reg, uint32_t value, uint32_t *result)
{
        ACPI_STATUS rv;
        ACPI_OBJECT Arg[GHCI_WORDS];
        ACPI_OBJECT_LIST ArgList;
        ACPI_OBJECT *param, *PrtElement;
        ACPI_BUFFER buf;
        int     i;


        for (i = 0; i < GHCI_WORDS; i++) {
                Arg[i].Type = ACPI_TYPE_INTEGER;
                Arg[i].Integer.Value = 0;
        }

        Arg[0].Integer.Value = 0xff00;
        Arg[1].Integer.Value = reg;
        Arg[2].Integer.Value = value;

        ArgList.Count = GHCI_WORDS;
        ArgList.Pointer = Arg;

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_LOCAL_BUFFER;

        rv = AcpiEvaluateObject(sc->sc_node->ad_handle,
            "GHCI", &ArgList, &buf);
        if (ACPI_FAILURE(rv)) {
                aprint_error_dev(sc->sc_dev, "failed to evaluate GHCI: %s\n",
                    AcpiFormatException(rv));
                return (rv);
        }

        *result = GHCI_NOT_SUPPORT;
        param = buf.Pointer;
        if (param->Type == ACPI_TYPE_PACKAGE) {
                PrtElement = param->Package.Elements;
                if (PrtElement->Type == ACPI_TYPE_INTEGER)
                        *result = PrtElement->Integer.Value;
        }

        if (buf.Pointer)
                ACPI_FREE(buf.Pointer);
        return (rv);
}

/*
 * vald_acpi_libright_get_bus:
 *
 *      Get LCD brightness level via "_BCL" Method,
 *      and save this handle.
 */
static ACPI_STATUS
vald_acpi_libright_get_bus(ACPI_HANDLE handle, uint32_t level,
    void *context, void **status)
{
        struct vald_acpi_softc *sc = context;
        ACPI_STATUS rv;
        ACPI_BUFFER buf;
        ACPI_OBJECT *param, *PrtElement;
        int i, *pi;

        rv = acpi_eval_struct(handle, "_BCL", &buf);
        if (ACPI_FAILURE(rv))
                return (AE_OK);

        sc->lcd_handle = handle;
        param = buf.Pointer;
        if (param->Type == ACPI_TYPE_PACKAGE) {
                printf("_BCL return: %d packages\n", param->Package.Count);

                sc->lcd_num = param->Package.Count;
                sc->lcd_level = ACPI_ALLOCATE(sizeof(int) * sc->lcd_num);
                if (sc->lcd_level == NULL) {
                        if (buf.Pointer)
                                ACPI_FREE(buf.Pointer);
                        return (AE_NO_MEMORY);
                }

                PrtElement = param->Package.Elements;
                pi = sc->lcd_level;
                for (i = 0; i < param->Package.Count; i++) {
                        if (PrtElement->Type == ACPI_TYPE_INTEGER) {
                                *pi = (unsigned)PrtElement->Integer.Value;
                                PrtElement++;
                                pi++;
                        }
                }
                if (sc->sc_ac_status == 1) /* AC adaptor on when attach */
                        sc->lcd_index = sc->lcd_num -1; /* MAX Brightness */
                else
                        sc->lcd_index = 3;

#ifdef ACPI_DEBUG
                pi = sc->lcd_level;
                printf("\t Full Power Level: %d\n", *pi);
                printf("\t on Battery Level: %d\n", *(pi+1));
                printf("\t Possible Level: ");
                for (i = 2;i < sc->lcd_num; i++)
                        printf(" %d", *(pi+i));
                printf("\n");
#endif
        }

        if (buf.Pointer)
                ACPI_FREE(buf.Pointer);
        return (AE_OK);
}

/*
 * vald_acpi_libright_get:
 *
 *      Search node that have "_BCL" Method.
 */
static void
vald_acpi_libright_get(struct vald_acpi_softc *sc)
{
        ACPI_HANDLE parent;
        ACPI_STATUS rv;

        aprint_verbose_dev(sc->sc_dev, "get LCD brightness via _BCL\n");

#ifdef ACPI_DEBUG
        printf("acpi_libright_get: start\n");
#endif
        rv = AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &parent);
        if (ACPI_FAILURE(rv))
                return;

        AcpiWalkNamespace(ACPI_TYPE_DEVICE, parent, 100,
            vald_acpi_libright_get_bus, NULL, sc, NULL);
}

/*
 * vald_acpi_libright_set:
 *
 *      Figure up next status and set it.
 */
static void
vald_acpi_libright_set(struct vald_acpi_softc *sc, int UpDown)
{
        uint32_t backlight, backlight_new, result, bright;
        ACPI_STATUS rv;
        int *pi;

        /* Skip,if it does not support _BCL. */
        if (sc->lcd_handle == NULL)
                return;

        /* Get LCD backlight status. */
        rv = vald_acpi_ghci_get(sc, GHCI_BACKLIGHT, &backlight, &result);
        if (ACPI_FAILURE(rv) || result != 0)
                return;

        /* Figure up next status. */
        backlight_new = backlight;
        if (UpDown == LIBRIGHT_UP) {
                if (backlight == 1)
                        sc->lcd_index++;
                else {
                        /* backlight on */
                        backlight_new = 1;
                        sc->lcd_index = 2;
                }
        } else if (UpDown == LIBRIGHT_DOWN) {
                if ((backlight == 1) && (sc->lcd_index > 2))
                        sc->lcd_index--;
                else {
                        /* backlight off */
                        backlight_new = 0;
                        sc->lcd_index = 2;
                }
        }

        /* Check index value. */
        if (sc->lcd_index < 2)
                sc->lcd_index = 2; /* index Minimum Value */
        if (sc->lcd_index >= sc->lcd_num)
                sc->lcd_index = sc->lcd_num - 1;

        /* Set LCD backlight,if status is changed. */
        if (backlight_new != backlight) {
                rv = vald_acpi_ghci_set(sc, GHCI_BACKLIGHT, backlight_new,
                    &result);
                if (ACPI_SUCCESS(rv) && result != 0)
                        aprint_error_dev(sc->sc_dev,
                            "can't set LCD backlight %s error=%x\n",
                            ((backlight_new == 1) ? "on" : "off"), result);
        }

        if (backlight_new == 1) {

                pi = sc->lcd_level;
                bright = *(pi + sc->lcd_index);

                rv = vald_acpi_bcm_set(sc->lcd_handle, bright);
                if (ACPI_FAILURE(rv))
                        aprint_error_dev(sc->sc_dev,
                            "unable to evaluate _BCM: %s\n",
                            AcpiFormatException(rv));
        } else {
                bright = 0;
        }
#ifdef ACPI_DEBUG
        printf("LCD bright");
        printf(" %s", ((UpDown == LIBRIGHT_UP) ? "up":""));
        printf("%s\n", ((UpDown == LIBRIGHT_DOWN) ? "down":""));
        printf("\t acpi_libright_set: Set brightness to %d%%\n", bright);
#endif
}

/*
 * vald_acpi_video_switch:
 *
 *      Get video status(LCD/CRT) and set new video status.
 */
static void
vald_acpi_video_switch(struct vald_acpi_softc *sc)
{
        ACPI_STATUS     rv;
        uint32_t        value, result;

        /* Get video status. */
        rv = vald_acpi_ghci_get(sc, GHCI_DISPLAY_DEVICE, &value, &result);
        if (ACPI_FAILURE(rv))
                return;
        if (result != 0) {
                aprint_error_dev(sc->sc_dev,
                    "can't get video status  error=%x\n", result);
                return;
        }

#ifdef ACPI_DEBUG
        printf("Toggle LCD/CRT\n");
        printf("\t Before switch, video status:   %s",
            (((value & GHCI_LCD) == GHCI_LCD) ? "LCD" : ""));
        printf("%s\n", (((value & GHCI_CRT) == GHCI_CRT) ? "CRT": ""));
#endif

        /* Toggle LCD/CRT */
        if (value & GHCI_LCD) {
                value &= ~GHCI_LCD;
                value |= GHCI_CRT;
        } else if (value & GHCI_CRT){
                value &= ~GHCI_CRT;
                value |= GHCI_LCD;
        }

        rv = vald_acpi_dssx_set(value);
        if (ACPI_FAILURE(rv))
                aprint_error_dev(sc->sc_dev, "unable to evaluate DSSX: %s\n",
                    AcpiFormatException(rv));

}

/*
 * vald_acpi_bcm_set:
 *
 *      Set LCD brightness via "_BCM" Method.
 */
static ACPI_STATUS
vald_acpi_bcm_set(ACPI_HANDLE handle, uint32_t bright)
{
        ACPI_STATUS rv;
        ACPI_OBJECT Arg;
        ACPI_OBJECT_LIST ArgList;

        ArgList.Count = 1;
        ArgList.Pointer = &Arg;

        Arg.Type = ACPI_TYPE_INTEGER;
        Arg.Integer.Value = bright;

        rv = AcpiEvaluateObject(handle, "_BCM", &ArgList, NULL);
        return (rv);
}

/*
 * vald_acpi_dssx_set:
 *
 *      Set value via "\\_SB_.VALX.DSSX" Method.
 */
static ACPI_STATUS
vald_acpi_dssx_set(uint32_t value)
{
        return acpi_eval_set_integer(NULL, "\\_SB_.VALX.DSSX", value);
}

/*
 * vald_acpi_fan_switch:
 *
 *      Get FAN status and set new FAN status.
 */
static void
vald_acpi_fan_switch(struct vald_acpi_softc *sc)
{
        ACPI_STATUS rv;
        uint32_t value, result;

        /* Get FAN status */
        rv = vald_acpi_ghci_get(sc, GHCI_FAN, &value, &result);
        if (ACPI_FAILURE(rv))
                return;
        if (result != 0) {
                aprint_error_dev(sc->sc_dev, "can't get FAN status error=%d\n",
                    result);
                return;
        }

#ifdef ACPI_DEBUG
        printf("Toggle FAN on/off\n");
        printf("\t Before toggle, FAN status %s\n",
            (value == GHCI_OFF ? "off" : "on"));
#endif

        /* Toggle FAN on/off */
        if (value == GHCI_OFF)
                value = GHCI_ON;
        else
                value = GHCI_OFF;

        /* Set FAN new status. */
        rv = vald_acpi_ghci_set(sc, GHCI_FAN, value, &result);
        if (ACPI_FAILURE(rv))
                return;
        if (result != 0) {
                aprint_error_dev(sc->sc_dev, "can't set FAN status error=%d\n",
                    result);
                return;
        }

#ifdef ACPI_DEBUG
        printf("\t After toggle, FAN status %s\n",
            (value == GHCI_OFF ? "off" : "on"));
#endif
}