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