/*
 * Copyright 2005-2008, Haiku Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License
 */
#ifndef _ACPI_H
#define _ACPI_H


#include <device_manager.h>
#include <KernelExport.h>


typedef struct acpi_module_info acpi_module_info;
typedef union acpi_object_type acpi_object_type;

#define B_ACPI_MODULE_NAME "bus_managers/acpi/v1"

typedef phys_addr_t acpi_physical_address;
typedef phys_addr_t acpi_io_address;
typedef size_t acpi_size;

/* Actually a ptr to a NS Node */
typedef void *                          acpi_handle;

#ifndef __ACTYPES_H__

/* Notify types */

#define ACPI_SYSTEM_NOTIFY                              0x1
#define ACPI_DEVICE_NOTIFY                              0x2
#define ACPI_ALL_NOTIFY                                 (ACPI_SYSTEM_NOTIFY | ACPI_DEVICE_NOTIFY)
#define ACPI_MAX_NOTIFY_HANDLER_TYPE    0x3

#define ACPI_MAX_SYS_NOTIFY                             0x7F

/* Address Space (Operation Region) Types */

enum {
        ACPI_ADR_SPACE_SYSTEM_MEMORY    = 0,
        ACPI_ADR_SPACE_SYSTEM_IO                = 1,
        ACPI_ADR_SPACE_PCI_CONFIG               = 2,
        ACPI_ADR_SPACE_EC                               = 3,
        ACPI_ADR_SPACE_SMBUS                    = 4,
        ACPI_ADR_SPACE_CMOS                     = 5,
        ACPI_ADR_SPACE_PCI_BAR_TARGET   = 6,
        ACPI_ADR_SPACE_IPMI                             = 7,
        ACPI_ADR_SPACE_DATA_TABLE               = 8,
        ACPI_ADR_SPACE_FIXED_HARDWARE   = 127
};

/* ACPI fixed event types */

enum {
        ACPI_EVENT_PMTIMER = 0,
        ACPI_EVENT_GLOBAL,
        ACPI_EVENT_POWER_BUTTON,
        ACPI_EVENT_SLEEP_BUTTON,
        ACPI_EVENT_RTC
};

/* ACPI Object Types */

enum {
        ACPI_TYPE_ANY = 0,
        ACPI_TYPE_INTEGER,
        ACPI_TYPE_STRING,
        ACPI_TYPE_BUFFER,
        ACPI_TYPE_PACKAGE,
        ACPI_TYPE_FIELD_UNIT,
        ACPI_TYPE_DEVICE,
        ACPI_TYPE_EVENT,
        ACPI_TYPE_METHOD,
        ACPI_TYPE_MUTEX,
        ACPI_TYPE_REGION,
        ACPI_TYPE_POWER,
        ACPI_TYPE_PROCESSOR,
        ACPI_TYPE_THERMAL,
        ACPI_TYPE_BUFFER_FIELD,
        ACPI_TYPE_DDB_HANDLE,
        ACPI_TYPE_DEBUG_OBJECT,
        ACPI_TYPE_LOCAL_REFERENCE = 0x14
};

/* ACPI control method arg type */

union acpi_object_type {
        uint32 object_type;
        struct {
                uint32 object_type;
                uint64 integer;
        } integer;
        struct {
                uint32 object_type;
                uint32 len;
                char *string; /* You have to allocate string space yourself */
        } string;
        struct {
                uint32 object_type;
                uint32 length;
                void *buffer;
        } buffer;
        struct {
                uint32 object_type;
                uint32 count;
                acpi_object_type *objects;
        } package;
        struct {
                uint32 object_type;
                uint32 actual_type;
                acpi_handle handle;
        } reference;
        struct {
                uint32 object_type;
                uint32 cpu_id;
                acpi_io_address pblk_address;
                uint32 pblk_length;
        } processor;
        struct {
                uint32 object_type;
                uint32 min_power_state;
                uint32 resource_order;
        } power_resource;
};


/*
 * List of objects, used as a parameter list for control method evaluation
 */
typedef struct acpi_objects {
        uint32                          count;
        acpi_object_type        *pointer;
} acpi_objects;


typedef struct acpi_data {
        acpi_size                       length;         /* Length in bytes of the buffer */
        void                            *pointer;       /* pointer to buffer */
} acpi_data;


enum {
        ACPI_ALLOCATE_BUFFER = (acpi_size)-1,
        ACPI_ALLOCATE_LOCAL_BUFFER = (acpi_size)-2,
};


