/*
 * Copyright 2013, Jérôme Duval, korli@users.berlios.de.
 * Copyright 2005, Nathan Whitehorn.
 *
 * Distributed under the terms of the MIT License.
 *
 * ACPI Button Driver, used to get info on power buttons, etc.
 */


#include <ACPI.h>

#include <fs/select_sync_pool.h>

#include <stdlib.h>
#include <string.h>


#define ACPI_BUTTON_MODULE_NAME "drivers/power/acpi_button/driver_v1"

#define ACPI_BUTTON_DEVICE_MODULE_NAME "drivers/power/acpi_button/device_v1"

#define ACPI_NOTIFY_BUTTON_SLEEP                0x80
#define ACPI_NOTIFY_BUTTON_WAKEUP               0x2

//#define TRACE_BUTTON
#ifdef TRACE_BUTTON
#       define TRACE(x...) dprintf("acpi_button: " x)
#else
#       define TRACE(x...)
#endif
#define ERROR(x...)     dprintf("acpi_button: " x)

static device_manager_info *sDeviceManager;
static struct acpi_module_info *sAcpi;


typedef struct acpi_ns_device_info {
        device_node *node;
        acpi_device_module_info *acpi;
        acpi_device acpi_cookie;
        uint32 type;
        bool fixed;
        uint8 last_status;
        select_sync_pool* select_pool;
} acpi_button_device_info;


static void
acpi_button_notify_handler(acpi_handle _device, uint32 value, void *context)
{
        acpi_button_device_info *device = (acpi_button_device_info *)context;
        if (value == ACPI_NOTIFY_BUTTON_SLEEP) {
                TRACE("sleep\n");
                device->last_status = 1;
                if (device->select_pool != NULL)
                        notify_select_event_pool(device->select_pool, B_SELECT_READ);
        } else if (value == ACPI_NOTIFY_BUTTON_WAKEUP) {
                TRACE("wakeup\n");
        } else {
                ERROR("unknown notification\n");
        }

}


static uint32
acpi_button_fixed_handler(void *context)
{
        acpi_button_device_info *device = (acpi_button_device_info *)context;
        TRACE("sleep\n");
        device->last_status = 1;
        if (device->select_pool != NULL)
                notify_select_event_pool(device->select_pool, B_SELECT_READ);
        return B_OK;
}


//      #pragma mark - device module API


static status_t
acpi_button_init_device(void *_cookie, void **cookie)
{
        device_node *node = (device_node *)_cookie;
        acpi_button_device_info *device;
        device_node *parent;

        device = (acpi_button_device_info *)calloc(1, sizeof(*device));
        if (device == NULL)
                return B_NO_MEMORY;

        device->node = node;

        parent = sDeviceManager->get_parent_node(node);
        sDeviceManager->get_driver(parent, (driver_module_info **)&device->acpi,
                (void **)&device->acpi_cookie);

        const char *hid;
        if (sDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &hid,
                false) != B_OK) {
                sDeviceManager->put_node(parent);
                return B_ERROR;
        }

        sDeviceManager->put_node(parent);

        device->fixed = strcmp(hid, "PNP0C0C") != 0 && strcmp(hid, "PNP0C0E") != 0;
        TRACE("Device found, hid: %s, fixed: %d\n", hid, device->fixed);
        if (strcmp(hid, "PNP0C0C") == 0 || strcmp(hid, "ACPI_FPB") == 0)
                device->type = ACPI_EVENT_POWER_BUTTON;
        else if (strcmp(hid, "PNP0C0E") == 0 || strcmp(hid, "ACPI_FSB") == 0)
                device->type = ACPI_EVENT_SLEEP_BUTTON;
        else
                return B_ERROR;
        device->last_status = 0;
        device->select_pool = NULL;

        if (device->fixed) {
                sAcpi->reset_fixed_event(device->type);
                TRACE("Installing fixed handler for type %" B_PRIu32 "\n",
                        device->type);
                if (sAcpi->install_fixed_event_handler(device->type,
                        acpi_button_fixed_handler, device) != B_OK) {
                        ERROR("can't install fixed handler\n");
                }
        } else {
                TRACE("Installing notify handler for type %" B_PRIu32 "\n",
                        device->type);
                if (device->acpi->install_notify_handler(device->acpi_cookie,
                        ACPI_DEVICE_NOTIFY, acpi_button_notify_handler, device) != B_OK) {
                        ERROR("can't install notify handler\n");
                }
        }


        *cookie = device;
        return B_OK;
}


static void
acpi_button_uninit_device(void *_cookie)
{
        acpi_button_device_info *device = (acpi_button_device_info *)_cookie;
        if (device->fixed) {
                sAcpi->remove_fixed_event_handler(device->type,
                        acpi_button_fixed_handler);
        } else {
                device->acpi->remove_notify_handler(device->acpi_cookie,
                        ACPI_DEVICE_NOTIFY, acpi_button_notify_handler);
        }
        free(device);
}


static status_t
acpi_button_open(void *_cookie, const char *path, int flags, void** cookie)
{
        acpi_button_device_info *device = (acpi_button_device_info *)_cookie;

        if (device->fixed)
                sAcpi->enable_fixed_event(device->type);

        *cookie = device;
        return B_OK;
}


static status_t
acpi_button_read(void* _cookie, off_t position, void *buffer, size_t* num_bytes)
{
        acpi_button_device_info* device = (acpi_button_device_info*)_cookie;
        if (*num_bytes < sizeof(uint8))
                return B_IO_ERROR;

        if (user_memcpy(buffer, &device->last_status, sizeof(uint8)) < B_OK)
                return B_BAD_ADDRESS;
        device->last_status = 0;

        *num_bytes = 1;
        return B_OK;
}


