headers/os/drivers/ACPI.h

   1 /*
   2  * Copyright 2005-2008, Haiku Inc. All Rights Reserved.
   3  * Distributed under the terms of the MIT License
   4  */
   5 #ifndef _ACPI_H
   6 #define _ACPI_H
   7
   8
   9 #include <device_manager.h>
  10 #include <KernelExport.h>
  11
  12
  13 typedef struct acpi_module_info acpi_module_info;
  14 typedef union acpi_object_type acpi_object_type;
  15
  16 #define B_ACPI_MODULE_NAME "bus_managers/acpi/v1"
  17
  18 typedef phys_addr_t acpi_physical_address;
  19 typedef phys_addr_t acpi_io_address;
  20 typedef size_t acpi_size;
  21
  22 /* Actually a ptr to a NS Node */
  23 typedef void *                          acpi_handle;
  24
  25 #ifndef __ACTYPES_H__
  26
  27 /* Notify types */
  28
  29 #define ACPI_SYSTEM_NOTIFY                              0x1
  30 #define ACPI_DEVICE_NOTIFY                              0x2
  31 #define ACPI_ALL_NOTIFY                                 (ACPI_SYSTEM_NOTIFY | ACPI_DEVICE_NOTIFY)
  32 #define ACPI_MAX_NOTIFY_HANDLER_TYPE    0x3
  33
  34 #define ACPI_MAX_SYS_NOTIFY                             0x7F
  35
  36 /* Address Space (Operation Region) Types */
  37
  38 enum {
  39         ACPI_ADR_SPACE_SYSTEM_MEMORY    = 0,
  40         ACPI_ADR_SPACE_SYSTEM_IO                = 1,
  41         ACPI_ADR_SPACE_PCI_CONFIG               = 2,
  42         ACPI_ADR_SPACE_EC                               = 3,
  43         ACPI_ADR_SPACE_SMBUS                    = 4,
  44         ACPI_ADR_SPACE_CMOS                     = 5,
  45         ACPI_ADR_SPACE_PCI_BAR_TARGET   = 6,
  46         ACPI_ADR_SPACE_IPMI                             = 7,
  47         ACPI_ADR_SPACE_DATA_TABLE               = 8,
  48         ACPI_ADR_SPACE_FIXED_HARDWARE   = 127
  49 };
  50
  51 /* ACPI fixed event types */
  52
  53 enum {
  54         ACPI_EVENT_PMTIMER = 0,
  55         ACPI_EVENT_GLOBAL,
  56         ACPI_EVENT_POWER_BUTTON,
  57         ACPI_EVENT_SLEEP_BUTTON,
  58         ACPI_EVENT_RTC
  59 };
  60
  61 /* ACPI Object Types */
  62
  63 enum {
  64         ACPI_TYPE_ANY = 0,
  65         ACPI_TYPE_INTEGER,
  66         ACPI_TYPE_STRING,
  67         ACPI_TYPE_BUFFER,
  68         ACPI_TYPE_PACKAGE,
  69         ACPI_TYPE_FIELD_UNIT,
  70         ACPI_TYPE_DEVICE,
  71         ACPI_TYPE_EVENT,
  72         ACPI_TYPE_METHOD,
  73         ACPI_TYPE_MUTEX,
  74         ACPI_TYPE_REGION,
  75         ACPI_TYPE_POWER,
  76         ACPI_TYPE_PROCESSOR,
  77         ACPI_TYPE_THERMAL,
  78         ACPI_TYPE_BUFFER_FIELD,
  79         ACPI_TYPE_DDB_HANDLE,
  80         ACPI_TYPE_DEBUG_OBJECT,
  81         ACPI_TYPE_LOCAL_REFERENCE = 0x14
  82 };
  83
  84 /* ACPI control method arg type */
  85
  86 union acpi_object_type {
  87         uint32 object_type;
  88         struct {
  89                 uint32 object_type;
  90                 uint64 integer;
  91         } integer;
  92         struct {
  93                 uint32 object_type;
  94                 uint32 len;
  95                 char *string; /* You have to allocate string space yourself */
  96         } string;
  97         struct {
  98                 uint32 object_type;
  99                 uint32 length;
 100                 void *buffer;
 101         } buffer;
 102         struct {
 103                 uint32 object_type;
 104                 uint32 count;
 105                 acpi_object_type *objects;
 106         } package;
 107         struct {
 108                 uint32 object_type;
 109                 uint32 actual_type;
 110                 acpi_handle handle;
 111         } reference;
 112         struct {
 113                 uint32 object_type;
 114                 uint32 cpu_id;
 115                 acpi_io_address pblk_address;
 116                 uint32 pblk_length;
 117         } processor;
 118         struct {
 119                 uint32 object_type;
 120                 uint32 min_power_state;
 121                 uint32 resource_order;
 122         } power_resource;
 123 };
 124
 125
 126 /*
 127  * List of objects, used as a parameter list for control method evaluation
 128  */
 129 typedef struct acpi_objects {
 130         uint32                          count;
 131         acpi_object_type        *pointer;
 132 } acpi_objects;
 133
 134
 135 typedef struct acpi_data {
 136         acpi_size                       length;         /* Length in bytes of the buffer */
 137         void                            *pointer;       /* pointer to buffer */
 138 } acpi_data;
 139
 140
 141 enum {
 142         ACPI_ALLOCATE_BUFFER = -1,
 143         ACPI_ALLOCATE_LOCAL_BUFFER = -2,
 144 };
 145
 146
 147 /*
 148  * acpi_status should return ACPI specific error codes, not BeOS ones.
 149  */
 150 typedef uint32 acpi_status;
 151
 152 typedef struct acpi_resource acpi_resource;
 153
 154 #define ACPI_REENABLE_GPE       0x80
 155
 156
 157 #endif  // __ACTYPES_H__
 158
 159
 160 typedef uint32 (*acpi_event_handler)(void *context);
 161 typedef uint32 (*acpi_gpe_handler) (acpi_handle GpeDevice, uint32 GpeNumber,
 162         void *context);
 163
 164 typedef acpi_status (*acpi_adr_space_handler)(uint32 function,
 165         acpi_physical_address address, uint32 bitWidth, int *value,
 166         void *handlerContext, void *regionContext);
 167
 168 typedef acpi_status (*acpi_adr_space_setup)(acpi_handle regionHandle,
 169         uint32 function, void *handlerContext, void **regionContext);
 170
 171 typedef void (*acpi_notify_handler)(acpi_handle device, uint32 value,
 172         void *context);
 173
 174 typedef acpi_status (*acpi_walk_resources_callback)(acpi_resource* resource,
 175         void* context);
 176
 177
 178 struct acpi_module_info {
 179         module_info info;
 180
 181         status_t        (*get_handle)(acpi_handle parent, const char *pathname,
 182                                         acpi_handle *retHandle);
 183         status_t        (*get_name)(acpi_handle handle, uint32 nameType,
 184                                         char* returnedName, size_t bufferLength);
 185
 186         /* Global Lock */
 187
 188         status_t        (*acquire_global_lock)(uint16 timeout, uint32 *handle);
 189         status_t        (*release_global_lock)(uint32 handle);
 190
 191         /* Notify Handler */
 192
 193         status_t        (*install_notify_handler)(acpi_handle device,
 194                                         uint32 handlerType, acpi_notify_handler handler,
 195                                         void *context);
 196         status_t        (*remove_notify_handler)(acpi_handle device,
 197                                         uint32 handlerType, acpi_notify_handler handler);
 198
 199         /* GPE Handler */
 200
 201         status_t        (*update_all_gpes)();
 202         status_t        (*enable_gpe)(acpi_handle handle, uint32 gpeNumber);
 203         status_t        (*disable_gpe)(acpi_handle handle, uint32 gpeNumber);
 204         status_t        (*clear_gpe)(acpi_handle handle, uint32 gpeNumber);
 205         status_t        (*set_gpe)(acpi_handle handle, uint32 gpeNumber,
 206                                         uint8 action);
 207         status_t        (*finish_gpe)(acpi_handle handle, uint32 gpeNumber);
 208         status_t        (*install_gpe_handler)(acpi_handle handle, uint32 gpeNumber,
 209                                         uint32 type, acpi_gpe_handler handler, void *data);
 210         status_t        (*remove_gpe_handler)(acpi_handle handle, uint32 gpeNumber,
 211                                         acpi_gpe_handler address);
 212
 213         /* Address Space Handler */
 214
 215         status_t        (*install_address_space_handler)(acpi_handle handle,
 216                                         uint32 spaceId,
 217                                         acpi_adr_space_handler handler,
 218                                         acpi_adr_space_setup setup,     void *data);
 219         status_t        (*remove_address_space_handler)(acpi_handle handle,
 220                                         uint32 spaceId,
 221                                         acpi_adr_space_handler handler);
 222
 223         /* Fixed Event Management */
 224
 225         void            (*enable_fixed_event)(uint32 event);
 226         void            (*disable_fixed_event)(uint32 event);
 227
 228         uint32          (*fixed_event_status) (uint32 event);
 229                                         /* Returns 1 if event set, 0 otherwise */
 230         void            (*reset_fixed_event) (uint32 event);
 231
 232         status_t        (*install_fixed_event_handler)(uint32 event,
 233                                         acpi_event_handler handler, void *data);
 234         status_t        (*remove_fixed_event_handler)(uint32 event,
 235                                         acpi_event_handler handler);
 236
 237         /* Namespace Access */
 238
 239         status_t        (*get_next_entry)(uint32 objectType, const char *base,
 240                                         char *result, size_t length, void **_counter);
 241         status_t        (*get_next_object)(uint32 objectType, acpi_handle parent,
 242                                         acpi_handle* currentChild);
 243         status_t        (*get_device)(const char *hid, uint32 index, char *result,
 244                                         size_t resultLength);
 245
 246         status_t        (*get_device_hid)(const char *path, char *hid,
 247                                         size_t hidLength);
 248         uint32          (*get_object_type)(const char *path);
 249         status_t        (*get_object)(const char *path,
 250                                         acpi_object_type **_returnValue);
 251         status_t        (*get_object_typed)(const char *path,
 252                                         acpi_object_type **_returnValue, uint32 objectType);
 253         status_t        (*ns_handle_to_pathname)(acpi_handle targetHandle,
 254                                         acpi_data *buffer);
 255
 256         /* Control method execution and data acquisition */
 257
 258         status_t        (*evaluate_object)(acpi_handle handle, const char* object,
 259                                         acpi_objects *args, acpi_object_type *returnValue, size_t bufferLength);
 260         status_t        (*evaluate_method)(acpi_handle handle, const char *method,
 261                                         acpi_objects *args, acpi_data *returnValue);
 262
 263         /* Resource Management */
 264
 265         status_t        (*get_irq_routing_table)(acpi_handle busDeviceHandle,
 266                                         acpi_data *retBuffer);
 267         status_t        (*get_current_resources)(acpi_handle busDeviceHandle,
 268                                         acpi_data *retBuffer);
 269         status_t        (*get_possible_resources)(acpi_handle busDeviceHandle,
 270                                         acpi_data *retBuffer);
 271         status_t        (*set_current_resources)(acpi_handle busDeviceHandle,
 272                                         acpi_data *buffer);
 273         status_t        (*walk_resources)(acpi_handle busDeviceHandle,
 274                                         char *method, acpi_walk_resources_callback callback,
 275                                         void* context);
 276
 277         /* Power state setting */
 278
 279         status_t        (*prepare_sleep_state)(uint8 state, void (*wakeFunc)(void),
 280                                         size_t size);
 281         status_t        (*enter_sleep_state)(uint8 state);
 282         status_t        (*reboot)(void);
 283
 284         /* Table Access */
 285         status_t        (*get_table)(const char *signature, uint32 instance,
 286                                         void **tableHeader);
 287
 288         /* Register Access */
 289         status_t        (*read_bit_register)(uint32 regid, uint32 *val);
 290         status_t        (*write_bit_register)(uint32 regid, uint32 val);
 291 };
 292
 293
 294 /* Sleep states */
 295
 296 enum {
 297         ACPI_POWER_STATE_ON = 0,
 298         ACPI_POWER_STATE_SLEEP_S1,
 299         ACPI_POWER_STATE_SLEEP_S2,
 300         ACPI_POWER_STATE_SLEEP_S3,
 301         ACPI_POWER_STATE_HIBERNATE,
 302         ACPI_POWER_STATE_OFF
 303 };
 304
 305
 306 #define ACPI_DEVICE_HID_ITEM    "acpi/hid"
 307 #define ACPI_DEVICE_PATH_ITEM   "acpi/path"
 308 #define ACPI_DEVICE_TYPE_ITEM   "acpi/type"
 309
 310
 311 typedef struct acpi_device_cookie *acpi_device;
 312
 313 //      Interface to one ACPI device.
 314 typedef struct acpi_device_module_info {
 315         driver_module_info info;
 316
 317         /* Notify Handler */
 318
 319         status_t        (*install_notify_handler)(acpi_device device,
 320                                         uint32 handlerType, acpi_notify_handler handler,
 321                                         void *context);
 322         status_t        (*remove_notify_handler)(acpi_device device,
 323                                         uint32 handlerType, acpi_notify_handler handler);
 324
 325         /* Address Space Handler */
 326         status_t        (*install_address_space_handler)(acpi_device device,
 327                                         uint32 spaceId,
 328                                         acpi_adr_space_handler handler,
 329                                         acpi_adr_space_setup setup,     void *data);
 330         status_t        (*remove_address_space_handler)(acpi_device device,
 331                                         uint32 spaceId,
 332                                         acpi_adr_space_handler handler);
 333
 334         /* Namespace Access */
 335         uint32          (*get_object_type)(acpi_device device);
 336         status_t        (*get_object)(acpi_device device, const char *path,
 337                                         acpi_object_type **_returnValue);
 338
 339         /* Control method execution and data acquisition */
 340         status_t        (*evaluate_method)(acpi_device device, const char *method,
 341                                         acpi_objects *args, acpi_data *returnValue);
 342
 343         /* Resource Management */
 344         status_t        (*walk_resources)(acpi_device device, char *method,
 345                                         acpi_walk_resources_callback callback, void* context);
 346 } acpi_device_module_info;
 347
 348
 349 #endif  /* _ACPI_H */