1
2
3
4
5
6
7
8#ifndef _LINUX_ACPI_H
9#define _LINUX_ACPI_H
10
11#include <linux/errno.h>
12#include <linux/ioport.h>
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
37static 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
49static 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
62static 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
72
73
74
75
76
77
78
79
80
81#define ACPI_DEVICE_CLASS(_cls, _msk) .cls = (_cls), .cls_msk = (_msk),
82
83static inline bool has_acpi_companion(struct device *dev)
84{
85 return is_acpi_device_node(dev->fwnode);
86}
87
88static 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
94static inline const char *acpi_dev_name(struct acpi_device *adev)
95{
96 return dev_name(&adev->dev);
97}
98
99struct device *acpi_get_first_physical_node(struct acpi_device *adev);
100
101enum 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
110extern enum acpi_irq_model_id acpi_irq_model;
111
112enum 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
121enum 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
131union acpi_subtable_headers {
132 struct acpi_subtable_header common;
133 struct acpi_hmat_structure hmat;
134};
135
136typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table);
137
138typedef int (*acpi_tbl_entry_handler)(union acpi_subtable_headers *header,
139 const unsigned long end);
140
141
142
143struct 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
151struct acpi_debugger {
152 const struct acpi_debugger_ops *ops;
153 struct module *owner;
154 struct mutex lock;
155};
156
157#ifdef CONFIG_ACPI_DEBUGGER
158int __init acpi_debugger_init(void);
159int acpi_register_debugger(struct module *owner,
160 const struct acpi_debugger_ops *ops);
161void acpi_unregister_debugger(const struct acpi_debugger_ops *ops);
162int acpi_debugger_create_thread(acpi_osd_exec_callback function, void *context);
163ssize_t acpi_debugger_write_log(const char *msg);
164ssize_t acpi_debugger_read_cmd(char *buffer, size_t buffer_length);
165int acpi_debugger_wait_command_ready(void);
166int acpi_debugger_notify_command_complete(void);
167#else
168static inline int acpi_debugger_init(void)
169{
170 return -ENODEV;
171}
172
173static inline int acpi_register_debugger(struct module *owner,
174 const struct acpi_debugger_ops *ops)
175{
176 return -ENODEV;
177}
178
179static inline void acpi_unregister_debugger(const struct acpi_debugger_ops *ops)
180{
181}
182
183static inline int acpi_debugger_create_thread(acpi_osd_exec_callback function,
184 void *context)
185{
186 return -ENODEV;
187}
188
189static inline int acpi_debugger_write_log(const char *msg)
190{
191 return -ENODEV;
192}
193
194static inline int acpi_debugger_read_cmd(char *buffer, u32 buffer_length)
195{
196 return -ENODEV;
197}
198
199static inline int acpi_debugger_wait_command_ready(void)
200{
201 return -ENODEV;
202}
203
204static 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
214struct acpi_subtable_proc {
215 int id;
216 acpi_tbl_entry_handler handler;
217 int count;
218};
219
220void __iomem *__acpi_map_table(unsigned long phys, unsigned long size);
221void __acpi_unmap_table(void __iomem *map, unsigned long size);
222int early_acpi_boot_init(void);
223int acpi_boot_init (void);
224void acpi_boot_table_init (void);
225int acpi_mps_check (void);
226int acpi_numa_init (void);
227
228int acpi_table_init (void);
229int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
230int __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);
234int __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);
237int acpi_table_parse_madt(enum acpi_madt_type id,
238 acpi_tbl_entry_handler handler,
239 unsigned int max_entries);
240int acpi_parse_mcfg (struct acpi_table_header *header);
241void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
242
243
244void acpi_numa_slit_init (struct acpi_table_slit *slit);
245
246#if defined(CONFIG_X86) || defined(CONFIG_IA64)
247void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);
248#else
249static inline void
250acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa) { }
251#endif
252
253void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);
254
255#ifdef CONFIG_ARM64
256void acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa);
257#else
258static inline void
259acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa) { }
260#endif
261
262int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);
263
264#ifndef PHYS_CPUID_INVALID
265typedef u32 phys_cpuid_t;
266#define PHYS_CPUID_INVALID (phys_cpuid_t)(-1)
267#endif
268
269static inline bool invalid_logical_cpuid(u32 cpuid)
270{
271 return (int)cpuid < 0;
272}
273
274static inline bool invalid_phys_cpuid(phys_cpuid_t phys_id)
275{
276 return phys_id == PHYS_CPUID_INVALID;
277}
278
279
280bool acpi_duplicate_processor_id(int proc_id);
281
282#ifdef CONFIG_ACPI_HOTPLUG_CPU
283
284int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id,
285 int *pcpu);
286int acpi_unmap_cpu(int cpu);
287#endif
288
289#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
290int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr);
291#endif
292
293int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
294int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
295int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base);
296void acpi_irq_stats_init(void);
297extern u32 acpi_irq_handled;
298extern u32 acpi_irq_not_handled;
299extern unsigned int acpi_sci_irq;
300extern bool acpi_no_s5;
301#define INVALID_ACPI_IRQ ((unsigned)-1)
302static inline bool acpi_sci_irq_valid(void)
303{
304 return acpi_sci_irq != INVALID_ACPI_IRQ;
305}
306
307extern int sbf_port;
308extern unsigned long acpi_realmode_flags;
309
310int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
311int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
312int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);
313
314void acpi_set_irq_model(enum acpi_irq_model_id model,
315 struct fwnode_handle *fwnode);
316
317#ifdef CONFIG_X86_IO_APIC
318extern 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
324
325
326
327void acpi_unregister_gsi (u32 gsi);
328
329struct pci_dev;
330
331int acpi_pci_irq_enable (struct pci_dev *dev);
332void acpi_penalize_isa_irq(int irq, int active);
333bool acpi_isa_irq_available(int irq);
334#ifdef CONFIG_PCI
335void acpi_penalize_sci_irq(int irq, int trigger, int polarity);
336#else
337static inline void acpi_penalize_sci_irq(int irq, int trigger,
338 int polarity)
339{
340}
341#endif
342void acpi_pci_irq_disable (struct pci_dev *dev);
343
344extern int ec_read(u8 addr, u8 *val);
345extern int ec_write(u8 addr, u8 val);
346extern int ec_transaction(u8 command,
347 const u8 *wdata, unsigned wdata_len,
348 u8 *rdata, unsigned rdata_len);
349extern acpi_handle ec_get_handle(void);
350
351extern bool acpi_is_pnp_device(struct acpi_device *);
352
353#if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
354
355typedef void (*wmi_notify_handler) (u32 value, void *context);
356
357extern 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);
361extern acpi_status wmi_query_block(const char *guid, u8 instance,
362 struct acpi_buffer *out);
363extern acpi_status wmi_set_block(const char *guid, u8 instance,
364 const struct acpi_buffer *in);
365extern acpi_status wmi_install_notify_handler(const char *guid,
366 wmi_notify_handler handler, void *data);
367extern acpi_status wmi_remove_notify_handler(const char *guid);
368extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out);
369extern bool wmi_has_guid(const char *guid);
370
371#endif
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
386extern char acpi_video_backlight_string[];
387extern long acpi_is_video_device(acpi_handle handle);
388extern int acpi_blacklisted(void);
389extern void acpi_osi_setup(char *str);
390extern bool acpi_osi_is_win8(void);
391
392#ifdef CONFIG_ACPI_NUMA
393int acpi_map_pxm_to_online_node(int pxm);
394int acpi_map_pxm_to_node(int pxm);
395int acpi_get_node(acpi_handle handle);
396#else
397static inline int acpi_map_pxm_to_online_node(int pxm)
398{
399 return 0;
400}
401static inline int acpi_map_pxm_to_node(int pxm)
402{
403 return 0;
404}
405static inline int acpi_get_node(acpi_handle handle)
406{
407 return 0;
408}
409#endif
410extern int acpi_paddr_to_node(u64 start_addr, u64 size);
411
412extern int pnpacpi_disabled;
413
414#define PXM_INVAL (-1)
415
416bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res);
417bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res);
418bool acpi_dev_resource_address_space(struct acpi_resource *ares,
419 struct resource_win *win);
420bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
421 struct resource_win *win);
422unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
423unsigned int acpi_dev_get_irq_type(int triggering, int polarity);
424bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
425 struct resource *res);
426
427void acpi_dev_free_resource_list(struct list_head *list);
428int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
429 int (*preproc)(struct acpi_resource *, void *),
430 void *preproc_data);
431int acpi_dev_get_dma_resources(struct acpi_device *adev,
432 struct list_head *list);
433int acpi_dev_filter_resource_type(struct acpi_resource *ares,
434 unsigned long types);
435
436static 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
442struct acpi_device *acpi_resource_consumer(struct resource *res);
443
444int acpi_check_resource_conflict(const struct resource *res);
445
446int acpi_check_region(resource_size_t start, resource_size_t n,
447 const char *name);
448
449acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
450 u32 level);
451
452int acpi_resources_are_enforced(void);
453
454#ifdef CONFIG_HIBERNATION
455void __init acpi_no_s4_hw_signature(void);
456#endif
457
458#ifdef CONFIG_PM_SLEEP
459void __init acpi_old_suspend_ordering(void);
460void __init acpi_nvs_nosave(void);
461void __init acpi_nvs_nosave_s3(void);
462void __init acpi_sleep_no_blacklist(void);
463#endif
464
465struct acpi_osc_context {
466 char *uuid_str;
467 int rev;
468 struct acpi_buffer cap;
469 struct acpi_buffer ret;
470};
471
472acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);
473
474
475#define OSC_QUERY_DWORD 0
476#define OSC_SUPPORT_DWORD 1
477#define OSC_CONTROL_DWORD 2
478
479
480#define OSC_QUERY_ENABLE 0x00000001
481#define OSC_REQUEST_ERROR 0x00000002
482#define OSC_INVALID_UUID_ERROR 0x00000004
483#define OSC_INVALID_REVISION_ERROR 0x00000008
484#define OSC_CAPABILITIES_MASK_ERROR 0x00000010
485
486
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
498extern bool osc_sb_apei_support_acked;
499extern bool osc_pc_lpi_support_confirmed;
500
501
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
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
530extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
531 u32 *mask, u32 req);
532
533
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
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
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
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
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
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
568enum acpi_predicate {
569 all_versions,
570 less_than_or_equal,
571 equal,
572 greater_than_or_equal,
573};
574
575
576struct 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};
585int acpi_match_platform_list(const struct acpi_platform_list *plat);
586
587extern void acpi_early_init(void);
588extern void acpi_subsystem_init(void);
589extern void arch_post_acpi_subsys_init(void);
590
591extern int acpi_nvs_register(__u64 start, __u64 size);
592
593extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
594 void *data);
595
596const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
597 const struct device *dev);
598
599const void *acpi_device_get_match_data(const struct device *dev);
600extern bool acpi_driver_match_device(struct device *dev,
601 const struct device_driver *drv);
602int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
603int acpi_device_modalias(struct device *, char *, int);
604void acpi_walk_dep_device_list(acpi_handle handle);
605
606struct platform_device *acpi_create_platform_device(struct acpi_device *,
607 struct property_entry *);
608#define ACPI_PTR(_ptr) (_ptr)
609
610static inline void acpi_device_set_enumerated(struct acpi_device *adev)
611{
612 adev->flags.visited = true;
613}
614
615static inline void acpi_device_clear_enumerated(struct acpi_device *adev)
616{
617 adev->flags.visited = false;
618}
619
620enum acpi_reconfig_event {
621 ACPI_RECONFIG_DEVICE_ADD = 0,
622 ACPI_RECONFIG_DEVICE_REMOVE,
623};
624
625int acpi_reconfig_notifier_register(struct notifier_block *nb);
626int acpi_reconfig_notifier_unregister(struct notifier_block *nb);
627
628#ifdef CONFIG_ACPI_GTDT
629int acpi_gtdt_init(struct acpi_table_header *table, int *platform_timer_count);
630int acpi_gtdt_map_ppi(int type);
631bool acpi_gtdt_c3stop(int type);
632int 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
636static inline u64 acpi_arch_get_root_pointer(void)
637{
638 return 0;
639}
640#endif
641
642#else
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
652struct fwnode_handle;
653
654static inline bool acpi_dev_found(const char *hid)
655{
656 return false;
657}
658
659static inline bool acpi_dev_present(const char *hid, const char *uid, s64 hrv)
660{
661 return false;
662}
663
664static inline struct acpi_device *
665acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv)
666{
667 return NULL;
668}
669
670static inline void acpi_dev_put(struct acpi_device *adev) {}
671
672static inline bool is_acpi_node(struct fwnode_handle *fwnode)
673{
674 return false;
675}
676
677static inline bool is_acpi_device_node(struct fwnode_handle *fwnode)
678{
679 return false;
680}
681
682static inline struct acpi_device *to_acpi_device_node(struct fwnode_handle *fwnode)
683{
684 return NULL;
685}
686
687static inline bool is_acpi_data_node(struct fwnode_handle *fwnode)
688{
689 return false;
690}
691
692static inline struct acpi_data_node *to_acpi_data_node(struct fwnode_handle *fwnode)
693{
694 return NULL;
695}
696
697static inline bool acpi_data_node_match(struct fwnode_handle *fwnode,
698 const char *name)
699{
700 return false;
701}
702
703static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
704{
705 return NULL;
706}
707
708static inline bool has_acpi_companion(struct device *dev)
709{
710 return false;
711}
712
713static inline void acpi_preset_companion(struct device *dev,
714 struct acpi_device *parent, u64 addr)
715{
716}
717
718static inline const char *acpi_dev_name(struct acpi_device *adev)
719{
720 return NULL;
721}
722
723static inline struct device *acpi_get_first_physical_node(struct acpi_device *adev)
724{
725 return NULL;
726}
727
728static inline void acpi_early_init(void) { }
729static inline void acpi_subsystem_init(void) { }
730
731static inline int early_acpi_boot_init(void)
732{
733 return 0;
734}
735static inline int acpi_boot_init(void)
736{
737 return 0;
738}
739
740static inline void acpi_boot_table_init(void)
741{
742 return;
743}
744
745static inline int acpi_mps_check(void)
746{
747 return 0;
748}
749
750static inline int acpi_check_resource_conflict(struct resource *res)
751{
752 return 0;
753}
754
755static inline int acpi_check_region(resource_size_t start, resource_size_t n,
756 const char *name)
757{
758 return 0;
759}
760
761struct acpi_table_header;
762static inline int acpi_table_parse(char *id,
763 int (*handler)(struct acpi_table_header *))
764{
765 return -ENODEV;
766}
767
768static inline int acpi_nvs_register(__u64 start, __u64 size)
769{
770 return 0;
771}
772
773static inline int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
774 void *data)
775{
776 return 0;
777}
778
779struct acpi_device_id;
780
781static 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
787static inline const void *acpi_device_get_match_data(const struct device *dev)
788{
789 return NULL;
790}
791
792static inline bool acpi_driver_match_device(struct device *dev,
793 const struct device_driver *drv)
794{
795 return false;
796}
797
798static 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
806static inline int acpi_device_uevent_modalias(struct device *dev,
807 struct kobj_uevent_env *env)
808{
809 return -ENODEV;
810}
811
812static inline int acpi_device_modalias(struct device *dev,
813 char *buf, int size)
814{
815 return -ENODEV;
816}
817
818static inline bool acpi_dma_supported(struct acpi_device *adev)
819{
820 return false;
821}
822
823static inline enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
824{
825 return DEV_DMA_NOT_SUPPORTED;
826}
827
828static inline int acpi_dma_get_range(struct device *dev, u64 *dma_addr,
829 u64 *offset, u64 *size)
830{
831 return -ENODEV;
832}
833
834static 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
842static inline void acpi_device_set_enumerated(struct acpi_device *adev)
843{
844}
845
846static inline void acpi_device_clear_enumerated(struct acpi_device *adev)
847{
848}
849
850static inline int acpi_reconfig_notifier_register(struct notifier_block *nb)
851{
852 return -EINVAL;
853}
854
855static inline int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
856{
857 return -EINVAL;
858}
859
860static inline struct acpi_device *acpi_resource_consumer(struct resource *res)
861{
862 return NULL;
863}
864
865#endif
866
867#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
868int acpi_ioapic_add(acpi_handle root);
869#else
870static inline int acpi_ioapic_add(acpi_handle root) { return 0; }
871#endif
872
873#ifdef CONFIG_ACPI
874void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
875 u32 pm1a_ctrl, u32 pm1b_ctrl));
876
877acpi_status acpi_os_prepare_sleep(u8 sleep_state,
878 u32 pm1a_control, u32 pm1b_control);
879
880void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
881 u32 val_a, u32 val_b));
882
883acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state,
884 u32 val_a, u32 val_b);
885
886#ifdef CONFIG_X86
887void arch_reserve_mem_area(acpi_physical_address addr, size_t size);
888#else
889static inline void arch_reserve_mem_area(acpi_physical_address addr,
890 size_t size)
891{
892}
893#endif
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)
899int acpi_dev_suspend(struct device *dev, bool wakeup);
900int acpi_dev_resume(struct device *dev);
901int acpi_subsys_runtime_suspend(struct device *dev);
902int acpi_subsys_runtime_resume(struct device *dev);
903int acpi_dev_pm_attach(struct device *dev, bool power_on);
904#else
905static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; }
906static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; }
907static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }
908static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }
909static 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)
916int acpi_dev_suspend_late(struct device *dev);
917int acpi_subsys_prepare(struct device *dev);
918void acpi_subsys_complete(struct device *dev);
919int acpi_subsys_suspend_late(struct device *dev);
920int acpi_subsys_suspend_noirq(struct device *dev);
921int acpi_subsys_resume_noirq(struct device *dev);
922int acpi_subsys_resume_early(struct device *dev);
923int acpi_subsys_suspend(struct device *dev);
924int acpi_subsys_freeze(struct device *dev);
925int acpi_subsys_freeze_late(struct device *dev);
926int acpi_subsys_freeze_noirq(struct device *dev);
927int acpi_subsys_thaw_noirq(struct device *dev);
928#else
929static inline int acpi_dev_resume_early(struct device *dev) { return 0; }
930static inline int acpi_subsys_prepare(struct device *dev) { return 0; }
931static inline void acpi_subsys_complete(struct device *dev) {}
932static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; }
933static inline int acpi_subsys_suspend_noirq(struct device *dev) { return 0; }
934static inline int acpi_subsys_resume_noirq(struct device *dev) { return 0; }
935static inline int acpi_subsys_resume_early(struct device *dev) { return 0; }
936static inline int acpi_subsys_suspend(struct device *dev) { return 0; }
937static inline int acpi_subsys_freeze(struct device *dev) { return 0; }
938static inline int acpi_subsys_freeze_late(struct device *dev) { return 0; }
939static inline int acpi_subsys_freeze_noirq(struct device *dev) { return 0; }
940static inline int acpi_subsys_thaw_noirq(struct device *dev) { return 0; }
941#endif
942
943#ifdef CONFIG_ACPI
944__printf(3, 4)
945void acpi_handle_printk(const char *level, acpi_handle handle,
946 const char *fmt, ...);
947#else
948static inline __printf(3, 4) void
949acpi_handle_printk(const char *level, void *handle, const char *fmt, ...) {}
950#endif
951
952#if defined(CONFIG_ACPI) && defined(CONFIG_DYNAMIC_DEBUG)
953__printf(3, 4)
954void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...);
955#endif
956
957
958
959
960
961
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
996struct acpi_gpio_params {
997 unsigned int crs_entry_index;
998 unsigned int line_index;
999 bool active_low;
1000};
1001
1002struct acpi_gpio_mapping {
1003 const char *name;
1004 const struct acpi_gpio_params *data;
1005 unsigned int size;
1006
1007
1008#define ACPI_GPIO_QUIRK_NO_IO_RESTRICTION BIT(0)
1009
1010
1011
1012
1013
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)
1021int acpi_dev_add_driver_gpios(struct acpi_device *adev,
1022 const struct acpi_gpio_mapping *gpios);
1023
1024static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev)
1025{
1026 if (adev)
1027 adev->driver_gpios = NULL;
1028}
1029
1030int devm_acpi_dev_add_driver_gpios(struct device *dev,
1031 const struct acpi_gpio_mapping *gpios);
1032void devm_acpi_dev_remove_driver_gpios(struct device *dev);
1033
1034bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
1035 struct acpi_resource_gpio **agpio);
1036int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index);
1037#else
1038static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
1039 const struct acpi_gpio_mapping *gpios)
1040{
1041 return -ENXIO;
1042}
1043static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
1044
1045static inline int devm_acpi_dev_add_driver_gpios(struct device *dev,
1046 const struct acpi_gpio_mapping *gpios)
1047{
1048 return -ENXIO;
1049}
1050static inline void devm_acpi_dev_remove_driver_gpios(struct device *dev) {}
1051
1052static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
1053 struct acpi_resource_gpio **agpio)
1054{
1055 return false;
1056}
1057static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
1058{
1059 return -ENXIO;
1060}
1061#endif
1062
1063
1064
1065#ifdef CONFIG_ACPI
1066int acpi_dev_get_property(const struct acpi_device *adev, const char *name,
1067 acpi_object_type type, const union acpi_object **obj);
1068int __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
1072static 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
1081static inline bool acpi_dev_has_props(const struct acpi_device *adev)
1082{
1083 return !list_empty(&adev->data.properties);
1084}
1085
1086struct acpi_device_properties *
1087acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,
1088 const union acpi_object *properties);
1089
1090int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname,
1091 void **valptr);
1092int acpi_dev_prop_read_single(struct acpi_device *adev,
1093 const char *propname, enum dev_prop_type proptype,
1094 void *val);
1095int acpi_node_prop_read(const struct fwnode_handle *fwnode,
1096 const char *propname, enum dev_prop_type proptype,
1097 void *val, size_t nval);
1098int acpi_dev_prop_read(const struct acpi_device *adev, const char *propname,
1099 enum dev_prop_type proptype, void *val, size_t nval);
1100
1101struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
1102 struct fwnode_handle *child);
1103struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode);
1104
1105struct acpi_probe_entry;
1106typedef 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
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124struct 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
1149int __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
1160static 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
1167static 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
1175static inline int
1176acpi_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
1183static inline int acpi_node_prop_get(const struct fwnode_handle *fwnode,
1184 const char *propname,
1185 void **valptr)
1186{
1187 return -ENXIO;
1188}
1189
1190static inline int acpi_dev_prop_get(const struct acpi_device *adev,
1191 const char *propname,
1192 void **valptr)
1193{
1194 return -ENXIO;
1195}
1196
1197static 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
1205static 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
1213static 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
1221static inline struct fwnode_handle *
1222acpi_get_next_subnode(const struct fwnode_handle *fwnode,
1223 struct fwnode_handle *child)
1224{
1225 return NULL;
1226}
1227
1228static inline struct fwnode_handle *
1229acpi_node_get_parent(const struct fwnode_handle *fwnode)
1230{
1231 return NULL;
1232}
1233
1234static inline struct fwnode_handle *
1235acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1236 struct fwnode_handle *prev)
1237{
1238 return ERR_PTR(-ENXIO);
1239}
1240
1241static inline int
1242acpi_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
1263void acpi_table_upgrade(void);
1264#else
1265static inline void acpi_table_upgrade(void) { }
1266#endif
1267
1268#if defined(CONFIG_ACPI) && defined(CONFIG_ACPI_WATCHDOG)
1269extern bool acpi_has_watchdog(void);
1270#else
1271static inline bool acpi_has_watchdog(void) { return false; }
1272#endif
1273
1274#ifdef CONFIG_ACPI_SPCR_TABLE
1275extern bool qdf2400_e44_present;
1276int acpi_parse_spcr(bool enable_earlycon, bool enable_console);
1277#else
1278static 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)
1285int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res);
1286#else
1287static inline
1288int 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
1295int lpit_read_residency_count_address(u64 *address);
1296#else
1297static inline int lpit_read_residency_count_address(u64 *address)
1298{
1299 return -EINVAL;
1300}
1301#endif
1302
1303#ifdef CONFIG_ACPI_PPTT
1304int find_acpi_cpu_topology(unsigned int cpu, int level);
1305int find_acpi_cpu_topology_package(unsigned int cpu);
1306int find_acpi_cpu_cache_topology(unsigned int cpu, int level);
1307#else
1308static inline int find_acpi_cpu_topology(unsigned int cpu, int level)
1309{
1310 return -EINVAL;
1311}
1312static inline int find_acpi_cpu_topology_package(unsigned int cpu)
1313{
1314 return -EINVAL;
1315}
1316static inline int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
1317{
1318 return -EINVAL;
1319}
1320#endif
1321
1322#ifdef CONFIG_ACPI
1323extern int acpi_platform_notify(struct device *dev, enum kobject_action action);
1324#else
1325static inline int
1326acpi_platform_notify(struct device *dev, enum kobject_action action)
1327{
1328 return 0;
1329}
1330#endif
1331
1332#endif
1333