static status_t
acpi_button_write(void* cookie, off_t position, const void* buffer,
        size_t* num_bytes)
{
        return B_ERROR;
}


static status_t
acpi_button_control(void* _cookie, uint32 op, void* arg, size_t len)
{
        return B_ERROR;
}


static status_t
acpi_button_select(void *_cookie, uint8 event, selectsync *sync)
{
        acpi_button_device_info* device = (acpi_button_device_info*)_cookie;

        if (event != B_SELECT_READ)
                return B_BAD_VALUE;

        // add the event to the pool
        status_t error = add_select_sync_pool_entry(&device->select_pool, sync,
                event);
        if (error != B_OK) {
                ERROR("add_select_sync_pool_entry() failed: %" B_PRIx32 "\n", error);
                return error;
        }

        if (device->last_status != 0)
                notify_select_event(sync, event);

        return B_OK;
}


static status_t
acpi_button_deselect(void *_cookie, uint8 event, selectsync *sync)
{
        acpi_button_device_info* device = (acpi_button_device_info*)_cookie;

        if (event != B_SELECT_READ)
                return B_BAD_VALUE;

        return remove_select_sync_pool_entry(&device->select_pool, sync, event);
}


static status_t
acpi_button_close (void* cookie)
{
        return B_OK;
}


static status_t
acpi_button_free (void* cookie)
{
        return B_OK;
}


//      #pragma mark - driver module API


static float
acpi_button_support(device_node *parent)
{
        const char *bus;
        uint32 device_type;
        const char *hid;

        // make sure parent is really the ACPI bus manager
        if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
                return -1;

        if (strcmp(bus, "acpi"))
                return 0.0;

        // check whether it's really a device
        if (sDeviceManager->get_attr_uint32(parent, ACPI_DEVICE_TYPE_ITEM,
                &device_type, false) != B_OK || device_type != ACPI_TYPE_DEVICE) {
                return 0.0;
        }

        // check whether it's a button device
        if (sDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &hid,
                false) != B_OK || (strcmp(hid, "PNP0C0C") != 0
                        && strcmp(hid, "ACPI_FPB") != 0 && strcmp(hid, "PNP0C0E") != 0
                        && strcmp(hid, "ACPI_FSB") != 0)) {
                return 0.0;
        }

        TRACE("acpi_button_support button device found: %s\n", hid);

        return 0.6;
}


static status_t
acpi_button_register_device(device_node *node)
{
        device_attr attrs[] = {
                { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI Button" }},
                { NULL }
        };

        return sDeviceManager->register_node(node, ACPI_BUTTON_MODULE_NAME, attrs,
                NULL, NULL);
}


static status_t
acpi_button_init_driver(device_node *node, void **_driverCookie)
{
        *_driverCookie = node;
        return B_OK;
}


static void
acpi_button_uninit_driver(void *driverCookie)
{
}


static status_t
acpi_button_register_child_devices(void *_cookie)
{
        device_node *node = (device_node*)_cookie;
        device_node *parent = sDeviceManager->get_parent_node(node);
        const char *hid;
        if (sDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &hid,
                false) != B_OK) {
                sDeviceManager->put_node(parent);
                return B_ERROR;
        }

        sDeviceManager->put_node(parent);

        status_t status = B_ERROR;
        if (strcmp(hid, "PNP0C0C") == 0) {
                status = sDeviceManager->publish_device(node,
                        "power/button/power", ACPI_BUTTON_DEVICE_MODULE_NAME);
        } else if (strcmp(hid, "ACPI_FPB") == 0) {
                status = sDeviceManager->publish_device(node,
                        "power/button/power_fixed", ACPI_BUTTON_DEVICE_MODULE_NAME);
        } else if (strcmp(hid, "PNP0C0E") == 0) {
                status = sDeviceManager->publish_device(node, "power/button/sleep",
                        ACPI_BUTTON_DEVICE_MODULE_NAME);
        } else if ( strcmp(hid, "ACPI_FSB") == 0) {
                status = sDeviceManager->publish_device(node,
                        "power/button/sleep_fixed", ACPI_BUTTON_DEVICE_MODULE_NAME);
        }

        return status;
}


module_dependency module_dependencies[] = {
        { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&sDeviceManager },
        { B_ACPI_MODULE_NAME, (module_info **)&sAcpi },
        {}
};


driver_module_info acpi_button_driver_module = {
        {
                ACPI_BUTTON_MODULE_NAME,
                0,
                NULL
        },

        acpi_button_support,
        acpi_button_register_device,
        acpi_button_init_driver,
        acpi_button_uninit_driver,
        acpi_button_register_child_devices,
        NULL,   // rescan
        NULL,   // removed
};


struct device_module_info acpi_button_device_module = {
        {
                ACPI_BUTTON_DEVICE_MODULE_NAME,
                0,
                NULL
        },

        acpi_button_init_device,
        acpi_button_uninit_device,
        NULL,

        acpi_button_open,
        acpi_button_close,
        acpi_button_free,
        acpi_button_read,
        acpi_button_write,
        NULL,
        acpi_button_control,
        acpi_button_select,
        acpi_button_deselect
};

module_info *modules[] = {
        (module_info *)&acpi_button_driver_module,
        (module_info *)&acpi_button_device_module,
        NULL
};