1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * acpi.h - ACPI Interface 4 * 5 * Copyright (C) 2001 Paul Diefenbaugh <[email protected]> 6 */ 7 8 #ifndef _LINUX_ACPI_H 9 #define _LINUX_ACPI_H 10 11 #include <linux/errno.h> 12 #include <linux/ioport.h> /* for struct resource */ 13 #include <linux/resource_ext.h> 14 #include <linux/device.h> 15 #include <linux/property.h> 16 #include <linux/uuid.h> 17 18 #ifndef _LINUX 19 #define _LINUX 20 #endif 21 #include <acpi/acpi.h> 22 23 #ifdef CONFIG_ACPI 24 25 #include <linux/list.h> 26 #include <linux/mod_devicetable.h> 27 #include <linux/dynamic_debug.h> 28 #include <linux/module.h> 29 #include <linux/mutex.h> 30 31 #include <acpi/acpi_bus.h> 32 #include <acpi/acpi_drivers.h> 33 #include <acpi/acpi_numa.h> 34 #include <acpi/acpi_io.h> 35 #include <asm/acpi.h> 36 37 static inline acpi_handle acpi_device_handle(struct acpi_device *adev) 38 { 39 return adev ? adev->handle : NULL; 40 } 41 42 #define ACPI_COMPANION(dev) to_acpi_device_node((dev)->fwnode) 43 #define ACPI_COMPANION_SET(dev, adev) set_primary_fwnode(dev, (adev) ? \ 44 acpi_fwnode_handle(adev) : NULL) 45 #define ACPI_HANDLE(dev) acpi_device_handle(ACPI_COMPANION(dev)) 46 #define ACPI_HANDLE_FWNODE(fwnode) \ 47 acpi_device_handle(to_acpi_device_node(fwnode)) 48 49 static inline struct fwnode_handle *acpi_alloc_fwnode_static(void) 50 { 51 struct fwnode_handle *fwnode; 52 53 fwnode = kzalloc(sizeof(struct fwnode_handle), GFP_KERNEL); 54 if (!fwnode) 55 return NULL; 56 57 fwnode->ops = &acpi_static_fwnode_ops; 58 59 return fwnode; 60 } 61 62 static inline void acpi_free_fwnode_static(struct fwnode_handle *fwnode) 63 { 64 if (WARN_ON(!is_acpi_static_node(fwnode))) 65 return; 66 67 kfree(fwnode); 68 } 69 70 /** 71 * ACPI_DEVICE_CLASS - macro used to describe an ACPI device with 72 * the PCI-defined class-code information 73 * 74 * @_cls : the class, subclass, prog-if triple for this device 75 * @_msk : the class mask for this device 76 * 77 * This macro is used to create a struct acpi_device_id that matches a 78 * specific PCI class. The .id and .driver_data fields will be left 79 * initialized with the default value. 80 */ 81 #define ACPI_DEVICE_CLASS(_cls, _msk) .cls = (_cls), .cls_msk = (_msk), 82 83 static inline bool has_acpi_companion(struct device *dev) 84 { 85 return is_acpi_device_node(dev->fwnode); 86 } 87 88 static inline void acpi_preset_companion(struct device *dev, 89 struct acpi_device *parent, u64 addr) 90 { 91 ACPI_COMPANION_SET(dev, acpi_find_child_device(parent, addr, false)); 92 } 93 94 static inline const char *acpi_dev_name(struct acpi_device *adev) 95 { 96 return dev_name(&adev->dev); 97 } 98 99 struct device *acpi_get_first_physical_node(struct acpi_device *adev); 100 101 enum acpi_irq_model_id { 102 ACPI_IRQ_MODEL_PIC = 0, 103 ACPI_IRQ_MODEL_IOAPIC, 104 ACPI_IRQ_MODEL_IOSAPIC, 105 ACPI_IRQ_MODEL_PLATFORM, 106 ACPI_IRQ_MODEL_GIC, 107 ACPI_IRQ_MODEL_COUNT 108 }; 109 110 extern enum acpi_irq_model_id acpi_irq_model; 111 112 enum acpi_interrupt_id { 113 ACPI_INTERRUPT_PMI = 1, 114 ACPI_INTERRUPT_INIT, 115 ACPI_INTERRUPT_CPEI, 116 ACPI_INTERRUPT_COUNT 117 }; 118 119 #define ACPI_SPACE_MEM 0 120 121 enum acpi_address_range_id { 122 ACPI_ADDRESS_RANGE_MEMORY = 1, 123 ACPI_ADDRESS_RANGE_RESERVED = 2, 124 ACPI_ADDRESS_RANGE_ACPI = 3, 125 ACPI_ADDRESS_RANGE_NVS = 4, 126 ACPI_ADDRESS_RANGE_COUNT 127 }; 128 129 130 /* Table Handlers */ 131 union acpi_subtable_headers { 132 struct acpi_subtable_header common; 133 struct acpi_hmat_structure hmat; 134 }; 135 136 typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table); 137 138 typedef int (*acpi_tbl_entry_handler)(union acpi_subtable_headers *header, 139 const unsigned long end); 140 141 /* Debugger support */ 142 143 struct acpi_debugger_ops { 144 int (*create_thread)(acpi_osd_exec_callback function, void *context); 145 ssize_t (*write_log)(const char *msg); 146 ssize_t (*read_cmd)(char *buffer, size_t length); 147 int (*wait_command_ready)(bool single_step, char *buffer, size_t length); 148 int (*notify_command_complete)(void); 149 }; 150 151 struct acpi_debugger { 152 const struct acpi_debugger_ops *ops; 153 struct module *owner; 154 struct mutex lock; 155 }; 156 157 #ifdef CONFIG_ACPI_DEBUGGER 158 int __init acpi_debugger_init(void); 159 int acpi_register_debugger(struct module *owner, 160 const struct acpi_debugger_ops *ops); 161 void acpi_unregister_debugger(const struct acpi_debugger_ops *ops); 162 int acpi_debugger_create_thread(acpi_osd_exec_callback function, void *context); 163 ssize_t acpi_debugger_write_log(const char *msg); 164 ssize_t acpi_debugger_read_cmd(char *buffer, size_t buffer_length); 165 int acpi_debugger_wait_command_ready(void); 166 int acpi_debugger_notify_command_complete(void); 167 #else 168 static inline int acpi_debugger_init(void) 169 { 170 return -ENODEV; 171 } 172 173 static inline int acpi_register_debugger(struct module *owner, 174 const struct acpi_debugger_ops *ops) 175 { 176 return -ENODEV; 177 } 178 179 static inline void acpi_unregister_debugger(const struct acpi_debugger_ops *ops) 180 { 181 } 182 183 static inline int acpi_debugger_create_thread(acpi_osd_exec_callback function, 184 void *context) 185 { 186 return -ENODEV; 187 } 188 189 static inline int acpi_debugger_write_log(const char *msg) 190 { 191 return -ENODEV; 192 } 193 194 static inline int acpi_debugger_read_cmd(char *buffer, u32 buffer_length) 195 { 196 return -ENODEV; 197 } 198 199 static inline int acpi_debugger_wait_command_ready(void) 200 { 201 return -ENODEV; 202 } 203 204 static inline int acpi_debugger_notify_command_complete(void) 205 { 206 return -ENODEV; 207 } 208 #endif 209 210 #define BAD_MADT_ENTRY(entry, end) ( \ 211 (!entry) || (unsigned long)entry + sizeof(*entry) > end || \ 212 ((struct acpi_subtable_header *)entry)->length < sizeof(*entry)) 213 214 struct acpi_subtable_proc { 215 int id; 216 acpi_tbl_entry_handler handler; 217 int count; 218 }; 219 220 void __iomem *__acpi_map_table(unsigned long phys, unsigned long size); 221 void __acpi_unmap_table(void __iomem *map, unsigned long size); 222 int early_acpi_boot_init(void); 223 int acpi_boot_init (void); 224 void acpi_boot_table_init (void); 225 int acpi_mps_check (void); 226 int acpi_numa_init (void); 227 228 int acpi_table_init (void); 229 int acpi_table_parse(char *id, acpi_tbl_table_handler handler); 230 int __init acpi_table_parse_entries(char *id, unsigned long table_size, 231 int entry_id, 232 acpi_tbl_entry_handler handler, 233 unsigned int max_entries); 234 int __init acpi_table_parse_entries_array(char *id, unsigned long table_size, 235 struct acpi_subtable_proc *proc, int proc_num, 236 unsigned int max_entries); 237 int acpi_table_parse_madt(enum acpi_madt_type id, 238 acpi_tbl_entry_handler handler, 239 unsigned int max_entries); 240 int acpi_parse_mcfg (struct acpi_table_header *header); 241 void acpi_table_print_madt_entry (struct acpi_subtable_header *madt); 242 243 /* the following numa functions are architecture-dependent */ 244 void acpi_numa_slit_init (struct acpi_table_slit *slit); 245 246 #if defined(CONFIG_X86) || defined(CONFIG_IA64) 247 void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa); 248 #else 249 static inline void 250 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa) { } 251 #endif 252 253 void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa); 254 255 #ifdef CONFIG_ARM64 256 void acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa); 257 #else 258 static inline void 259 acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa) { } 260 #endif 261 262 int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma); 263 264 #ifndef PHYS_CPUID_INVALID 265 typedef u32 phys_cpuid_t; 266 #define PHYS_CPUID_INVALID (phys_cpuid_t)(-1) 267 #endif 268 269 static inline bool invalid_logical_cpuid(u32 cpuid) 270 { 271 return (int)cpuid < 0; 272 } 273 274 static inline bool invalid_phys_cpuid(phys_cpuid_t phys_id) 275 { 276 return phys_id == PHYS_CPUID_INVALID; 277 } 278 279 /* Validate the processor object's proc_id */ 280 bool acpi_duplicate_processor_id(int proc_id); 281 282 #ifdef CONFIG_ACPI_HOTPLUG_CPU 283 /* Arch dependent functions for cpu hotplug support */ 284 int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id, 285 int *pcpu); 286 int acpi_unmap_cpu(int cpu); 287 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 288 289 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 290 int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr); 291 #endif 292 293 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base); 294 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base); 295 int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base); 296 void acpi_irq_stats_init(void); 297 extern u32 acpi_irq_handled; 298 extern u32 acpi_irq_not_handled; 299 extern unsigned int acpi_sci_irq; 300 extern bool acpi_no_s5; 301 #define INVALID_ACPI_IRQ ((unsigned)-1) 302 static inline bool acpi_sci_irq_valid(void) 303 { 304 return acpi_sci_irq != INVALID_ACPI_IRQ; 305 } 306 307 extern int sbf_port; 308 extern unsigned long acpi_realmode_flags; 309 310 int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity); 311 int acpi_gsi_to_irq (u32 gsi, unsigned int *irq); 312 int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi); 313 314 void acpi_set_irq_model(enum acpi_irq_model_id model, 315 struct fwnode_handle *fwnode); 316 317 #ifdef CONFIG_X86_IO_APIC 318 extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity); 319 #else 320 #define acpi_get_override_irq(gsi, trigger, polarity) (-1) 321 #endif 322 /* 323 * This function undoes the effect of one call to acpi_register_gsi(). 324 * If this matches the last registration, any IRQ resources for gsi 325 * are freed. 326 */ 327 void acpi_unregister_gsi (u32 gsi); 328 329 struct pci_dev; 330 331 int acpi_pci_irq_enable (struct pci_dev *dev); 332 void acpi_penalize_isa_irq(int irq, int active); 333 bool acpi_isa_irq_available(int irq); 334 #ifdef CONFIG_PCI 335 void acpi_penalize_sci_irq(int irq, int trigger, int polarity); 336 #else 337 static inline void acpi_penalize_sci_irq(int irq, int trigger, 338 int polarity) 339 { 340 } 341 #endif 342 void acpi_pci_irq_disable (struct pci_dev *dev); 343 344 extern int ec_read(u8 addr, u8 *val); 345 extern int ec_write(u8 addr, u8 val); 346 extern int ec_transaction(u8 command, 347 const u8 *wdata, unsigned wdata_len, 348 u8 *rdata, unsigned rdata_len); 349 extern acpi_handle ec_get_handle(void); 350 351 extern bool acpi_is_pnp_device(struct acpi_device *); 352 353 #if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE) 354 355 typedef void (*wmi_notify_handler) (u32 value, void *context); 356 357 extern acpi_status wmi_evaluate_method(const char *guid, u8 instance, 358 u32 method_id, 359 const struct acpi_buffer *in, 360 struct acpi_buffer *out); 361 extern acpi_status wmi_query_block(const char *guid, u8 instance, 362 struct acpi_buffer *out); 363 extern acpi_status wmi_set_block(const char *guid, u8 instance, 364 const struct acpi_buffer *in); 365 extern acpi_status wmi_install_notify_handler(const char *guid, 366 wmi_notify_handler handler, void *data); 367 extern acpi_status wmi_remove_notify_handler(const char *guid); 368 extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out); 369 extern bool wmi_has_guid(const char *guid); 370 371 #endif /* CONFIG_ACPI_WMI */ 372 373 #define ACPI_VIDEO_OUTPUT_SWITCHING 0x0001 374 #define ACPI_VIDEO_DEVICE_POSTING 0x0002 375 #define ACPI_VIDEO_ROM_AVAILABLE 0x0004 376 #define ACPI_VIDEO_BACKLIGHT 0x0008 377 #define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR 0x0010 378 #define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO 0x0020 379 #define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR 0x0040 380 #define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO 0x0080 381 #define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR 0x0100 382 #define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO 0x0200 383 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR 0x0400 384 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO 0x0800 385 386 extern char acpi_video_backlight_string[]; 387 extern long acpi_is_video_device(acpi_handle handle); 388 extern int acpi_blacklisted(void); 389 extern void acpi_osi_setup(char *str); 390 extern bool acpi_osi_is_win8(void); 391 392 #ifdef CONFIG_ACPI_NUMA 393 int acpi_map_pxm_to_online_node(int pxm); 394 int acpi_map_pxm_to_node(int pxm); 395 int acpi_get_node(acpi_handle handle); 396 #else 397 static inline int acpi_map_pxm_to_online_node(int pxm) 398 { 399 return 0; 400 } 401 static inline int acpi_map_pxm_to_node(int pxm) 402 { 403 return 0; 404 } 405 static inline int acpi_get_node(acpi_handle handle) 406 { 407 return 0; 408 } 409 #endif 410 extern int acpi_paddr_to_node(u64 start_addr, u64 size); 411 412 extern int pnpacpi_disabled; 413 414 #define PXM_INVAL (-1) 415 416 bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res); 417 bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res); 418 bool acpi_dev_resource_address_space(struct acpi_resource *ares, 419 struct resource_win *win); 420 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares, 421 struct resource_win *win); 422 unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable); 423 unsigned int acpi_dev_get_irq_type(int triggering, int polarity); 424 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index, 425 struct resource *res); 426 427 void acpi_dev_free_resource_list(struct list_head *list); 428 int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list, 429 int (*preproc)(struct acpi_resource *, void *), 430 void *preproc_data); 431 int acpi_dev_get_dma_resources(struct acpi_device *adev, 432 struct list_head *list); 433 int acpi_dev_filter_resource_type(struct acpi_resource *ares, 434 unsigned long types); 435 436 static inline int acpi_dev_filter_resource_type_cb(struct acpi_resource *ares, 437 void *arg) 438 { 439 return acpi_dev_filter_resource_type(ares, (unsigned long)arg); 440 } 441 442 struct acpi_device *acpi_resource_consumer(struct resource *res); 443 444 int acpi_check_resource_conflict(const struct resource *res); 445 446 int acpi_check_region(resource_size_t start, resource_size_t n, 447 const char *name); 448 449 acpi_status acpi_release_memory(acpi_handle handle, struct resource *res, 450 u32 level); 451 452 int acpi_resources_are_enforced(void); 453 454 #ifdef CONFIG_HIBERNATION 455 void __init acpi_no_s4_hw_signature(void); 456 #endif 457 458 #ifdef CONFIG_PM_SLEEP 459 void __init acpi_old_suspend_ordering(void); 460 void __init acpi_nvs_nosave(void); 461 void __init acpi_nvs_nosave_s3(void); 462 void __init acpi_sleep_no_blacklist(void); 463 #endif /* CONFIG_PM_SLEEP */ 464 465 struct acpi_osc_context { 466 char *uuid_str; /* UUID string */ 467 int rev; 468 struct acpi_buffer cap; /* list of DWORD capabilities */ 469 struct acpi_buffer ret; /* free by caller if success */ 470 }; 471 472 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context); 473 474 /* Indexes into _OSC Capabilities Buffer (DWORDs 2 & 3 are device-specific) */ 475 #define OSC_QUERY_DWORD 0 /* DWORD 1 */ 476 #define OSC_SUPPORT_DWORD 1 /* DWORD 2 */ 477 #define OSC_CONTROL_DWORD 2 /* DWORD 3 */ 478 479 /* _OSC Capabilities DWORD 1: Query/Control and Error Returns (generic) */ 480 #define OSC_QUERY_ENABLE 0x00000001 /* input */ 481 #define OSC_REQUEST_ERROR 0x00000002 /* return */ 482 #define OSC_INVALID_UUID_ERROR 0x00000004 /* return */ 483 #define OSC_INVALID_REVISION_ERROR 0x00000008 /* return */ 484 #define OSC_CAPABILITIES_MASK_ERROR 0x00000010 /* return */ 485 486 /* Platform-Wide Capabilities _OSC: Capabilities DWORD 2: Support Field */ 487 #define OSC_SB_PAD_SUPPORT 0x00000001 488 #define OSC_SB_PPC_OST_SUPPORT 0x00000002 489 #define OSC_SB_PR3_SUPPORT 0x00000004 490 #define OSC_SB_HOTPLUG_OST_SUPPORT 0x00000008 491 #define OSC_SB_APEI_SUPPORT 0x00000010 492 #define OSC_SB_CPC_SUPPORT 0x00000020 493 #define OSC_SB_CPCV2_SUPPORT 0x00000040 494 #define OSC_SB_PCLPI_SUPPORT 0x00000080 495 #define OSC_SB_OSLPI_SUPPORT 0x00000100 496 #define OSC_SB_CPC_DIVERSE_HIGH_SUPPORT 0x00001000 497 498 extern bool osc_sb_apei_support_acked; 499 extern bool osc_pc_lpi_support_confirmed; 500 501 /* PCI Host Bridge _OSC: Capabilities DWORD 2: Support Field */ 502 #define OSC_PCI_EXT_CONFIG_SUPPORT 0x00000001 503 #define OSC_PCI_ASPM_SUPPORT 0x00000002 504 #define OSC_PCI_CLOCK_PM_SUPPORT 0x00000004 505 #define OSC_PCI_SEGMENT_GROUPS_SUPPORT 0x00000008 506 #define OSC_PCI_MSI_SUPPORT 0x00000010 507 #define OSC_PCI_HPX_TYPE_3_SUPPORT 0x00000100 508 #define OSC_PCI_SUPPORT_MASKS 0x0000011f 509 510 /* PCI Host Bridge _OSC: Capabilities DWORD 3: Control Field */ 511 #define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL 0x00000001 512 #define OSC_PCI_SHPC_NATIVE_HP_CONTROL 0x00000002 513 #define OSC_PCI_EXPRESS_PME_CONTROL 0x00000004 514 #define OSC_PCI_EXPRESS_AER_CONTROL 0x00000008 515 #define OSC_PCI_EXPRESS_CAPABILITY_CONTROL 0x00000010 516 #define OSC_PCI_EXPRESS_LTR_CONTROL 0x00000020 517 #define OSC_PCI_CONTROL_MASKS 0x0000003f 518 519 #define ACPI_GSB_ACCESS_ATTRIB_QUICK 0x00000002 520 #define ACPI_GSB_ACCESS_ATTRIB_SEND_RCV 0x00000004 521 #define ACPI_GSB_ACCESS_ATTRIB_BYTE 0x00000006 522 #define ACPI_GSB_ACCESS_ATTRIB_WORD 0x00000008 523 #define ACPI_GSB_ACCESS_ATTRIB_BLOCK 0x0000000A 524 #define ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE 0x0000000B 525 #define ACPI_GSB_ACCESS_ATTRIB_WORD_CALL 0x0000000C 526 #define ACPI_GSB_ACCESS_ATTRIB_BLOCK_CALL 0x0000000D 527 #define ACPI_GSB_ACCESS_ATTRIB_RAW_BYTES 0x0000000E 528 #define ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS 0x0000000F 529 530 extern acpi_status acpi_pci_osc_control_set(acpi_handle handle, 531 u32 *mask, u32 req); 532 533 /* Enable _OST when all relevant hotplug operations are enabled */ 534 #if defined(CONFIG_ACPI_HOTPLUG_CPU) && \ 535 defined(CONFIG_ACPI_HOTPLUG_MEMORY) && \ 536 defined(CONFIG_ACPI_CONTAINER) 537 #define ACPI_HOTPLUG_OST 538 #endif 539 540 /* _OST Source Event Code (OSPM Action) */ 541 #define ACPI_OST_EC_OSPM_SHUTDOWN 0x100 542 #define ACPI_OST_EC_OSPM_EJECT 0x103 543 #define ACPI_OST_EC_OSPM_INSERTION 0x200 544 545 /* _OST General Processing Status Code */ 546 #define ACPI_OST_SC_SUCCESS 0x0 547 #define ACPI_OST_SC_NON_SPECIFIC_FAILURE 0x1 548 #define ACPI_OST_SC_UNRECOGNIZED_NOTIFY 0x2 549 550 /* _OST OS Shutdown Processing (0x100) Status Code */ 551 #define ACPI_OST_SC_OS_SHUTDOWN_DENIED 0x80 552 #define ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS 0x81 553 #define ACPI_OST_SC_OS_SHUTDOWN_COMPLETED 0x82 554 #define ACPI_OST_SC_OS_SHUTDOWN_NOT_SUPPORTED 0x83 555 556 /* _OST Ejection Request (0x3, 0x103) Status Code */ 557 #define ACPI_OST_SC_EJECT_NOT_SUPPORTED 0x80 558 #define ACPI_OST_SC_DEVICE_IN_USE 0x81 559 #define ACPI_OST_SC_DEVICE_BUSY 0x82 560 #define ACPI_OST_SC_EJECT_DEPENDENCY_BUSY 0x83 561 #define ACPI_OST_SC_EJECT_IN_PROGRESS 0x84 562 563 /* _OST Insertion Request (0x200) Status Code */ 564 #define ACPI_OST_SC_INSERT_IN_PROGRESS 0x80 565 #define ACPI_OST_SC_DRIVER_LOAD_FAILURE 0x81 566 #define ACPI_OST_SC_INSERT_NOT_SUPPORTED 0x82 567 568 enum acpi_predicate { 569 all_versions, 570 less_than_or_equal, 571 equal, 572 greater_than_or_equal, 573 }; 574 575 /* Table must be terminted by a NULL entry */ 576 struct acpi_platform_list { 577 char oem_id[ACPI_OEM_ID_SIZE+1]; 578 char oem_table_id[ACPI_OEM_TABLE_ID_SIZE+1]; 579 u32 oem_revision; 580 char *table; 581 enum acpi_predicate pred; 582 char *reason; 583 u32 data; 584 }; 585 int acpi_match_platform_list(const struct acpi_platform_list *plat); 586 587 extern void acpi_early_init(void); 588 extern void acpi_subsystem_init(void); 589 extern void arch_post_acpi_subsys_init(void); 590 591 extern int acpi_nvs_register(__u64 start, __u64 size); 592 593 extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *), 594 void *data); 595 596 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids, 597 const struct device *dev); 598 599 const void *acpi_device_get_match_data(const struct device *dev); 600 extern bool acpi_driver_match_device(struct device *dev, 601 const struct device_driver *drv); 602 int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *); 603 int acpi_device_modalias(struct device *, char *, int); 604 void acpi_walk_dep_device_list(acpi_handle handle); 605 606 struct platform_device *acpi_create_platform_device(struct acpi_device *, 607 struct property_entry *); 608 #define ACPI_PTR(_ptr) (_ptr) 609 610 static inline void acpi_device_set_enumerated(struct acpi_device *adev) 611 { 612 adev->flags.visited = true; 613 } 614 615 static inline void acpi_device_clear_enumerated(struct acpi_device *adev) 616 { 617 adev->flags.visited = false; 618 } 619 620 enum acpi_reconfig_event { 621 ACPI_RECONFIG_DEVICE_ADD = 0, 622 ACPI_RECONFIG_DEVICE_REMOVE, 623 }; 624 625 int acpi_reconfig_notifier_register(struct notifier_block *nb); 626 int acpi_reconfig_notifier_unregister(struct notifier_block *nb); 627 628 #ifdef CONFIG_ACPI_GTDT 629 int acpi_gtdt_init(struct acpi_table_header *table, int *platform_timer_count); 630 int acpi_gtdt_map_ppi(int type); 631 bool acpi_gtdt_c3stop(int type); 632 int acpi_arch_timer_mem_init(struct arch_timer_mem *timer_mem, int *timer_count); 633 #endif 634 635 #ifndef ACPI_HAVE_ARCH_GET_ROOT_POINTER 636 static inline u64 acpi_arch_get_root_pointer(void) 637 { 638 return 0; 639 } 640 #endif 641 642 #else /* !CONFIG_ACPI */ 643 644 #define acpi_disabled 1 645 646 #define ACPI_COMPANION(dev) (NULL) 647 #define ACPI_COMPANION_SET(dev, adev) do { } while (0) 648 #define ACPI_HANDLE(dev) (NULL) 649 #define ACPI_HANDLE_FWNODE(fwnode) (NULL) 650 #define ACPI_DEVICE_CLASS(_cls, _msk) .cls = (0), .cls_msk = (0), 651 652 struct fwnode_handle; 653 654 static inline bool acpi_dev_found(const char *hid) 655 { 656 return false; 657 } 658 659 static inline bool acpi_dev_present(const char *hid, const char *uid, s64 hrv) 660 { 661 return false; 662 } 663 664 static inline struct acpi_device * 665 acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv) 666 { 667 return NULL; 668 } 669 670 static inline void acpi_dev_put(struct acpi_device *adev) {} 671 672 static inline bool is_acpi_node(struct fwnode_handle *fwnode) 673 { 674 return false; 675 } 676 677 static inline bool is_acpi_device_node(struct fwnode_handle *fwnode) 678 { 679 return false; 680 } 681 682 static inline struct acpi_device *to_acpi_device_node(struct fwnode_handle *fwnode) 683 { 684 return NULL; 685 } 686 687 static inline bool is_acpi_data_node(struct fwnode_handle *fwnode) 688 { 689 return false; 690 } 691 692 static inline struct acpi_data_node *to_acpi_data_node(struct fwnode_handle *fwnode) 693 { 694 return NULL; 695 } 696 697 static inline bool acpi_data_node_match(struct fwnode_handle *fwnode, 698 const char *name) 699 { 700 return false; 701 } 702 703 static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev) 704 { 705 return NULL; 706 } 707 708 static inline bool has_acpi_companion(struct device *dev) 709 { 710 return false; 711 } 712 713 static inline void acpi_preset_companion(struct device *dev, 714 struct acpi_device *parent, u64 addr) 715 { 716 } 717 718 static inline const char *acpi_dev_name(struct acpi_device *adev) 719 { 720 return NULL; 721 } 722 723 static inline struct device *acpi_get_first_physical_node(struct acpi_device *adev) 724 { 725 return NULL; 726 } 727 728 static inline void acpi_early_init(void) { } 729 static inline void acpi_subsystem_init(void) { } 730 731 static inline int early_acpi_boot_init(void) 732 { 733 return 0; 734 } 735 static inline int acpi_boot_init(void) 736 { 737 return 0; 738 } 739 740 static inline void acpi_boot_table_init(void) 741 { 742 return; 743 } 744 745 static inline int acpi_mps_check(void) 746 { 747 return 0; 748 } 749 750 static inline int acpi_check_resource_conflict(struct resource *res) 751 { 752 return 0; 753 } 754 755 static inline int acpi_check_region(resource_size_t start, resource_size_t n, 756 const char *name) 757 { 758 return 0; 759 } 760 761 struct acpi_table_header; 762 static inline int acpi_table_parse(char *id, 763 int (*handler)(struct acpi_table_header *)) 764 { 765 return -ENODEV; 766 } 767 768 static inline int acpi_nvs_register(__u64 start, __u64 size) 769 { 770 return 0; 771 } 772 773 static inline int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *), 774 void *data) 775 { 776 return 0; 777 } 778 779 struct acpi_device_id; 780 781 static inline const struct acpi_device_id *acpi_match_device( 782 const struct acpi_device_id *ids, const struct device *dev) 783 { 784 return NULL; 785 } 786 787 static inline const void *acpi_device_get_match_data(const struct device *dev) 788 { 789 return NULL; 790 } 791 792 static inline bool acpi_driver_match_device(struct device *dev, 793 const struct device_driver *drv) 794 { 795 return false; 796 } 797 798 static inline union acpi_object *acpi_evaluate_dsm(acpi_handle handle, 799 const guid_t *guid, 800 int rev, int func, 801 union acpi_object *argv4) 802 { 803 return NULL; 804 } 805 806 static inline int acpi_device_uevent_modalias(struct device *dev, 807 struct kobj_uevent_env *env) 808 { 809 return -ENODEV; 810 } 811 812 static inline int acpi_device_modalias(struct device *dev, 813 char *buf, int size) 814 { 815 return -ENODEV; 816 } 817 818 static inline bool acpi_dma_supported(struct acpi_device *adev) 819 { 820 return false; 821 } 822 823 static inline enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev) 824 { 825 return DEV_DMA_NOT_SUPPORTED; 826 } 827 828 static inline int acpi_dma_get_range(struct device *dev, u64 *dma_addr, 829 u64 *offset, u64 *size) 830 { 831 return -ENODEV; 832 } 833 834 static inline int acpi_dma_configure(struct device *dev, 835 enum dev_dma_attr attr) 836 { 837 return 0; 838 } 839 840 #define ACPI_PTR(_ptr) (NULL) 841 842 static inline void acpi_device_set_enumerated(struct acpi_device *adev) 843 { 844 } 845 846 static inline void acpi_device_clear_enumerated(struct acpi_device *adev) 847 { 848 } 849 850 static inline int acpi_reconfig_notifier_register(struct notifier_block *nb) 851 { 852 return -EINVAL; 853 } 854 855 static inline int acpi_reconfig_notifier_unregister(struct notifier_block *nb) 856 { 857 return -EINVAL; 858 } 859 860 static inline struct acpi_device *acpi_resource_consumer(struct resource *res) 861 { 862 return NULL; 863 } 864 865 #endif /* !CONFIG_ACPI */ 866 867 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 868 int acpi_ioapic_add(acpi_handle root); 869 #else 870 static inline int acpi_ioapic_add(acpi_handle root) { return 0; } 871 #endif 872 873 #ifdef CONFIG_ACPI 874 void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state, 875 u32 pm1a_ctrl, u32 pm1b_ctrl)); 876 877 acpi_status acpi_os_prepare_sleep(u8 sleep_state, 878 u32 pm1a_control, u32 pm1b_control); 879 880 void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state, 881 u32 val_a, u32 val_b)); 882 883 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, 884 u32 val_a, u32 val_b); 885 886 #ifdef CONFIG_X86 887 void arch_reserve_mem_area(acpi_physical_address addr, size_t size); 888 #else 889 static inline void arch_reserve_mem_area(acpi_physical_address addr, 890 size_t size) 891 { 892 } 893 #endif /* CONFIG_X86 */ 894 #else 895 #define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0) 896 #endif 897 898 #if defined(CONFIG_ACPI) && defined(CONFIG_PM) 899 int acpi_dev_suspend(struct device *dev, bool wakeup); 900 int acpi_dev_resume(struct device *dev); 901 int acpi_subsys_runtime_suspend(struct device *dev); 902 int acpi_subsys_runtime_resume(struct device *dev); 903 int acpi_dev_pm_attach(struct device *dev, bool power_on); 904 #else 905 static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; } 906 static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; } 907 static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; } 908 static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; } 909 static inline int acpi_dev_pm_attach(struct device *dev, bool power_on) 910 { 911 return 0; 912 } 913 #endif 914 915 #if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP) 916 int acpi_dev_suspend_late(struct device *dev); 917 int acpi_subsys_prepare(struct device *dev); 918 void acpi_subsys_complete(struct device *dev); 919 int acpi_subsys_suspend_late(struct device *dev); 920 int acpi_subsys_suspend_noirq(struct device *dev); 921 int acpi_subsys_resume_noirq(struct device *dev); 922 int acpi_subsys_resume_early(struct device *dev); 923 int acpi_subsys_suspend(struct device *dev); 924 int acpi_subsys_freeze(struct device *dev); 925 int acpi_subsys_freeze_late(struct device *dev); 926 int acpi_subsys_freeze_noirq(struct device *dev); 927 int acpi_subsys_thaw_noirq(struct device *dev); 928 #else 929 static inline int acpi_dev_resume_early(struct device *dev) { return 0; } 930 static inline int acpi_subsys_prepare(struct device *dev) { return 0; } 931 static inline void acpi_subsys_complete(struct device *dev) {} 932 static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; } 933 static inline int acpi_subsys_suspend_noirq(struct device *dev) { return 0; } 934 static inline int acpi_subsys_resume_noirq(struct device *dev) { return 0; } 935 static inline int acpi_subsys_resume_early(struct device *dev) { return 0; } 936 static inline int acpi_subsys_suspend(struct device *dev) { return 0; } 937 static inline int acpi_subsys_freeze(struct device *dev) { return 0; } 938 static inline int acpi_subsys_freeze_late(struct device *dev) { return 0; } 939 static inline int acpi_subsys_freeze_noirq(struct device *dev) { return 0; } 940 static inline int acpi_subsys_thaw_noirq(struct device *dev) { return 0; } 941 #endif 942 943 #ifdef CONFIG_ACPI 944 __printf(3, 4) 945 void acpi_handle_printk(const char *level, acpi_handle handle, 946 const char *fmt, ...); 947 #else /* !CONFIG_ACPI */ 948 static inline __printf(3, 4) void 949 acpi_handle_printk(const char *level, void *handle, const char *fmt, ...) {} 950 #endif /* !CONFIG_ACPI */ 951 952 #if defined(CONFIG_ACPI) && defined(CONFIG_DYNAMIC_DEBUG) 953 __printf(3, 4) 954 void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...); 955 #endif 956 957 /* 958 * acpi_handle_<level>: Print message with ACPI prefix and object path 959 * 960 * These interfaces acquire the global namespace mutex to obtain an object 961 * path. In interrupt context, it shows the object path as <n/a>. 962 */ 963 #define acpi_handle_emerg(handle, fmt, ...) \ 964 acpi_handle_printk(KERN_EMERG, handle, fmt, ##__VA_ARGS__) 965 #define acpi_handle_alert(handle, fmt, ...) \ 966 acpi_handle_printk(KERN_ALERT, handle, fmt, ##__VA_ARGS__) 967 #define acpi_handle_crit(handle, fmt, ...) \ 968 acpi_handle_printk(KERN_CRIT, handle, fmt, ##__VA_ARGS__) 969 #define acpi_handle_err(handle, fmt, ...) \ 970 acpi_handle_printk(KERN_ERR, handle, fmt, ##__VA_ARGS__) 971 #define acpi_handle_warn(handle, fmt, ...) \ 972 acpi_handle_printk(KERN_WARNING, handle, fmt, ##__VA_ARGS__) 973 #define acpi_handle_notice(handle, fmt, ...) \ 974 acpi_handle_printk(KERN_NOTICE, handle, fmt, ##__VA_ARGS__) 975 #define acpi_handle_info(handle, fmt, ...) \ 976 acpi_handle_printk(KERN_INFO, handle, fmt, ##__VA_ARGS__) 977 978 #if defined(DEBUG) 979 #define acpi_handle_debug(handle, fmt, ...) \ 980 acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__) 981 #else 982 #if defined(CONFIG_DYNAMIC_DEBUG) 983 #define acpi_handle_debug(handle, fmt, ...) \ 984 _dynamic_func_call(fmt, __acpi_handle_debug, \ 985 handle, pr_fmt(fmt), ##__VA_ARGS__) 986 #else 987 #define acpi_handle_debug(handle, fmt, ...) \ 988 ({ \ 989 if (0) \ 990 acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__); \ 991 0; \ 992 }) 993 #endif 994 #endif 995 996 struct acpi_gpio_params { 997 unsigned int crs_entry_index; 998 unsigned int line_index; 999 bool active_low; 1000 }; 1001 1002 struct acpi_gpio_mapping { 1003 const char *name; 1004 const struct acpi_gpio_params *data; 1005 unsigned int size; 1006 1007 /* Ignore IoRestriction field */ 1008 #define ACPI_GPIO_QUIRK_NO_IO_RESTRICTION BIT(0) 1009 /* 1010 * When ACPI GPIO mapping table is in use the index parameter inside it 1011 * refers to the GPIO resource in _CRS method. That index has no 1012 * distinction of actual type of the resource. When consumer wants to 1013 * get GpioIo type explicitly, this quirk may be used. 1014 */ 1015 #define ACPI_GPIO_QUIRK_ONLY_GPIOIO BIT(1) 1016 1017 unsigned int quirks; 1018 }; 1019 1020 #if defined(CONFIG_ACPI) && defined(CONFIG_GPIOLIB) 1021 int acpi_dev_add_driver_gpios(struct acpi_device *adev, 1022 const struct acpi_gpio_mapping *gpios); 1023 1024 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) 1025 { 1026 if (adev) 1027 adev->driver_gpios = NULL; 1028 } 1029 1030 int devm_acpi_dev_add_driver_gpios(struct device *dev, 1031 const struct acpi_gpio_mapping *gpios); 1032 void devm_acpi_dev_remove_driver_gpios(struct device *dev); 1033 1034 bool acpi_gpio_get_irq_resource(struct acpi_resource *ares, 1035 struct acpi_resource_gpio **agpio); 1036 int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index); 1037 #else 1038 static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev, 1039 const struct acpi_gpio_mapping *gpios) 1040 { 1041 return -ENXIO; 1042 } 1043 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {} 1044 1045 static inline int devm_acpi_dev_add_driver_gpios(struct device *dev, 1046 const struct acpi_gpio_mapping *gpios) 1047 { 1048 return -ENXIO; 1049 } 1050 static inline void devm_acpi_dev_remove_driver_gpios(struct device *dev) {} 1051 1052 static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares, 1053 struct acpi_resource_gpio **agpio) 1054 { 1055 return false; 1056 } 1057 static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index) 1058 { 1059 return -ENXIO; 1060 } 1061 #endif 1062 1063 /* Device properties */ 1064 1065 #ifdef CONFIG_ACPI 1066 int acpi_dev_get_property(const struct acpi_device *adev, const char *name, 1067 acpi_object_type type, const union acpi_object **obj); 1068 int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode, 1069 const char *name, size_t index, size_t num_args, 1070 struct fwnode_reference_args *args); 1071 1072 static inline int acpi_node_get_property_reference( 1073 const struct fwnode_handle *fwnode, 1074 const char *name, size_t index, 1075 struct fwnode_reference_args *args) 1076 { 1077 return __acpi_node_get_property_reference(fwnode, name, index, 1078 NR_FWNODE_REFERENCE_ARGS, args); 1079 } 1080 1081 static inline bool acpi_dev_has_props(const struct acpi_device *adev) 1082 { 1083 return !list_empty(&adev->data.properties); 1084 } 1085 1086 struct acpi_device_properties * 1087 acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid, 1088 const union acpi_object *properties); 1089 1090 int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname, 1091 void **valptr); 1092 int acpi_dev_prop_read_single(struct acpi_device *adev, 1093 const char *propname, enum dev_prop_type proptype, 1094 void *val); 1095 int acpi_node_prop_read(const struct fwnode_handle *fwnode, 1096 const char *propname, enum dev_prop_type proptype, 1097 void *val, size_t nval); 1098 int acpi_dev_prop_read(const struct acpi_device *adev, const char *propname, 1099 enum dev_prop_type proptype, void *val, size_t nval); 1100 1101 struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode, 1102 struct fwnode_handle *child); 1103 struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode); 1104 1105 struct acpi_probe_entry; 1106 typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *, 1107 struct acpi_probe_entry *); 1108 1109 #define ACPI_TABLE_ID_LEN 5 1110 1111 /** 1112 * struct acpi_probe_entry - boot-time probing entry 1113 * @id: ACPI table name 1114 * @type: Optional subtable type to match 1115 * (if @id contains subtables) 1116 * @subtable_valid: Optional callback to check the validity of 1117 * the subtable 1118 * @probe_table: Callback to the driver being probed when table 1119 * match is successful 1120 * @probe_subtbl: Callback to the driver being probed when table and 1121 * subtable match (and optional callback is successful) 1122 * @driver_data: Sideband data provided back to the driver 1123 */ 1124 struct acpi_probe_entry { 1125 __u8 id[ACPI_TABLE_ID_LEN]; 1126 __u8 type; 1127 acpi_probe_entry_validate_subtbl subtable_valid; 1128 union { 1129 acpi_tbl_table_handler probe_table; 1130 acpi_tbl_entry_handler probe_subtbl; 1131 }; 1132 kernel_ulong_t driver_data; 1133 }; 1134 1135 #define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, valid, data, fn) \ 1136 static const struct acpi_probe_entry __acpi_probe_##name \ 1137 __used __section(__##table##_acpi_probe_table) \ 1138 = { \ 1139 .id = table_id, \ 1140 .type = subtable, \ 1141 .subtable_valid = valid, \ 1142 .probe_table = (acpi_tbl_table_handler)fn, \ 1143 .driver_data = data, \ 1144 } 1145 1146 #define ACPI_PROBE_TABLE(name) __##name##_acpi_probe_table 1147 #define ACPI_PROBE_TABLE_END(name) __##name##_acpi_probe_table_end 1148 1149 int __acpi_probe_device_table(struct acpi_probe_entry *start, int nr); 1150 1151 #define acpi_probe_device_table(t) \ 1152 ({ \ 1153 extern struct acpi_probe_entry ACPI_PROBE_TABLE(t), \ 1154 ACPI_PROBE_TABLE_END(t); \ 1155 __acpi_probe_device_table(&ACPI_PROBE_TABLE(t), \ 1156 (&ACPI_PROBE_TABLE_END(t) - \ 1157 &ACPI_PROBE_TABLE(t))); \ 1158 }) 1159 #else 1160 static inline int acpi_dev_get_property(struct acpi_device *adev, 1161 const char *name, acpi_object_type type, 1162 const union acpi_object **obj) 1163 { 1164 return -ENXIO; 1165 } 1166 1167 static inline int 1168 __acpi_node_get_property_reference(const struct fwnode_handle *fwnode, 1169 const char *name, size_t index, size_t num_args, 1170 struct fwnode_reference_args *args) 1171 { 1172 return -ENXIO; 1173 } 1174 1175 static inline int 1176 acpi_node_get_property_reference(const struct fwnode_handle *fwnode, 1177 const char *name, size_t index, 1178 struct fwnode_reference_args *args) 1179 { 1180 return -ENXIO; 1181 } 1182 1183 static inline int acpi_node_prop_get(const struct fwnode_handle *fwnode, 1184 const char *propname, 1185 void **valptr) 1186 { 1187 return -ENXIO; 1188 } 1189 1190 static inline int acpi_dev_prop_get(const struct acpi_device *adev, 1191 const char *propname, 1192 void **valptr) 1193 { 1194 return -ENXIO; 1195 } 1196 1197 static inline int acpi_dev_prop_read_single(const struct acpi_device *adev, 1198 const char *propname, 1199 enum dev_prop_type proptype, 1200 void *val) 1201 { 1202 return -ENXIO; 1203 } 1204 1205 static inline int acpi_node_prop_read(const struct fwnode_handle *fwnode, 1206 const char *propname, 1207 enum dev_prop_type proptype, 1208 void *val, size_t nval) 1209 { 1210 return -ENXIO; 1211 } 1212 1213 static inline int acpi_dev_prop_read(const struct acpi_device *adev, 1214 const char *propname, 1215 enum dev_prop_type proptype, 1216 void *val, size_t nval) 1217 { 1218 return -ENXIO; 1219 } 1220 1221 static inline struct fwnode_handle * 1222 acpi_get_next_subnode(const struct fwnode_handle *fwnode, 1223 struct fwnode_handle *child) 1224 { 1225 return NULL; 1226 } 1227 1228 static inline struct fwnode_handle * 1229 acpi_node_get_parent(const struct fwnode_handle *fwnode) 1230 { 1231 return NULL; 1232 } 1233 1234 static inline struct fwnode_handle * 1235 acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode, 1236 struct fwnode_handle *prev) 1237 { 1238 return ERR_PTR(-ENXIO); 1239 } 1240 1241 static inline int 1242 acpi_graph_get_remote_endpoint(const struct fwnode_handle *fwnode, 1243 struct fwnode_handle **remote, 1244 struct fwnode_handle **port, 1245 struct fwnode_handle **endpoint) 1246 { 1247 return -ENXIO; 1248 } 1249 1250 #define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, valid, data, fn) \ 1251 static const void * __acpi_table_##name[] \ 1252 __attribute__((unused)) \ 1253 = { (void *) table_id, \ 1254 (void *) subtable, \ 1255 (void *) valid, \ 1256 (void *) fn, \ 1257 (void *) data } 1258 1259 #define acpi_probe_device_table(t) ({ int __r = 0; __r;}) 1260 #endif 1261 1262 #ifdef CONFIG_ACPI_TABLE_UPGRADE 1263 void acpi_table_upgrade(void); 1264 #else 1265 static inline void acpi_table_upgrade(void) { } 1266 #endif 1267 1268 #if defined(CONFIG_ACPI) && defined(CONFIG_ACPI_WATCHDOG) 1269 extern bool acpi_has_watchdog(void); 1270 #else 1271 static inline bool acpi_has_watchdog(void) { return false; } 1272 #endif 1273 1274 #ifdef CONFIG_ACPI_SPCR_TABLE 1275 extern bool qdf2400_e44_present; 1276 int acpi_parse_spcr(bool enable_earlycon, bool enable_console); 1277 #else 1278 static inline int acpi_parse_spcr(bool enable_earlycon, bool enable_console) 1279 { 1280 return 0; 1281 } 1282 #endif 1283 1284 #if IS_ENABLED(CONFIG_ACPI_GENERIC_GSI) 1285 int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res); 1286 #else 1287 static inline 1288 int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res) 1289 { 1290 return -EINVAL; 1291 } 1292 #endif 1293 1294 #ifdef CONFIG_ACPI_LPIT 1295 int lpit_read_residency_count_address(u64 *address); 1296 #else 1297 static inline int lpit_read_residency_count_address(u64 *address) 1298 { 1299 return -EINVAL; 1300 } 1301 #endif 1302 1303 #ifdef CONFIG_ACPI_PPTT 1304 int find_acpi_cpu_topology(unsigned int cpu, int level); 1305 int find_acpi_cpu_topology_package(unsigned int cpu); 1306 int find_acpi_cpu_cache_topology(unsigned int cpu, int level); 1307 #else 1308 static inline int find_acpi_cpu_topology(unsigned int cpu, int level) 1309 { 1310 return -EINVAL; 1311 } 1312 static inline int find_acpi_cpu_topology_package(unsigned int cpu) 1313 { 1314 return -EINVAL; 1315 } 1316 static inline int find_acpi_cpu_cache_topology(unsigned int cpu, int level) 1317 { 1318 return -EINVAL; 1319 } 1320 #endif 1321 1322 #ifdef CONFIG_ACPI 1323 extern int acpi_platform_notify(struct device *dev, enum kobject_action action); 1324 #else 1325 static inline int 1326 acpi_platform_notify(struct device *dev, enum kobject_action action) 1327 { 1328 return 0; 1329 } 1330 #endif 1331 1332 #endif /*_LINUX_ACPI_H*/ 1333