1 /* 2 * acpi.h - ACPI Interface 3 * 4 * Copyright (C) 2001 Paul Diefenbaugh <[email protected]> 5 * 6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 */ 24 25 #ifndef _LINUX_ACPI_H 26 #define _LINUX_ACPI_H 27 28 #include <linux/errno.h> 29 #include <linux/ioport.h> /* for struct resource */ 30 #include <linux/resource_ext.h> 31 #include <linux/device.h> 32 #include <linux/property.h> 33 34 #ifndef _LINUX 35 #define _LINUX 36 #endif 37 #include <acpi/acpi.h> 38 39 #ifdef CONFIG_ACPI 40 41 #include <linux/list.h> 42 #include <linux/mod_devicetable.h> 43 #include <linux/dynamic_debug.h> 44 45 #include <acpi/acpi_bus.h> 46 #include <acpi/acpi_drivers.h> 47 #include <acpi/acpi_numa.h> 48 #include <acpi/acpi_io.h> 49 #include <asm/acpi.h> 50 51 static inline acpi_handle acpi_device_handle(struct acpi_device *adev) 52 { 53 return adev ? adev->handle : NULL; 54 } 55 56 #define ACPI_COMPANION(dev) ((dev)->acpi_node.companion) 57 #define ACPI_COMPANION_SET(dev, adev) ACPI_COMPANION(dev) = (adev) 58 #define ACPI_HANDLE(dev) acpi_device_handle(ACPI_COMPANION(dev)) 59 60 static inline void acpi_preset_companion(struct device *dev, 61 struct acpi_device *parent, u64 addr) 62 { 63 ACPI_COMPANION_SET(dev, acpi_find_child_device(parent, addr, NULL)); 64 } 65 66 static inline const char *acpi_dev_name(struct acpi_device *adev) 67 { 68 return dev_name(&adev->dev); 69 } 70 71 enum acpi_irq_model_id { 72 ACPI_IRQ_MODEL_PIC = 0, 73 ACPI_IRQ_MODEL_IOAPIC, 74 ACPI_IRQ_MODEL_IOSAPIC, 75 ACPI_IRQ_MODEL_PLATFORM, 76 ACPI_IRQ_MODEL_COUNT 77 }; 78 79 extern enum acpi_irq_model_id acpi_irq_model; 80 81 enum acpi_interrupt_id { 82 ACPI_INTERRUPT_PMI = 1, 83 ACPI_INTERRUPT_INIT, 84 ACPI_INTERRUPT_CPEI, 85 ACPI_INTERRUPT_COUNT 86 }; 87 88 #define ACPI_SPACE_MEM 0 89 90 enum acpi_address_range_id { 91 ACPI_ADDRESS_RANGE_MEMORY = 1, 92 ACPI_ADDRESS_RANGE_RESERVED = 2, 93 ACPI_ADDRESS_RANGE_ACPI = 3, 94 ACPI_ADDRESS_RANGE_NVS = 4, 95 ACPI_ADDRESS_RANGE_COUNT 96 }; 97 98 99 /* Table Handlers */ 100 101 typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table); 102 103 typedef int (*acpi_tbl_entry_handler)(struct acpi_subtable_header *header, 104 const unsigned long end); 105 106 #ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE 107 void acpi_initrd_override(void *data, size_t size); 108 #else 109 static inline void acpi_initrd_override(void *data, size_t size) 110 { 111 } 112 #endif 113 114 #define BAD_MADT_ENTRY(entry, end) ( \ 115 (!entry) || (unsigned long)entry + sizeof(*entry) > end || \ 116 ((struct acpi_subtable_header *)entry)->length < sizeof(*entry)) 117 118 char * __acpi_map_table (unsigned long phys_addr, unsigned long size); 119 void __acpi_unmap_table(char *map, unsigned long size); 120 int early_acpi_boot_init(void); 121 int acpi_boot_init (void); 122 void acpi_boot_table_init (void); 123 int acpi_mps_check (void); 124 int acpi_numa_init (void); 125 126 int acpi_table_init (void); 127 int acpi_table_parse(char *id, acpi_tbl_table_handler handler); 128 int __init acpi_parse_entries(char *id, unsigned long table_size, 129 acpi_tbl_entry_handler handler, 130 struct acpi_table_header *table_header, 131 int entry_id, unsigned int max_entries); 132 int __init acpi_table_parse_entries(char *id, unsigned long table_size, 133 int entry_id, 134 acpi_tbl_entry_handler handler, 135 unsigned int max_entries); 136 int acpi_table_parse_madt(enum acpi_madt_type id, 137 acpi_tbl_entry_handler handler, 138 unsigned int max_entries); 139 int acpi_parse_mcfg (struct acpi_table_header *header); 140 void acpi_table_print_madt_entry (struct acpi_subtable_header *madt); 141 142 /* the following four functions are architecture-dependent */ 143 void acpi_numa_slit_init (struct acpi_table_slit *slit); 144 void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa); 145 void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa); 146 int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma); 147 void acpi_numa_arch_fixup(void); 148 149 #ifdef CONFIG_ACPI_HOTPLUG_CPU 150 /* Arch dependent functions for cpu hotplug support */ 151 int acpi_map_cpu(acpi_handle handle, int physid, int *pcpu); 152 int acpi_unmap_cpu(int cpu); 153 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 154 155 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 156 int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr); 157 #endif 158 159 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base); 160 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base); 161 int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base); 162 void acpi_irq_stats_init(void); 163 extern u32 acpi_irq_handled; 164 extern u32 acpi_irq_not_handled; 165 166 extern int sbf_port; 167 extern unsigned long acpi_realmode_flags; 168 169 int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity); 170 int acpi_gsi_to_irq (u32 gsi, unsigned int *irq); 171 int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi); 172 173 #ifdef CONFIG_X86_IO_APIC 174 extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity); 175 #else 176 #define acpi_get_override_irq(gsi, trigger, polarity) (-1) 177 #endif 178 /* 179 * This function undoes the effect of one call to acpi_register_gsi(). 180 * If this matches the last registration, any IRQ resources for gsi 181 * are freed. 182 */ 183 void acpi_unregister_gsi (u32 gsi); 184 185 struct pci_dev; 186 187 int acpi_pci_irq_enable (struct pci_dev *dev); 188 void acpi_penalize_isa_irq(int irq, int active); 189 190 void acpi_pci_irq_disable (struct pci_dev *dev); 191 192 extern int ec_read(u8 addr, u8 *val); 193 extern int ec_write(u8 addr, u8 val); 194 extern int ec_transaction(u8 command, 195 const u8 *wdata, unsigned wdata_len, 196 u8 *rdata, unsigned rdata_len); 197 extern acpi_handle ec_get_handle(void); 198 199 extern bool acpi_is_pnp_device(struct acpi_device *); 200 201 #if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE) 202 203 typedef void (*wmi_notify_handler) (u32 value, void *context); 204 205 extern acpi_status wmi_evaluate_method(const char *guid, u8 instance, 206 u32 method_id, 207 const struct acpi_buffer *in, 208 struct acpi_buffer *out); 209 extern acpi_status wmi_query_block(const char *guid, u8 instance, 210 struct acpi_buffer *out); 211 extern acpi_status wmi_set_block(const char *guid, u8 instance, 212 const struct acpi_buffer *in); 213 extern acpi_status wmi_install_notify_handler(const char *guid, 214 wmi_notify_handler handler, void *data); 215 extern acpi_status wmi_remove_notify_handler(const char *guid); 216 extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out); 217 extern bool wmi_has_guid(const char *guid); 218 219 #endif /* CONFIG_ACPI_WMI */ 220 221 #define ACPI_VIDEO_OUTPUT_SWITCHING 0x0001 222 #define ACPI_VIDEO_DEVICE_POSTING 0x0002 223 #define ACPI_VIDEO_ROM_AVAILABLE 0x0004 224 #define ACPI_VIDEO_BACKLIGHT 0x0008 225 #define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR 0x0010 226 #define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO 0x0020 227 #define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR 0x0040 228 #define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO 0x0080 229 #define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR 0x0100 230 #define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO 0x0200 231 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR 0x0400 232 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO 0x0800 233 234 #if defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE) 235 236 extern long acpi_video_get_capabilities(acpi_handle graphics_dev_handle); 237 extern long acpi_is_video_device(acpi_handle handle); 238 extern void acpi_video_dmi_promote_vendor(void); 239 extern void acpi_video_dmi_demote_vendor(void); 240 extern int acpi_video_backlight_support(void); 241 extern int acpi_video_display_switch_support(void); 242 243 #else 244 245 static inline long acpi_video_get_capabilities(acpi_handle graphics_dev_handle) 246 { 247 return 0; 248 } 249 250 static inline long acpi_is_video_device(acpi_handle handle) 251 { 252 return 0; 253 } 254 255 static inline void acpi_video_dmi_promote_vendor(void) 256 { 257 } 258 259 static inline void acpi_video_dmi_demote_vendor(void) 260 { 261 } 262 263 static inline int acpi_video_backlight_support(void) 264 { 265 return 0; 266 } 267 268 static inline int acpi_video_display_switch_support(void) 269 { 270 return 0; 271 } 272 273 #endif /* defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE) */ 274 275 extern int acpi_blacklisted(void); 276 extern void acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d); 277 extern void acpi_osi_setup(char *str); 278 279 #ifdef CONFIG_ACPI_NUMA 280 int acpi_get_node(acpi_handle handle); 281 #else 282 static inline int acpi_get_node(acpi_handle handle) 283 { 284 return 0; 285 } 286 #endif 287 extern int acpi_paddr_to_node(u64 start_addr, u64 size); 288 289 extern int pnpacpi_disabled; 290 291 #define PXM_INVAL (-1) 292 293 bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res); 294 bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res); 295 bool acpi_dev_resource_address_space(struct acpi_resource *ares, 296 struct resource_win *win); 297 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares, 298 struct resource_win *win); 299 unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable); 300 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index, 301 struct resource *res); 302 303 void acpi_dev_free_resource_list(struct list_head *list); 304 int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list, 305 int (*preproc)(struct acpi_resource *, void *), 306 void *preproc_data); 307 int acpi_dev_filter_resource_type(struct acpi_resource *ares, 308 unsigned long types); 309 310 static inline int acpi_dev_filter_resource_type_cb(struct acpi_resource *ares, 311 void *arg) 312 { 313 return acpi_dev_filter_resource_type(ares, (unsigned long)arg); 314 } 315 316 int acpi_check_resource_conflict(const struct resource *res); 317 318 int acpi_check_region(resource_size_t start, resource_size_t n, 319 const char *name); 320 321 int acpi_resources_are_enforced(void); 322 323 #ifdef CONFIG_HIBERNATION 324 void __init acpi_no_s4_hw_signature(void); 325 #endif 326 327 #ifdef CONFIG_PM_SLEEP 328 void __init acpi_old_suspend_ordering(void); 329 void __init acpi_nvs_nosave(void); 330 void __init acpi_nvs_nosave_s3(void); 331 #endif /* CONFIG_PM_SLEEP */ 332 333 struct acpi_osc_context { 334 char *uuid_str; /* UUID string */ 335 int rev; 336 struct acpi_buffer cap; /* list of DWORD capabilities */ 337 struct acpi_buffer ret; /* free by caller if success */ 338 }; 339 340 acpi_status acpi_str_to_uuid(char *str, u8 *uuid); 341 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context); 342 343 /* Indexes into _OSC Capabilities Buffer (DWORDs 2 & 3 are device-specific) */ 344 #define OSC_QUERY_DWORD 0 /* DWORD 1 */ 345 #define OSC_SUPPORT_DWORD 1 /* DWORD 2 */ 346 #define OSC_CONTROL_DWORD 2 /* DWORD 3 */ 347 348 /* _OSC Capabilities DWORD 1: Query/Control and Error Returns (generic) */ 349 #define OSC_QUERY_ENABLE 0x00000001 /* input */ 350 #define OSC_REQUEST_ERROR 0x00000002 /* return */ 351 #define OSC_INVALID_UUID_ERROR 0x00000004 /* return */ 352 #define OSC_INVALID_REVISION_ERROR 0x00000008 /* return */ 353 #define OSC_CAPABILITIES_MASK_ERROR 0x00000010 /* return */ 354 355 /* Platform-Wide Capabilities _OSC: Capabilities DWORD 2: Support Field */ 356 #define OSC_SB_PAD_SUPPORT 0x00000001 357 #define OSC_SB_PPC_OST_SUPPORT 0x00000002 358 #define OSC_SB_PR3_SUPPORT 0x00000004 359 #define OSC_SB_HOTPLUG_OST_SUPPORT 0x00000008 360 #define OSC_SB_APEI_SUPPORT 0x00000010 361 #define OSC_SB_CPC_SUPPORT 0x00000020 362 363 extern bool osc_sb_apei_support_acked; 364 365 /* PCI Host Bridge _OSC: Capabilities DWORD 2: Support Field */ 366 #define OSC_PCI_EXT_CONFIG_SUPPORT 0x00000001 367 #define OSC_PCI_ASPM_SUPPORT 0x00000002 368 #define OSC_PCI_CLOCK_PM_SUPPORT 0x00000004 369 #define OSC_PCI_SEGMENT_GROUPS_SUPPORT 0x00000008 370 #define OSC_PCI_MSI_SUPPORT 0x00000010 371 #define OSC_PCI_SUPPORT_MASKS 0x0000001f 372 373 /* PCI Host Bridge _OSC: Capabilities DWORD 3: Control Field */ 374 #define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL 0x00000001 375 #define OSC_PCI_SHPC_NATIVE_HP_CONTROL 0x00000002 376 #define OSC_PCI_EXPRESS_PME_CONTROL 0x00000004 377 #define OSC_PCI_EXPRESS_AER_CONTROL 0x00000008 378 #define OSC_PCI_EXPRESS_CAPABILITY_CONTROL 0x00000010 379 #define OSC_PCI_CONTROL_MASKS 0x0000001f 380 381 #define ACPI_GSB_ACCESS_ATTRIB_QUICK 0x00000002 382 #define ACPI_GSB_ACCESS_ATTRIB_SEND_RCV 0x00000004 383 #define ACPI_GSB_ACCESS_ATTRIB_BYTE 0x00000006 384 #define ACPI_GSB_ACCESS_ATTRIB_WORD 0x00000008 385 #define ACPI_GSB_ACCESS_ATTRIB_BLOCK 0x0000000A 386 #define ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE 0x0000000B 387 #define ACPI_GSB_ACCESS_ATTRIB_WORD_CALL 0x0000000C 388 #define ACPI_GSB_ACCESS_ATTRIB_BLOCK_CALL 0x0000000D 389 #define ACPI_GSB_ACCESS_ATTRIB_RAW_BYTES 0x0000000E 390 #define ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS 0x0000000F 391 392 extern acpi_status acpi_pci_osc_control_set(acpi_handle handle, 393 u32 *mask, u32 req); 394 395 /* Enable _OST when all relevant hotplug operations are enabled */ 396 #if defined(CONFIG_ACPI_HOTPLUG_CPU) && \ 397 defined(CONFIG_ACPI_HOTPLUG_MEMORY) && \ 398 defined(CONFIG_ACPI_CONTAINER) 399 #define ACPI_HOTPLUG_OST 400 #endif 401 402 /* _OST Source Event Code (OSPM Action) */ 403 #define ACPI_OST_EC_OSPM_SHUTDOWN 0x100 404 #define ACPI_OST_EC_OSPM_EJECT 0x103 405 #define ACPI_OST_EC_OSPM_INSERTION 0x200 406 407 /* _OST General Processing Status Code */ 408 #define ACPI_OST_SC_SUCCESS 0x0 409 #define ACPI_OST_SC_NON_SPECIFIC_FAILURE 0x1 410 #define ACPI_OST_SC_UNRECOGNIZED_NOTIFY 0x2 411 412 /* _OST OS Shutdown Processing (0x100) Status Code */ 413 #define ACPI_OST_SC_OS_SHUTDOWN_DENIED 0x80 414 #define ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS 0x81 415 #define ACPI_OST_SC_OS_SHUTDOWN_COMPLETED 0x82 416 #define ACPI_OST_SC_OS_SHUTDOWN_NOT_SUPPORTED 0x83 417 418 /* _OST Ejection Request (0x3, 0x103) Status Code */ 419 #define ACPI_OST_SC_EJECT_NOT_SUPPORTED 0x80 420 #define ACPI_OST_SC_DEVICE_IN_USE 0x81 421 #define ACPI_OST_SC_DEVICE_BUSY 0x82 422 #define ACPI_OST_SC_EJECT_DEPENDENCY_BUSY 0x83 423 #define ACPI_OST_SC_EJECT_IN_PROGRESS 0x84 424 425 /* _OST Insertion Request (0x200) Status Code */ 426 #define ACPI_OST_SC_INSERT_IN_PROGRESS 0x80 427 #define ACPI_OST_SC_DRIVER_LOAD_FAILURE 0x81 428 #define ACPI_OST_SC_INSERT_NOT_SUPPORTED 0x82 429 430 extern void acpi_early_init(void); 431 432 extern int acpi_nvs_register(__u64 start, __u64 size); 433 434 extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *), 435 void *data); 436 437 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids, 438 const struct device *dev); 439 440 extern bool acpi_driver_match_device(struct device *dev, 441 const struct device_driver *drv); 442 int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *); 443 int acpi_device_modalias(struct device *, char *, int); 444 void acpi_walk_dep_device_list(acpi_handle handle); 445 446 struct platform_device *acpi_create_platform_device(struct acpi_device *); 447 #define ACPI_PTR(_ptr) (_ptr) 448 449 #else /* !CONFIG_ACPI */ 450 451 #define acpi_disabled 1 452 453 #define ACPI_COMPANION(dev) (NULL) 454 #define ACPI_COMPANION_SET(dev, adev) do { } while (0) 455 #define ACPI_HANDLE(dev) (NULL) 456 457 struct fwnode_handle; 458 459 static inline bool is_acpi_node(struct fwnode_handle *fwnode) 460 { 461 return false; 462 } 463 464 static inline struct acpi_device *acpi_node(struct fwnode_handle *fwnode) 465 { 466 return NULL; 467 } 468 469 static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev) 470 { 471 return NULL; 472 } 473 474 static inline const char *acpi_dev_name(struct acpi_device *adev) 475 { 476 return NULL; 477 } 478 479 static inline void acpi_early_init(void) { } 480 481 static inline int early_acpi_boot_init(void) 482 { 483 return 0; 484 } 485 static inline int acpi_boot_init(void) 486 { 487 return 0; 488 } 489 490 static inline void acpi_boot_table_init(void) 491 { 492 return; 493 } 494 495 static inline int acpi_mps_check(void) 496 { 497 return 0; 498 } 499 500 static inline int acpi_check_resource_conflict(struct resource *res) 501 { 502 return 0; 503 } 504 505 static inline int acpi_check_region(resource_size_t start, resource_size_t n, 506 const char *name) 507 { 508 return 0; 509 } 510 511 struct acpi_table_header; 512 static inline int acpi_table_parse(char *id, 513 int (*handler)(struct acpi_table_header *)) 514 { 515 return -ENODEV; 516 } 517 518 static inline int acpi_nvs_register(__u64 start, __u64 size) 519 { 520 return 0; 521 } 522 523 static inline int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *), 524 void *data) 525 { 526 return 0; 527 } 528 529 struct acpi_device_id; 530 531 static inline const struct acpi_device_id *acpi_match_device( 532 const struct acpi_device_id *ids, const struct device *dev) 533 { 534 return NULL; 535 } 536 537 static inline bool acpi_driver_match_device(struct device *dev, 538 const struct device_driver *drv) 539 { 540 return false; 541 } 542 543 static inline int acpi_device_uevent_modalias(struct device *dev, 544 struct kobj_uevent_env *env) 545 { 546 return -ENODEV; 547 } 548 549 static inline int acpi_device_modalias(struct device *dev, 550 char *buf, int size) 551 { 552 return -ENODEV; 553 } 554 555 #define ACPI_PTR(_ptr) (NULL) 556 557 #endif /* !CONFIG_ACPI */ 558 559 #ifdef CONFIG_ACPI 560 void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state, 561 u32 pm1a_ctrl, u32 pm1b_ctrl)); 562 563 acpi_status acpi_os_prepare_sleep(u8 sleep_state, 564 u32 pm1a_control, u32 pm1b_control); 565 566 void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state, 567 u32 val_a, u32 val_b)); 568 569 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, 570 u32 val_a, u32 val_b); 571 572 #ifdef CONFIG_X86 573 void arch_reserve_mem_area(acpi_physical_address addr, size_t size); 574 #else 575 static inline void arch_reserve_mem_area(acpi_physical_address addr, 576 size_t size) 577 { 578 } 579 #endif /* CONFIG_X86 */ 580 #else 581 #define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0) 582 #endif 583 584 #if defined(CONFIG_ACPI) && defined(CONFIG_PM) 585 int acpi_dev_runtime_suspend(struct device *dev); 586 int acpi_dev_runtime_resume(struct device *dev); 587 int acpi_subsys_runtime_suspend(struct device *dev); 588 int acpi_subsys_runtime_resume(struct device *dev); 589 struct acpi_device *acpi_dev_pm_get_node(struct device *dev); 590 int acpi_dev_pm_attach(struct device *dev, bool power_on); 591 #else 592 static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; } 593 static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; } 594 static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; } 595 static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; } 596 static inline struct acpi_device *acpi_dev_pm_get_node(struct device *dev) 597 { 598 return NULL; 599 } 600 static inline int acpi_dev_pm_attach(struct device *dev, bool power_on) 601 { 602 return -ENODEV; 603 } 604 #endif 605 606 #if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP) 607 int acpi_dev_suspend_late(struct device *dev); 608 int acpi_dev_resume_early(struct device *dev); 609 int acpi_subsys_prepare(struct device *dev); 610 void acpi_subsys_complete(struct device *dev); 611 int acpi_subsys_suspend_late(struct device *dev); 612 int acpi_subsys_resume_early(struct device *dev); 613 int acpi_subsys_suspend(struct device *dev); 614 int acpi_subsys_freeze(struct device *dev); 615 #else 616 static inline int acpi_dev_suspend_late(struct device *dev) { return 0; } 617 static inline int acpi_dev_resume_early(struct device *dev) { return 0; } 618 static inline int acpi_subsys_prepare(struct device *dev) { return 0; } 619 static inline void acpi_subsys_complete(struct device *dev) {} 620 static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; } 621 static inline int acpi_subsys_resume_early(struct device *dev) { return 0; } 622 static inline int acpi_subsys_suspend(struct device *dev) { return 0; } 623 static inline int acpi_subsys_freeze(struct device *dev) { return 0; } 624 #endif 625 626 #ifdef CONFIG_ACPI 627 __printf(3, 4) 628 void acpi_handle_printk(const char *level, acpi_handle handle, 629 const char *fmt, ...); 630 #else /* !CONFIG_ACPI */ 631 static inline __printf(3, 4) void 632 acpi_handle_printk(const char *level, void *handle, const char *fmt, ...) {} 633 #endif /* !CONFIG_ACPI */ 634 635 #if defined(CONFIG_ACPI) && defined(CONFIG_DYNAMIC_DEBUG) 636 __printf(3, 4) 637 void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...); 638 #else 639 #define __acpi_handle_debug(descriptor, handle, fmt, ...) \ 640 acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__); 641 #endif 642 643 /* 644 * acpi_handle_<level>: Print message with ACPI prefix and object path 645 * 646 * These interfaces acquire the global namespace mutex to obtain an object 647 * path. In interrupt context, it shows the object path as <n/a>. 648 */ 649 #define acpi_handle_emerg(handle, fmt, ...) \ 650 acpi_handle_printk(KERN_EMERG, handle, fmt, ##__VA_ARGS__) 651 #define acpi_handle_alert(handle, fmt, ...) \ 652 acpi_handle_printk(KERN_ALERT, handle, fmt, ##__VA_ARGS__) 653 #define acpi_handle_crit(handle, fmt, ...) \ 654 acpi_handle_printk(KERN_CRIT, handle, fmt, ##__VA_ARGS__) 655 #define acpi_handle_err(handle, fmt, ...) \ 656 acpi_handle_printk(KERN_ERR, handle, fmt, ##__VA_ARGS__) 657 #define acpi_handle_warn(handle, fmt, ...) \ 658 acpi_handle_printk(KERN_WARNING, handle, fmt, ##__VA_ARGS__) 659 #define acpi_handle_notice(handle, fmt, ...) \ 660 acpi_handle_printk(KERN_NOTICE, handle, fmt, ##__VA_ARGS__) 661 #define acpi_handle_info(handle, fmt, ...) \ 662 acpi_handle_printk(KERN_INFO, handle, fmt, ##__VA_ARGS__) 663 664 #if defined(DEBUG) 665 #define acpi_handle_debug(handle, fmt, ...) \ 666 acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__) 667 #else 668 #if defined(CONFIG_DYNAMIC_DEBUG) 669 #define acpi_handle_debug(handle, fmt, ...) \ 670 do { \ 671 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \ 672 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \ 673 __acpi_handle_debug(&descriptor, handle, pr_fmt(fmt), \ 674 ##__VA_ARGS__); \ 675 } while (0) 676 #else 677 #define acpi_handle_debug(handle, fmt, ...) \ 678 ({ \ 679 if (0) \ 680 acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__); \ 681 0; \ 682 }) 683 #endif 684 #endif 685 686 struct acpi_gpio_params { 687 unsigned int crs_entry_index; 688 unsigned int line_index; 689 bool active_low; 690 }; 691 692 struct acpi_gpio_mapping { 693 const char *name; 694 const struct acpi_gpio_params *data; 695 unsigned int size; 696 }; 697 698 #if defined(CONFIG_ACPI) && defined(CONFIG_GPIOLIB) 699 int acpi_dev_add_driver_gpios(struct acpi_device *adev, 700 const struct acpi_gpio_mapping *gpios); 701 702 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) 703 { 704 if (adev) 705 adev->driver_gpios = NULL; 706 } 707 #else 708 static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev, 709 const struct acpi_gpio_mapping *gpios) 710 { 711 return -ENXIO; 712 } 713 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {} 714 #endif 715 716 /* Device properties */ 717 718 #define MAX_ACPI_REFERENCE_ARGS 8 719 struct acpi_reference_args { 720 struct acpi_device *adev; 721 size_t nargs; 722 u64 args[MAX_ACPI_REFERENCE_ARGS]; 723 }; 724 725 #ifdef CONFIG_ACPI 726 int acpi_dev_get_property(struct acpi_device *adev, const char *name, 727 acpi_object_type type, const union acpi_object **obj); 728 int acpi_dev_get_property_array(struct acpi_device *adev, const char *name, 729 acpi_object_type type, 730 const union acpi_object **obj); 731 int acpi_dev_get_property_reference(struct acpi_device *adev, 732 const char *name, size_t index, 733 struct acpi_reference_args *args); 734 735 int acpi_dev_prop_get(struct acpi_device *adev, const char *propname, 736 void **valptr); 737 int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname, 738 enum dev_prop_type proptype, void *val); 739 int acpi_dev_prop_read(struct acpi_device *adev, const char *propname, 740 enum dev_prop_type proptype, void *val, size_t nval); 741 742 struct acpi_device *acpi_get_next_child(struct device *dev, 743 struct acpi_device *child); 744 #else 745 static inline int acpi_dev_get_property(struct acpi_device *adev, 746 const char *name, acpi_object_type type, 747 const union acpi_object **obj) 748 { 749 return -ENXIO; 750 } 751 static inline int acpi_dev_get_property_array(struct acpi_device *adev, 752 const char *name, 753 acpi_object_type type, 754 const union acpi_object **obj) 755 { 756 return -ENXIO; 757 } 758 static inline int acpi_dev_get_property_reference(struct acpi_device *adev, 759 const char *name, const char *cells_name, 760 size_t index, struct acpi_reference_args *args) 761 { 762 return -ENXIO; 763 } 764 765 static inline int acpi_dev_prop_get(struct acpi_device *adev, 766 const char *propname, 767 void **valptr) 768 { 769 return -ENXIO; 770 } 771 772 static inline int acpi_dev_prop_read_single(struct acpi_device *adev, 773 const char *propname, 774 enum dev_prop_type proptype, 775 void *val) 776 { 777 return -ENXIO; 778 } 779 780 static inline int acpi_dev_prop_read(struct acpi_device *adev, 781 const char *propname, 782 enum dev_prop_type proptype, 783 void *val, size_t nval) 784 { 785 return -ENXIO; 786 } 787 788 static inline struct acpi_device *acpi_get_next_child(struct device *dev, 789 struct acpi_device *child) 790 { 791 return NULL; 792 } 793 794 #endif 795 796 #endif /*_LINUX_ACPI_H*/ 797