/*
 * acpi_status should return ACPI specific error codes, not BeOS ones.
 */
typedef uint32 acpi_status;

typedef struct acpi_resource acpi_resource;

#define ACPI_REENABLE_GPE       0x80


#endif  // __ACTYPES_H__


typedef uint32 (*acpi_event_handler)(void *context);
typedef uint32 (*acpi_gpe_handler) (acpi_handle GpeDevice, uint32 GpeNumber,
        void *context);

typedef acpi_status (*acpi_adr_space_handler)(uint32 function,
        acpi_physical_address address, uint32 bitWidth, int *value,
        void *handlerContext, void *regionContext);

typedef acpi_status (*acpi_adr_space_setup)(acpi_handle regionHandle,
        uint32 function, void *handlerContext, void **regionContext);

typedef void (*acpi_notify_handler)(acpi_handle device, uint32 value,
        void *context);

typedef acpi_status (*acpi_walk_resources_callback)(acpi_resource* resource,
        void* context);

typedef acpi_status (*acpi_walk_callback) (acpi_handle object, uint32 nestingLevel,
        void *context, void** returnValue);


struct acpi_module_info {
        module_info info;

        status_t        (*get_handle)(acpi_handle parent, const char *pathname,
                                        acpi_handle *retHandle);
        status_t        (*get_name)(acpi_handle handle, uint32 nameType,
                                        char* returnedName, size_t bufferLength);

        /* Global Lock */

        status_t        (*acquire_global_lock)(uint16 timeout, uint32 *handle);
        status_t        (*release_global_lock)(uint32 handle);

        /* Notify Handler */

        status_t        (*install_notify_handler)(acpi_handle device,
                                        uint32 handlerType, acpi_notify_handler handler,
                                        void *context);
        status_t        (*remove_notify_handler)(acpi_handle device,
                                        uint32 handlerType, acpi_notify_handler handler);

        /* GPE Handler */

        status_t        (*update_all_gpes)();
        status_t        (*enable_gpe)(acpi_handle handle, uint32 gpeNumber);
        status_t        (*disable_gpe)(acpi_handle handle, uint32 gpeNumber);
        status_t        (*clear_gpe)(acpi_handle handle, uint32 gpeNumber);
        status_t        (*set_gpe)(acpi_handle handle, uint32 gpeNumber,
                                        uint8 action);
        status_t        (*finish_gpe)(acpi_handle handle, uint32 gpeNumber);
        status_t        (*install_gpe_handler)(acpi_handle handle, uint32 gpeNumber,
                                        uint32 type, acpi_gpe_handler handler, void *data);
        status_t        (*remove_gpe_handler)(acpi_handle handle, uint32 gpeNumber,
                                        acpi_gpe_handler address);

        /* Address Space Handler */

        status_t        (*install_address_space_handler)(acpi_handle handle,
                                        uint32 spaceId,
                                        acpi_adr_space_handler handler,
                                        acpi_adr_space_setup setup,     void *data);
        status_t        (*remove_address_space_handler)(acpi_handle handle,
                                        uint32 spaceId,
                                        acpi_adr_space_handler handler);

        /* Fixed Event Management */

        void            (*enable_fixed_event)(uint32 event);
        void            (*disable_fixed_event)(uint32 event);

        uint32          (*fixed_event_status) (uint32 event);
                                        /* Returns 1 if event set, 0 otherwise */
        void            (*reset_fixed_event) (uint32 event);

        status_t        (*install_fixed_event_handler)(uint32 event,
                                        acpi_event_handler handler, void *data);
        status_t        (*remove_fixed_event_handler)(uint32 event,
                                        acpi_event_handler handler);

        /* Namespace Access */

        status_t        (*get_next_entry)(uint32 objectType, const char *base,
                                        char *result, size_t length, void **_counter);
        status_t        (*get_next_object)(uint32 objectType, acpi_handle parent,
                                        acpi_handle* currentChild);
        status_t        (*walk_namespace)(acpi_handle busDeviceHandle,
                                        uint32 objectType, uint32 maxDepth,
                                        acpi_walk_callback descendingCallback,
                                        acpi_walk_callback ascendingCallback, void* context,
                                        void** returnValue);

        status_t        (*get_device)(const char *hid, uint32 index, char *result,
                                        size_t resultLength);

        status_t        (*get_device_info)(const char *path, char** hid,
                                        char** cidList, size_t cidListLength, char** uid, char** cls);
        uint32          (*get_object_type)(const char *path);
        status_t        (*get_object)(const char *path,
                                        acpi_object_type **_returnValue);
        status_t        (*get_object_typed)(const char *path,
                                        acpi_object_type **_returnValue, uint32 objectType);
        status_t        (*ns_handle_to_pathname)(acpi_handle targetHandle,
                                        acpi_data *buffer);

        /* Control method execution and data acquisition */

        status_t        (*evaluate_object)(acpi_handle handle, const char* object,
                                        acpi_objects *args, acpi_object_type *returnValue, size_t bufferLength);
        status_t        (*evaluate_method)(acpi_handle handle, const char *method,
                                        acpi_objects *args, acpi_data *returnValue);

        /* Resource Management */

        status_t        (*get_irq_routing_table)(acpi_handle busDeviceHandle,
                                        acpi_data *retBuffer);
        status_t        (*get_current_resources)(acpi_handle busDeviceHandle,
                                        acpi_data *retBuffer);
        status_t        (*get_possible_resources)(acpi_handle busDeviceHandle,
                                        acpi_data *retBuffer);
        status_t        (*set_current_resources)(acpi_handle busDeviceHandle,
                                        acpi_data *buffer);
        status_t        (*walk_resources)(acpi_handle busDeviceHandle,
                                        char *method, acpi_walk_resources_callback callback,
                                        void* context);

        /* Power state setting */

        status_t        (*prepare_sleep_state)(uint8 state, void (*wakeFunc)(void),
                                        size_t size);
        status_t        (*enter_sleep_state)(uint8 state);
        status_t        (*reboot)(void);

        /* Table Access */
        status_t        (*get_table)(const char *signature, uint32 instance,
                                        void **tableHeader);

        /* Register Access */
        status_t        (*read_bit_register)(uint32 regid, uint32 *val);
        status_t        (*write_bit_register)(uint32 regid, uint32 val);
};


/* Sleep states */

enum {
        ACPI_POWER_STATE_ON = 0,
        ACPI_POWER_STATE_SLEEP_S1,
        ACPI_POWER_STATE_SLEEP_S2,
        ACPI_POWER_STATE_SLEEP_S3,
        ACPI_POWER_STATE_HIBERNATE,
        ACPI_POWER_STATE_OFF
};


#define ACPI_DEVICE_ADDR_ITEM   "acpi/addr"
#define ACPI_DEVICE_CID_ITEM    "acpi/cid"
#define ACPI_DEVICE_HANDLE_ITEM "acpi/handle"
#define ACPI_DEVICE_HID_ITEM    "acpi/hid"
#define ACPI_DEVICE_PATH_ITEM   "acpi/path"
#define ACPI_DEVICE_TYPE_ITEM   "acpi/type"
#define ACPI_DEVICE_UID_ITEM    "acpi/uid"


typedef struct acpi_device_cookie *acpi_device;

//      Interface to one ACPI device.
typedef struct acpi_device_module_info {
        driver_module_info info;

        /* Notify Handler */

        status_t        (*install_notify_handler)(acpi_device device,
                                        uint32 handlerType, acpi_notify_handler handler,
                                        void *context);
        status_t        (*remove_notify_handler)(acpi_device device,
                                        uint32 handlerType, acpi_notify_handler handler);

        /* Address Space Handler */
        status_t        (*install_address_space_handler)(acpi_device device,
                                        uint32 spaceId,
                                        acpi_adr_space_handler handler,
                                        acpi_adr_space_setup setup,     void *data);
        status_t        (*remove_address_space_handler)(acpi_device device,
                                        uint32 spaceId,
                                        acpi_adr_space_handler handler);

        /* Namespace Access */
        uint32          (*get_object_type)(acpi_device device);
        status_t        (*get_object)(acpi_device device, const char *path,
                                        acpi_object_type **_returnValue);
        status_t        (*walk_namespace)(acpi_device device,
                                        uint32 objectType, uint32 maxDepth,
                                        acpi_walk_callback descendingCallback,
                                        acpi_walk_callback ascendingCallback,
                                        void* context, void** returnValue);

        /* Control method execution and data acquisition */
        status_t        (*evaluate_method)(acpi_device device, const char *method,
                                        acpi_objects *args, acpi_data *returnValue);

        /* Resource Management */
        status_t        (*walk_resources)(acpi_device device, char *method,
                                        acpi_walk_resources_callback callback, void* context);
} acpi_device_module_info;


#endif  /* _ACPI_H */