acpi.h 37.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * acpi.h - ACPI Interface
 *
 * Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#ifndef _LINUX_ACPI_H
#define _LINUX_ACPI_H

24
#include <linux/errno.h>
25
#include <linux/ioport.h>	/* for struct resource */
26
#include <linux/resource_ext.h>
27
#include <linux/device.h>
28
#include <linux/property.h>
C
Christoph Hellwig 已提交
29
#include <linux/uuid.h>
30

L
Linus Torvalds 已提交
31 32 33
#ifndef _LINUX
#define _LINUX
#endif
34 35 36
#include <acpi/acpi.h>

#ifdef	CONFIG_ACPI
L
Linus Torvalds 已提交
37 38

#include <linux/list.h>
39
#include <linux/mod_devicetable.h>
B
Bjørn Mork 已提交
40
#include <linux/dynamic_debug.h>
41 42
#include <linux/module.h>
#include <linux/mutex.h>
L
Linus Torvalds 已提交
43 44 45

#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
46
#include <acpi/acpi_numa.h>
47
#include <acpi/acpi_io.h>
L
Linus Torvalds 已提交
48 49
#include <asm/acpi.h>

50 51 52 53 54
static inline acpi_handle acpi_device_handle(struct acpi_device *adev)
{
	return adev ? adev->handle : NULL;
}

55
#define ACPI_COMPANION(dev)		to_acpi_device_node((dev)->fwnode)
56 57
#define ACPI_COMPANION_SET(dev, adev)	set_primary_fwnode(dev, (adev) ? \
	acpi_fwnode_handle(adev) : NULL)
58
#define ACPI_HANDLE(dev)		acpi_device_handle(ACPI_COMPANION(dev))
59 60
#define ACPI_HANDLE_FWNODE(fwnode)	\
				acpi_device_handle(to_acpi_device_node(fwnode))
61

62 63 64 65 66 67 68 69
static inline struct fwnode_handle *acpi_alloc_fwnode_static(void)
{
	struct fwnode_handle *fwnode;

	fwnode = kzalloc(sizeof(struct fwnode_handle), GFP_KERNEL);
	if (!fwnode)
		return NULL;

70
	fwnode->ops = &acpi_static_fwnode_ops;
71 72 73 74 75 76

	return fwnode;
}

static inline void acpi_free_fwnode_static(struct fwnode_handle *fwnode)
{
77
	if (WARN_ON(!is_acpi_static_node(fwnode)))
78 79 80 81 82
		return;

	kfree(fwnode);
}

83 84 85 86 87 88 89 90 91 92 93 94 95
/**
 * ACPI_DEVICE_CLASS - macro used to describe an ACPI device with
 * the PCI-defined class-code information
 *
 * @_cls : the class, subclass, prog-if triple for this device
 * @_msk : the class mask for this device
 *
 * This macro is used to create a struct acpi_device_id that matches a
 * specific PCI class. The .id and .driver_data fields will be left
 * initialized with the default value.
 */
#define ACPI_DEVICE_CLASS(_cls, _msk)	.cls = (_cls), .cls_msk = (_msk),

96 97
static inline bool has_acpi_companion(struct device *dev)
{
98
	return is_acpi_device_node(dev->fwnode);
99 100
}

101 102 103 104 105 106
static inline void acpi_preset_companion(struct device *dev,
					 struct acpi_device *parent, u64 addr)
{
	ACPI_COMPANION_SET(dev, acpi_find_child_device(parent, addr, NULL));
}

107 108 109 110 111
static inline const char *acpi_dev_name(struct acpi_device *adev)
{
	return dev_name(&adev->dev);
}

112 113
struct device *acpi_get_first_physical_node(struct acpi_device *adev);

L
Linus Torvalds 已提交
114 115 116 117
enum acpi_irq_model_id {
	ACPI_IRQ_MODEL_PIC = 0,
	ACPI_IRQ_MODEL_IOAPIC,
	ACPI_IRQ_MODEL_IOSAPIC,
J
John Keller 已提交
118
	ACPI_IRQ_MODEL_PLATFORM,
119
	ACPI_IRQ_MODEL_GIC,
L
Linus Torvalds 已提交
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
	ACPI_IRQ_MODEL_COUNT
};

extern enum acpi_irq_model_id	acpi_irq_model;

enum acpi_interrupt_id {
	ACPI_INTERRUPT_PMI	= 1,
	ACPI_INTERRUPT_INIT,
	ACPI_INTERRUPT_CPEI,
	ACPI_INTERRUPT_COUNT
};

#define	ACPI_SPACE_MEM		0

enum acpi_address_range_id {
	ACPI_ADDRESS_RANGE_MEMORY = 1,
	ACPI_ADDRESS_RANGE_RESERVED = 2,
	ACPI_ADDRESS_RANGE_ACPI = 3,
	ACPI_ADDRESS_RANGE_NVS	= 4,
	ACPI_ADDRESS_RANGE_COUNT
};


/* Table Handlers */

145
typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table);
L
Linus Torvalds 已提交
146

147 148
typedef int (*acpi_tbl_entry_handler)(struct acpi_subtable_header *header,
				      const unsigned long end);
L
Linus Torvalds 已提交
149

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
/* Debugger support */

struct acpi_debugger_ops {
	int (*create_thread)(acpi_osd_exec_callback function, void *context);
	ssize_t (*write_log)(const char *msg);
	ssize_t (*read_cmd)(char *buffer, size_t length);
	int (*wait_command_ready)(bool single_step, char *buffer, size_t length);
	int (*notify_command_complete)(void);
};

struct acpi_debugger {
	const struct acpi_debugger_ops *ops;
	struct module *owner;
	struct mutex lock;
};

#ifdef CONFIG_ACPI_DEBUGGER
int __init acpi_debugger_init(void);
int acpi_register_debugger(struct module *owner,
			   const struct acpi_debugger_ops *ops);
void acpi_unregister_debugger(const struct acpi_debugger_ops *ops);
int acpi_debugger_create_thread(acpi_osd_exec_callback function, void *context);
ssize_t acpi_debugger_write_log(const char *msg);
ssize_t acpi_debugger_read_cmd(char *buffer, size_t buffer_length);
int acpi_debugger_wait_command_ready(void);
int acpi_debugger_notify_command_complete(void);
#else
static inline int acpi_debugger_init(void)
{
	return -ENODEV;
}

static inline int acpi_register_debugger(struct module *owner,
					 const struct acpi_debugger_ops *ops)
{
	return -ENODEV;
}

static inline void acpi_unregister_debugger(const struct acpi_debugger_ops *ops)
{
}

static inline int acpi_debugger_create_thread(acpi_osd_exec_callback function,
					      void *context)
{
	return -ENODEV;
}

static inline int acpi_debugger_write_log(const char *msg)
{
	return -ENODEV;
}

static inline int acpi_debugger_read_cmd(char *buffer, u32 buffer_length)
{
	return -ENODEV;
}

static inline int acpi_debugger_wait_command_ready(void)
{
	return -ENODEV;
}

static inline int acpi_debugger_notify_command_complete(void)
{
	return -ENODEV;
}
#endif

219 220 221 222
#define BAD_MADT_ENTRY(entry, end) (					    \
		(!entry) || (unsigned long)entry + sizeof(*entry) > end ||  \
		((struct acpi_subtable_header *)entry)->length < sizeof(*entry))

223 224 225 226 227 228
struct acpi_subtable_proc {
	int id;
	acpi_tbl_entry_handler handler;
	int count;
};

229 230
void __iomem *__acpi_map_table(unsigned long phys, unsigned long size);
void __acpi_unmap_table(void __iomem *map, unsigned long size);
231
int early_acpi_boot_init(void);
L
Linus Torvalds 已提交
232
int acpi_boot_init (void);
233
void acpi_boot_table_init (void);
234
int acpi_mps_check (void);
L
Linus Torvalds 已提交
235 236 237
int acpi_numa_init (void);

int acpi_table_init (void);
238
int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
239
int __init acpi_table_parse_entries(char *id, unsigned long table_size,
240 241 242 243 244 245
			      int entry_id,
			      acpi_tbl_entry_handler handler,
			      unsigned int max_entries);
int __init acpi_table_parse_entries_array(char *id, unsigned long table_size,
			      struct acpi_subtable_proc *proc, int proc_num,
			      unsigned int max_entries);
246 247 248
int acpi_table_parse_madt(enum acpi_madt_type id,
			  acpi_tbl_entry_handler handler,
			  unsigned int max_entries);
249
int acpi_parse_mcfg (struct acpi_table_header *header);
250
void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
L
Linus Torvalds 已提交
251

252
/* the following numa functions are architecture-dependent */
L
Linus Torvalds 已提交
253
void acpi_numa_slit_init (struct acpi_table_slit *slit);
254 255

#if defined(CONFIG_X86) || defined(CONFIG_IA64)
256
void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);
257 258 259 260 261
#else
static inline void
acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa) { }
#endif

262
void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);
263 264 265 266 267 268 269 270

#ifdef CONFIG_ARM64
void acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa);
#else
static inline void
acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa) { }
#endif

271
int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);
L
Linus Torvalds 已提交
272

273 274 275 276 277
#ifndef PHYS_CPUID_INVALID
typedef u32 phys_cpuid_t;
#define PHYS_CPUID_INVALID (phys_cpuid_t)(-1)
#endif

278 279 280 281 282
static inline bool invalid_logical_cpuid(u32 cpuid)
{
	return (int)cpuid < 0;
}

283 284 285 286 287
static inline bool invalid_phys_cpuid(phys_cpuid_t phys_id)
{
	return phys_id == PHYS_CPUID_INVALID;
}

288
/* Validate the processor object's proc_id */
289
bool acpi_duplicate_processor_id(int proc_id);
290

L
Linus Torvalds 已提交
291 292
#ifdef CONFIG_ACPI_HOTPLUG_CPU
/* Arch dependent functions for cpu hotplug support */
293 294
int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id,
		 int *pcpu);
295
int acpi_unmap_cpu(int cpu);
L
Linus Torvalds 已提交
296 297
#endif /* CONFIG_ACPI_HOTPLUG_CPU */

298 299 300 301
#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr);
#endif

302 303
int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
304
int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base);
305 306
void acpi_irq_stats_init(void);
extern u32 acpi_irq_handled;
307
extern u32 acpi_irq_not_handled;
308
extern unsigned int acpi_sci_irq;
309
extern bool acpi_no_s5;
310 311 312 313 314
#define INVALID_ACPI_IRQ	((unsigned)-1)
static inline bool acpi_sci_irq_valid(void)
{
	return acpi_sci_irq != INVALID_ACPI_IRQ;
}
L
Linus Torvalds 已提交
315

316
extern int sbf_port;
317
extern unsigned long acpi_realmode_flags;
L
Linus Torvalds 已提交
318

319
int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
L
Linus Torvalds 已提交
320
int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
321
int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);
L
Linus Torvalds 已提交
322

323 324 325
void acpi_set_irq_model(enum acpi_irq_model_id model,
			struct fwnode_handle *fwnode);

326
#ifdef CONFIG_X86_IO_APIC
327
extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity);
328
#else
329 330 331 332
static inline int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity)
{
	return -1;
}
333
#endif
L
Linus Torvalds 已提交
334 335 336 337 338 339 340 341 342 343
/*
 * This function undoes the effect of one call to acpi_register_gsi().
 * If this matches the last registration, any IRQ resources for gsi
 * are freed.
 */
void acpi_unregister_gsi (u32 gsi);

struct pci_dev;

int acpi_pci_irq_enable (struct pci_dev *dev);
D
David Shaohua Li 已提交
344
void acpi_penalize_isa_irq(int irq, int active);
345
bool acpi_isa_irq_available(int irq);
346
void acpi_penalize_sci_irq(int irq, int trigger, int polarity);
L
Linus Torvalds 已提交
347 348 349 350
void acpi_pci_irq_disable (struct pci_dev *dev);

extern int ec_read(u8 addr, u8 *val);
extern int ec_write(u8 addr, u8 val);
351 352
extern int ec_transaction(u8 command,
                          const u8 *wdata, unsigned wdata_len,
T
Thomas Renninger 已提交
353
                          u8 *rdata, unsigned rdata_len);
S
Seth Forshee 已提交
354
extern acpi_handle ec_get_handle(void);
L
Linus Torvalds 已提交
355

356 357
extern bool acpi_is_pnp_device(struct acpi_device *);

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
#if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)

typedef void (*wmi_notify_handler) (u32 value, void *context);

extern acpi_status wmi_evaluate_method(const char *guid, u8 instance,
					u32 method_id,
					const struct acpi_buffer *in,
					struct acpi_buffer *out);
extern acpi_status wmi_query_block(const char *guid, u8 instance,
					struct acpi_buffer *out);
extern acpi_status wmi_set_block(const char *guid, u8 instance,
					const struct acpi_buffer *in);
extern acpi_status wmi_install_notify_handler(const char *guid,
					wmi_notify_handler handler, void *data);
extern acpi_status wmi_remove_notify_handler(const char *guid);
extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out);
extern bool wmi_has_guid(const char *guid);

#endif	/* CONFIG_ACPI_WMI */

378 379 380 381 382 383 384 385 386 387 388 389 390
#define ACPI_VIDEO_OUTPUT_SWITCHING			0x0001
#define ACPI_VIDEO_DEVICE_POSTING			0x0002
#define ACPI_VIDEO_ROM_AVAILABLE			0x0004
#define ACPI_VIDEO_BACKLIGHT				0x0008
#define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR		0x0010
#define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO		0x0020
#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR	0x0040
#define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO		0x0080
#define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR			0x0100
#define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO			0x0200
#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR		0x0400
#define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO		0x0800

391
extern char acpi_video_backlight_string[];
392
extern long acpi_is_video_device(acpi_handle handle);
L
Linus Torvalds 已提交
393
extern int acpi_blacklisted(void);
L
Lin Ming 已提交
394
extern void acpi_osi_setup(char *str);
395
extern bool acpi_osi_is_win8(void);
L
Linus Torvalds 已提交
396 397

#ifdef CONFIG_ACPI_NUMA
398
int acpi_map_pxm_to_online_node(int pxm);
399
int acpi_get_node(acpi_handle handle);
L
Linus Torvalds 已提交
400
#else
401 402 403 404
static inline int acpi_map_pxm_to_online_node(int pxm)
{
	return 0;
}
405
static inline int acpi_get_node(acpi_handle handle)
406 407 408
{
	return 0;
}
L
Linus Torvalds 已提交
409
#endif
410
extern int acpi_paddr_to_node(u64 start_addr, u64 size);
L
Linus Torvalds 已提交
411 412 413

extern int pnpacpi_disabled;

414 415
#define PXM_INVAL	(-1)

416 417 418
bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res);
bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res);
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 425 426
bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
				 struct resource *res);

427 428 429 430
void acpi_dev_free_resource_list(struct list_head *list);
int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
			   int (*preproc)(struct acpi_resource *, void *),
			   void *preproc_data);
431 432
int acpi_dev_get_dma_resources(struct acpi_device *adev,
			       struct list_head *list);
433 434 435 436 437 438 439 440
int acpi_dev_filter_resource_type(struct acpi_resource *ares,
				  unsigned long types);

static inline int acpi_dev_filter_resource_type_cb(struct acpi_resource *ares,
						   void *arg)
{
	return acpi_dev_filter_resource_type(ares, (unsigned long)arg);
}
441

442 443
struct acpi_device *acpi_resource_consumer(struct resource *res);

444
int acpi_check_resource_conflict(const struct resource *res);
445

446 447 448
int acpi_check_region(resource_size_t start, resource_size_t n,
		      const char *name);

449 450 451
acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
				u32 level);

452 453
int acpi_resources_are_enforced(void);

454
#ifdef CONFIG_HIBERNATION
455
void __init acpi_no_s4_hw_signature(void);
456 457 458
#endif

#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

S
Shaohua Li 已提交
465
struct acpi_osc_context {
466
	char *uuid_str;			/* UUID string */
S
Shaohua Li 已提交
467
	int rev;
468 469
	struct acpi_buffer cap;		/* list of DWORD capabilities */
	struct acpi_buffer ret;		/* free by caller if success */
S
Shaohua Li 已提交
470 471 472 473
};

acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);

474 475 476 477
/* Indexes into _OSC Capabilities Buffer (DWORDs 2 & 3 are device-specific) */
#define OSC_QUERY_DWORD				0	/* DWORD 1 */
#define OSC_SUPPORT_DWORD			1	/* DWORD 2 */
#define OSC_CONTROL_DWORD			2	/* DWORD 3 */
478

479 480 481 482 483 484
/* _OSC Capabilities DWORD 1: Query/Control and Error Returns (generic) */
#define OSC_QUERY_ENABLE			0x00000001  /* input */
#define OSC_REQUEST_ERROR			0x00000002  /* return */
#define OSC_INVALID_UUID_ERROR			0x00000004  /* return */
#define OSC_INVALID_REVISION_ERROR		0x00000008  /* return */
#define OSC_CAPABILITIES_MASK_ERROR		0x00000010  /* return */
485

486 487 488 489 490 491 492
/* Platform-Wide Capabilities _OSC: Capabilities DWORD 2: Support Field */
#define OSC_SB_PAD_SUPPORT			0x00000001
#define OSC_SB_PPC_OST_SUPPORT			0x00000002
#define OSC_SB_PR3_SUPPORT			0x00000004
#define OSC_SB_HOTPLUG_OST_SUPPORT		0x00000008
#define OSC_SB_APEI_SUPPORT			0x00000010
#define OSC_SB_CPC_SUPPORT			0x00000020
493 494 495
#define OSC_SB_CPCV2_SUPPORT			0x00000040
#define OSC_SB_PCLPI_SUPPORT			0x00000080
#define OSC_SB_OSLPI_SUPPORT			0x00000100
496
#define OSC_SB_CPC_DIVERSE_HIGH_SUPPORT		0x00001000
S
Shaohua Li 已提交
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 503 504
#define OSC_PCI_EXT_CONFIG_SUPPORT		0x00000001
#define OSC_PCI_ASPM_SUPPORT			0x00000002
#define OSC_PCI_CLOCK_PM_SUPPORT		0x00000004
505
#define OSC_PCI_SEGMENT_GROUPS_SUPPORT		0x00000008
506
#define OSC_PCI_MSI_SUPPORT			0x00000010
507 508 509 510
#define OSC_PCI_SUPPORT_MASKS			0x0000001f

/* PCI Host Bridge _OSC: Capabilities DWORD 3: Control Field */
#define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL	0x00000001
511
#define OSC_PCI_SHPC_NATIVE_HP_CONTROL		0x00000002
512 513
#define OSC_PCI_EXPRESS_PME_CONTROL		0x00000004
#define OSC_PCI_EXPRESS_AER_CONTROL		0x00000008
514
#define OSC_PCI_EXPRESS_CAPABILITY_CONTROL	0x00000010
515 516
#define OSC_PCI_EXPRESS_LTR_CONTROL		0x00000020
#define OSC_PCI_CONTROL_MASKS			0x0000003f
517

518 519 520 521 522 523 524 525 526 527 528
#define ACPI_GSB_ACCESS_ATTRIB_QUICK		0x00000002
#define ACPI_GSB_ACCESS_ATTRIB_SEND_RCV         0x00000004
#define ACPI_GSB_ACCESS_ATTRIB_BYTE		0x00000006
#define ACPI_GSB_ACCESS_ATTRIB_WORD		0x00000008
#define ACPI_GSB_ACCESS_ATTRIB_BLOCK		0x0000000A
#define ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE	0x0000000B
#define ACPI_GSB_ACCESS_ATTRIB_WORD_CALL	0x0000000C
#define ACPI_GSB_ACCESS_ATTRIB_BLOCK_CALL	0x0000000D
#define ACPI_GSB_ACCESS_ATTRIB_RAW_BYTES	0x0000000E
#define ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS	0x0000000F

529 530
extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
					     u32 *mask, u32 req);
531 532 533

/* Enable _OST when all relevant hotplug operations are enabled */
#if defined(CONFIG_ACPI_HOTPLUG_CPU) &&			\
534
	defined(CONFIG_ACPI_HOTPLUG_MEMORY) &&		\
535
	defined(CONFIG_ACPI_CONTAINER)
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
#define ACPI_HOTPLUG_OST
#endif

/* _OST Source Event Code (OSPM Action) */
#define ACPI_OST_EC_OSPM_SHUTDOWN		0x100
#define ACPI_OST_EC_OSPM_EJECT			0x103
#define ACPI_OST_EC_OSPM_INSERTION		0x200

/* _OST General Processing Status Code */
#define ACPI_OST_SC_SUCCESS			0x0
#define ACPI_OST_SC_NON_SPECIFIC_FAILURE	0x1
#define ACPI_OST_SC_UNRECOGNIZED_NOTIFY		0x2

/* _OST OS Shutdown Processing (0x100) Status Code */
#define ACPI_OST_SC_OS_SHUTDOWN_DENIED		0x80
#define ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS	0x81
#define ACPI_OST_SC_OS_SHUTDOWN_COMPLETED	0x82
#define ACPI_OST_SC_OS_SHUTDOWN_NOT_SUPPORTED	0x83

/* _OST Ejection Request (0x3, 0x103) Status Code */
#define ACPI_OST_SC_EJECT_NOT_SUPPORTED		0x80
#define ACPI_OST_SC_DEVICE_IN_USE		0x81
#define ACPI_OST_SC_DEVICE_BUSY			0x82
#define ACPI_OST_SC_EJECT_DEPENDENCY_BUSY	0x83
#define ACPI_OST_SC_EJECT_IN_PROGRESS		0x84

/* _OST Insertion Request (0x200) Status Code */
#define ACPI_OST_SC_INSERT_IN_PROGRESS		0x80
#define ACPI_OST_SC_DRIVER_LOAD_FAILURE		0x81
#define ACPI_OST_SC_INSERT_NOT_SUPPORTED	0x82

567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
enum acpi_predicate {
	all_versions,
	less_than_or_equal,
	equal,
	greater_than_or_equal,
};

/* Table must be terminted by a NULL entry */
struct acpi_platform_list {
	char	oem_id[ACPI_OEM_ID_SIZE+1];
	char	oem_table_id[ACPI_OEM_TABLE_ID_SIZE+1];
	u32	oem_revision;
	char	*table;
	enum acpi_predicate pred;
	char	*reason;
	u32	data;
};
int acpi_match_platform_list(const struct acpi_platform_list *plat);

586
extern void acpi_early_init(void);
587
extern void acpi_subsystem_init(void);
588
extern void arch_post_acpi_subsys_init(void);
589

H
Huang Ying 已提交
590 591 592 593 594
extern int acpi_nvs_register(__u64 start, __u64 size);

extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
				    void *data);

595 596 597
const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
					       const struct device *dev);

598
const void *acpi_device_get_match_data(const struct device *dev);
599 600
extern bool acpi_driver_match_device(struct device *dev,
				     const struct device_driver *drv);
601 602
int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
int acpi_device_modalias(struct device *, char *, int);
603
void acpi_walk_dep_device_list(acpi_handle handle);
604

605 606
struct platform_device *acpi_create_platform_device(struct acpi_device *,
						    struct property_entry *);
607 608
#define ACPI_PTR(_ptr)	(_ptr)

609 610 611 612 613 614 615 616 617 618
static inline void acpi_device_set_enumerated(struct acpi_device *adev)
{
	adev->flags.visited = true;
}

static inline void acpi_device_clear_enumerated(struct acpi_device *adev)
{
	adev->flags.visited = false;
}

619 620 621 622 623 624 625 626
enum acpi_reconfig_event  {
	ACPI_RECONFIG_DEVICE_ADD = 0,
	ACPI_RECONFIG_DEVICE_REMOVE,
};

int acpi_reconfig_notifier_register(struct notifier_block *nb);
int acpi_reconfig_notifier_unregister(struct notifier_block *nb);

F
Fu Wei 已提交
627 628 629 630
#ifdef CONFIG_ACPI_GTDT
int acpi_gtdt_init(struct acpi_table_header *table, int *platform_timer_count);
int acpi_gtdt_map_ppi(int type);
bool acpi_gtdt_c3stop(int type);
631
int acpi_arch_timer_mem_init(struct arch_timer_mem *timer_mem, int *timer_count);
F
Fu Wei 已提交
632 633
#endif

634 635 636 637 638 639 640
#ifndef ACPI_HAVE_ARCH_GET_ROOT_POINTER
static inline u64 acpi_arch_get_root_pointer(void)
{
	return 0;
}
#endif

641 642 643 644
#else	/* !CONFIG_ACPI */

#define acpi_disabled 1

645 646 647
#define ACPI_COMPANION(dev)		(NULL)
#define ACPI_COMPANION_SET(dev, adev)	do { } while (0)
#define ACPI_HANDLE(dev)		(NULL)
648
#define ACPI_HANDLE_FWNODE(fwnode)	(NULL)
649
#define ACPI_DEVICE_CLASS(_cls, _msk)	.cls = (0), .cls_msk = (0),
650

651 652
struct fwnode_handle;

653 654 655 656 657
static inline bool acpi_dev_found(const char *hid)
{
	return false;
}

658 659 660 661 662
static inline bool acpi_dev_present(const char *hid, const char *uid, s64 hrv)
{
	return false;
}

663 664 665 666 667 668
static inline const char *
acpi_dev_get_first_match_name(const char *hid, const char *uid, s64 hrv)
{
	return NULL;
}

669 670 671 672 673
static inline bool is_acpi_node(struct fwnode_handle *fwnode)
{
	return false;
}

674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
static inline bool is_acpi_device_node(struct fwnode_handle *fwnode)
{
	return false;
}

static inline struct acpi_device *to_acpi_device_node(struct fwnode_handle *fwnode)
{
	return NULL;
}

static inline bool is_acpi_data_node(struct fwnode_handle *fwnode)
{
	return false;
}

static inline struct acpi_data_node *to_acpi_data_node(struct fwnode_handle *fwnode)
690 691 692 693
{
	return NULL;
}

694 695 696 697 698 699
static inline bool acpi_data_node_match(struct fwnode_handle *fwnode,
					const char *name)
{
	return false;
}

700 701 702 703 704
static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
{
	return NULL;
}

705 706 707 708 709
static inline bool has_acpi_companion(struct device *dev)
{
	return false;
}

710 711 712 713 714
static inline void acpi_preset_companion(struct device *dev,
					 struct acpi_device *parent, u64 addr)
{
}

715 716 717 718 719
static inline const char *acpi_dev_name(struct acpi_device *adev)
{
	return NULL;
}

720 721 722 723 724
static inline struct device *acpi_get_first_physical_node(struct acpi_device *adev)
{
	return NULL;
}

725
static inline void acpi_early_init(void) { }
726
static inline void acpi_subsystem_init(void) { }
A
Andrew Morton 已提交
727

728 729 730 731
static inline int early_acpi_boot_init(void)
{
	return 0;
}
A
Andrew Morton 已提交
732 733 734 735 736
static inline int acpi_boot_init(void)
{
	return 0;
}

737
static inline void acpi_boot_table_init(void)
A
Andrew Morton 已提交
738
{
739
	return;
A
Andrew Morton 已提交
740 741
}

742 743 744 745 746
static inline int acpi_mps_check(void)
{
	return 0;
}

747 748 749 750 751
static inline int acpi_check_resource_conflict(struct resource *res)
{
	return 0;
}

752 753 754 755 756 757
static inline int acpi_check_region(resource_size_t start, resource_size_t n,
				    const char *name)
{
	return 0;
}

758 759 760 761
struct acpi_table_header;
static inline int acpi_table_parse(char *id,
				int (*handler)(struct acpi_table_header *))
{
762
	return -ENODEV;
763
}
764

H
Huang Ying 已提交
765
static inline int acpi_nvs_register(__u64 start, __u64 size)
766 767 768
{
	return 0;
}
H
Huang Ying 已提交
769 770 771 772 773 774 775

static inline int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
					   void *data)
{
	return 0;
}

776 777 778 779
struct acpi_device_id;

static inline const struct acpi_device_id *acpi_match_device(
	const struct acpi_device_id *ids, const struct device *dev)
780 781 782 783
{
	return NULL;
}

784
static inline const void *acpi_device_get_match_data(const struct device *dev)
785 786 787 788 789 790 791 792 793 794
{
	return NULL;
}

static inline bool acpi_driver_match_device(struct device *dev,
					    const struct device_driver *drv)
{
	return false;
}

795
static inline union acpi_object *acpi_evaluate_dsm(acpi_handle handle,
796
						   const guid_t *guid,
797 798 799 800 801 802
						   int rev, int func,
						   union acpi_object *argv4)
{
	return NULL;
}

803 804 805 806 807 808 809 810 811 812 813 814
static inline int acpi_device_uevent_modalias(struct device *dev,
				struct kobj_uevent_env *env)
{
	return -ENODEV;
}

static inline int acpi_device_modalias(struct device *dev,
				char *buf, int size)
{
	return -ENODEV;
}

815
static inline bool acpi_dma_supported(struct acpi_device *adev)
816 817 818 819
{
	return false;
}

820 821 822 823 824
static inline enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
{
	return DEV_DMA_NOT_SUPPORTED;
}

825 826 827 828 829 830
static inline int acpi_dma_get_range(struct device *dev, u64 *dma_addr,
				     u64 *offset, u64 *size)
{
	return -ENODEV;
}

831 832 833 834 835
static inline int acpi_dma_configure(struct device *dev,
				     enum dev_dma_attr attr)
{
	return 0;
}
836 837 838

static inline void acpi_dma_deconfigure(struct device *dev) { }

839 840
#define ACPI_PTR(_ptr)	(NULL)

841 842 843 844 845 846 847 848
static inline void acpi_device_set_enumerated(struct acpi_device *adev)
{
}

static inline void acpi_device_clear_enumerated(struct acpi_device *adev)
{
}

849 850 851 852 853 854 855 856 857 858
static inline int acpi_reconfig_notifier_register(struct notifier_block *nb)
{
	return -EINVAL;
}

static inline int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
{
	return -EINVAL;
}

859 860 861 862 863
static inline struct acpi_device *acpi_resource_consumer(struct resource *res)
{
	return NULL;
}

H
Huang Ying 已提交
864
#endif	/* !CONFIG_ACPI */
865

866 867 868 869 870 871
#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
int acpi_ioapic_add(acpi_handle root);
#else
static inline int acpi_ioapic_add(acpi_handle root) { return 0; }
#endif

872 873 874 875 876 877
#ifdef CONFIG_ACPI
void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
			       u32 pm1a_ctrl,  u32 pm1b_ctrl));

acpi_status acpi_os_prepare_sleep(u8 sleep_state,
				  u32 pm1a_control, u32 pm1b_control);
878 879 880 881 882 883 884

void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
				        u32 val_a,  u32 val_b));

acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state,
					   u32 val_a, u32 val_b);

885
#ifdef CONFIG_X86
886 887 888 889 890 891 892
void arch_reserve_mem_area(acpi_physical_address addr, size_t size);
#else
static inline void arch_reserve_mem_area(acpi_physical_address addr,
					  size_t size)
{
}
#endif /* CONFIG_X86 */
893 894 895 896
#else
#define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0)
#endif

897
#if defined(CONFIG_ACPI) && defined(CONFIG_PM)
898
int acpi_dev_suspend(struct device *dev, bool wakeup);
899
int acpi_dev_resume(struct device *dev);
900 901
int acpi_subsys_runtime_suspend(struct device *dev);
int acpi_subsys_runtime_resume(struct device *dev);
902
int acpi_dev_pm_attach(struct device *dev, bool power_on);
903 904 905 906 907
#else
static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; }
static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; }
static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }
static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }
908 909
static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
{
910
	return 0;
911
}
912 913
#endif

914
#if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)
915 916
int acpi_dev_suspend_late(struct device *dev);
int acpi_subsys_prepare(struct device *dev);
917
void acpi_subsys_complete(struct device *dev);
918
int acpi_subsys_suspend_late(struct device *dev);
919 920
int acpi_subsys_suspend_noirq(struct device *dev);
int acpi_subsys_resume_noirq(struct device *dev);
921
int acpi_subsys_resume_early(struct device *dev);
922 923
int acpi_subsys_suspend(struct device *dev);
int acpi_subsys_freeze(struct device *dev);
924 925 926
int acpi_subsys_freeze_late(struct device *dev);
int acpi_subsys_freeze_noirq(struct device *dev);
int acpi_subsys_thaw_noirq(struct device *dev);
927 928 929
#else
static inline int acpi_dev_resume_early(struct device *dev) { return 0; }
static inline int acpi_subsys_prepare(struct device *dev) { return 0; }
930
static inline void acpi_subsys_complete(struct device *dev) {}
931
static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; }
932 933
static inline int acpi_subsys_suspend_noirq(struct device *dev) { return 0; }
static inline int acpi_subsys_resume_noirq(struct device *dev) { return 0; }
934
static inline int acpi_subsys_resume_early(struct device *dev) { return 0; }
935 936
static inline int acpi_subsys_suspend(struct device *dev) { return 0; }
static inline int acpi_subsys_freeze(struct device *dev) { return 0; }
937 938 939
static inline int acpi_subsys_freeze_late(struct device *dev) { return 0; }
static inline int acpi_subsys_freeze_noirq(struct device *dev) { return 0; }
static inline int acpi_subsys_thaw_noirq(struct device *dev) { return 0; }
940 941
#endif

942 943 944 945 946 947 948 949 950
#ifdef CONFIG_ACPI
__printf(3, 4)
void acpi_handle_printk(const char *level, acpi_handle handle,
			const char *fmt, ...);
#else	/* !CONFIG_ACPI */
static inline __printf(3, 4) void
acpi_handle_printk(const char *level, void *handle, const char *fmt, ...) {}
#endif	/* !CONFIG_ACPI */

B
Bjørn Mork 已提交
951 952 953 954 955 956 957 958
#if defined(CONFIG_ACPI) && defined(CONFIG_DYNAMIC_DEBUG)
__printf(3, 4)
void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...);
#else
#define __acpi_handle_debug(descriptor, handle, fmt, ...)		\
	acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__);
#endif

959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
/*
 * acpi_handle_<level>: Print message with ACPI prefix and object path
 *
 * These interfaces acquire the global namespace mutex to obtain an object
 * path.  In interrupt context, it shows the object path as <n/a>.
 */
#define acpi_handle_emerg(handle, fmt, ...)				\
	acpi_handle_printk(KERN_EMERG, handle, fmt, ##__VA_ARGS__)
#define acpi_handle_alert(handle, fmt, ...)				\
	acpi_handle_printk(KERN_ALERT, handle, fmt, ##__VA_ARGS__)
#define acpi_handle_crit(handle, fmt, ...)				\
	acpi_handle_printk(KERN_CRIT, handle, fmt, ##__VA_ARGS__)
#define acpi_handle_err(handle, fmt, ...)				\
	acpi_handle_printk(KERN_ERR, handle, fmt, ##__VA_ARGS__)
#define acpi_handle_warn(handle, fmt, ...)				\
	acpi_handle_printk(KERN_WARNING, handle, fmt, ##__VA_ARGS__)
#define acpi_handle_notice(handle, fmt, ...)				\
	acpi_handle_printk(KERN_NOTICE, handle, fmt, ##__VA_ARGS__)
#define acpi_handle_info(handle, fmt, ...)				\
	acpi_handle_printk(KERN_INFO, handle, fmt, ##__VA_ARGS__)

B
Bjørn Mork 已提交
980
#if defined(DEBUG)
981 982 983
#define acpi_handle_debug(handle, fmt, ...)				\
	acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__)
#else
B
Bjørn Mork 已提交
984 985 986 987 988 989 990 991 992
#if defined(CONFIG_DYNAMIC_DEBUG)
#define acpi_handle_debug(handle, fmt, ...)				\
do {									\
	DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);			\
	if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))		\
		__acpi_handle_debug(&descriptor, handle, pr_fmt(fmt),	\
				##__VA_ARGS__);				\
} while (0)
#else
993 994 995 996 997 998 999
#define acpi_handle_debug(handle, fmt, ...)				\
({									\
	if (0)								\
		acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__); \
	0;								\
})
#endif
B
Bjørn Mork 已提交
1000
#endif
1001

1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
struct acpi_gpio_params {
	unsigned int crs_entry_index;
	unsigned int line_index;
	bool active_low;
};

struct acpi_gpio_mapping {
	const char *name;
	const struct acpi_gpio_params *data;
	unsigned int size;
1012 1013 1014 1015

/* Ignore IoRestriction field */
#define ACPI_GPIO_QUIRK_NO_IO_RESTRICTION	BIT(0)

1016
	unsigned int quirks;
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
};

#if defined(CONFIG_ACPI) && defined(CONFIG_GPIOLIB)
int acpi_dev_add_driver_gpios(struct acpi_device *adev,
			      const struct acpi_gpio_mapping *gpios);

static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev)
{
	if (adev)
		adev->driver_gpios = NULL;
}
1028

1029 1030 1031 1032
int devm_acpi_dev_add_driver_gpios(struct device *dev,
				   const struct acpi_gpio_mapping *gpios);
void devm_acpi_dev_remove_driver_gpios(struct device *dev);

1033 1034
bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
				struct acpi_resource_gpio **agpio);
1035
int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index);
1036 1037 1038 1039 1040 1041 1042
#else
static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
			      const struct acpi_gpio_mapping *gpios)
{
	return -ENXIO;
}
static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
1043

1044 1045 1046 1047 1048 1049 1050
static inline int devm_acpi_dev_add_driver_gpios(struct device *dev,
			      const struct acpi_gpio_mapping *gpios)
{
	return -ENXIO;
}
static inline void devm_acpi_dev_remove_driver_gpios(struct device *dev) {}

1051 1052 1053 1054 1055
static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
					      struct acpi_resource_gpio **agpio)
{
	return false;
}
1056 1057 1058 1059
static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
{
	return -ENXIO;
}
1060 1061
#endif

1062 1063 1064
/* Device properties */

#ifdef CONFIG_ACPI
1065
int acpi_dev_get_property(const struct acpi_device *adev, const char *name,
1066
			  acpi_object_type type, const union acpi_object **obj);
1067
int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
1068
				const char *name, size_t index, size_t num_args,
1069
				struct fwnode_reference_args *args);
1070

1071 1072
static inline int acpi_node_get_property_reference(
				const struct fwnode_handle *fwnode,
1073
				const char *name, size_t index,
1074
				struct fwnode_reference_args *args)
1075 1076
{
	return __acpi_node_get_property_reference(fwnode, name, index,
1077
		NR_FWNODE_REFERENCE_ARGS, args);
1078
}
1079

1080
int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname,
1081
		       void **valptr);
1082 1083 1084 1085 1086 1087 1088
int acpi_dev_prop_read_single(struct acpi_device *adev,
			      const char *propname, enum dev_prop_type proptype,
			      void *val);
int acpi_node_prop_read(const struct fwnode_handle *fwnode,
			const char *propname, enum dev_prop_type proptype,
			void *val, size_t nval);
int acpi_dev_prop_read(const struct acpi_device *adev, const char *propname,
1089
		       enum dev_prop_type proptype, void *val, size_t nval);
1090

1091
struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
1092
					    struct fwnode_handle *child);
1093
struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode);
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148

struct acpi_probe_entry;
typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *,
						 struct acpi_probe_entry *);

#define ACPI_TABLE_ID_LEN	5

/**
 * struct acpi_probe_entry - boot-time probing entry
 * @id:			ACPI table name
 * @type:		Optional subtable type to match
 *			(if @id contains subtables)
 * @subtable_valid:	Optional callback to check the validity of
 *			the subtable
 * @probe_table:	Callback to the driver being probed when table
 *			match is successful
 * @probe_subtbl:	Callback to the driver being probed when table and
 *			subtable match (and optional callback is successful)
 * @driver_data:	Sideband data provided back to the driver
 */
struct acpi_probe_entry {
	__u8 id[ACPI_TABLE_ID_LEN];
	__u8 type;
	acpi_probe_entry_validate_subtbl subtable_valid;
	union {
		acpi_tbl_table_handler probe_table;
		acpi_tbl_entry_handler probe_subtbl;
	};
	kernel_ulong_t driver_data;
};

#define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, valid, data, fn)	\
	static const struct acpi_probe_entry __acpi_probe_##name	\
		__used __section(__##table##_acpi_probe_table)		\
		 = {							\
			.id = table_id,					\
			.type = subtable,				\
			.subtable_valid = valid,			\
			.probe_table = (acpi_tbl_table_handler)fn,	\
			.driver_data = data, 				\
		   }

#define ACPI_PROBE_TABLE(name)		__##name##_acpi_probe_table
#define ACPI_PROBE_TABLE_END(name)	__##name##_acpi_probe_table_end

int __acpi_probe_device_table(struct acpi_probe_entry *start, int nr);

#define acpi_probe_device_table(t)					\
	({ 								\
		extern struct acpi_probe_entry ACPI_PROBE_TABLE(t),	\
			                       ACPI_PROBE_TABLE_END(t);	\
		__acpi_probe_device_table(&ACPI_PROBE_TABLE(t),		\
					  (&ACPI_PROBE_TABLE_END(t) -	\
					   &ACPI_PROBE_TABLE(t)));	\
	})
1149 1150 1151 1152 1153 1154 1155
#else
static inline int acpi_dev_get_property(struct acpi_device *adev,
					const char *name, acpi_object_type type,
					const union acpi_object **obj)
{
	return -ENXIO;
}
1156

1157
static inline int
1158
__acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
1159
				const char *name, size_t index, size_t num_args,
1160
				struct fwnode_reference_args *args)
1161 1162 1163 1164
{
	return -ENXIO;
}

1165 1166 1167
static inline int
acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
				 const char *name, size_t index,
1168
				 struct fwnode_reference_args *args)
1169 1170 1171
{
	return -ENXIO;
}
1172

1173
static inline int acpi_node_prop_get(const struct fwnode_handle *fwnode,
1174 1175
				     const char *propname,
				     void **valptr)
1176 1177 1178
{
	return -ENXIO;
}
1179

1180
static inline int acpi_dev_prop_get(const struct acpi_device *adev,
1181 1182 1183 1184 1185 1186
				    const char *propname,
				    void **valptr)
{
	return -ENXIO;
}

1187
static inline int acpi_dev_prop_read_single(const struct acpi_device *adev,
1188 1189 1190 1191 1192 1193 1194
					    const char *propname,
					    enum dev_prop_type proptype,
					    void *val)
{
	return -ENXIO;
}

1195
static inline int acpi_node_prop_read(const struct fwnode_handle *fwnode,
1196 1197 1198 1199 1200 1201 1202
				      const char *propname,
				      enum dev_prop_type proptype,
				      void *val, size_t nval)
{
	return -ENXIO;
}

1203
static inline int acpi_dev_prop_read(const struct acpi_device *adev,
1204 1205 1206 1207 1208 1209 1210
				     const char *propname,
				     enum dev_prop_type proptype,
				     void *val, size_t nval)
{
	return -ENXIO;
}

1211
static inline struct fwnode_handle *
1212 1213
acpi_get_next_subnode(const struct fwnode_handle *fwnode,
		      struct fwnode_handle *child)
1214 1215 1216 1217
{
	return NULL;
}

1218
static inline struct fwnode_handle *
1219
acpi_node_get_parent(const struct fwnode_handle *fwnode)
1220 1221 1222 1223
{
	return NULL;
}

1224
static inline struct fwnode_handle *
1225
acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1226 1227 1228 1229 1230 1231
			     struct fwnode_handle *prev)
{
	return ERR_PTR(-ENXIO);
}

static inline int
1232
acpi_graph_get_remote_endpoint(const struct fwnode_handle *fwnode,
1233 1234 1235 1236 1237 1238 1239
			       struct fwnode_handle **remote,
			       struct fwnode_handle **port,
			       struct fwnode_handle **endpoint)
{
	return -ENXIO;
}

1240
#define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, valid, data, fn) \
1241 1242 1243 1244 1245 1246 1247 1248 1249
	static const void * __acpi_table_##name[]			\
		__attribute__((unused))					\
		 = { (void *) table_id,					\
		     (void *) subtable,					\
		     (void *) valid,					\
		     (void *) fn,					\
		     (void *) data }

#define acpi_probe_device_table(t)	({ int __r = 0; __r;})
1250 1251
#endif

1252 1253 1254 1255 1256 1257
#ifdef CONFIG_ACPI_TABLE_UPGRADE
void acpi_table_upgrade(void);
#else
static inline void acpi_table_upgrade(void) { }
#endif

1258 1259 1260 1261 1262 1263
#if defined(CONFIG_ACPI) && defined(CONFIG_ACPI_WATCHDOG)
extern bool acpi_has_watchdog(void);
#else
static inline bool acpi_has_watchdog(void) { return false; }
#endif

1264
#ifdef CONFIG_ACPI_SPCR_TABLE
1265
extern bool qdf2400_e44_present;
1266
int acpi_parse_spcr(bool enable_earlycon, bool enable_console);
1267
#else
1268 1269 1270 1271
static inline int acpi_parse_spcr(bool enable_earlycon, bool enable_console)
{
	return 0;
}
1272 1273
#endif

1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
#if IS_ENABLED(CONFIG_ACPI_GENERIC_GSI)
int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res);
#else
static inline
int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
{
	return -EINVAL;
}
#endif

1284 1285 1286 1287 1288 1289 1290 1291 1292
#ifdef CONFIG_ACPI_LPIT
int lpit_read_residency_count_address(u64 *address);
#else
static inline int lpit_read_residency_count_address(u64 *address)
{
	return -EINVAL;
}
#endif

1293
#ifdef CONFIG_ACPI_PPTT
1294 1295 1296
int find_acpi_cpu_topology(unsigned int cpu, int level);
int find_acpi_cpu_topology_package(unsigned int cpu);
int find_acpi_cpu_cache_topology(unsigned int cpu, int level);
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
#else
static inline int find_acpi_cpu_topology(unsigned int cpu, int level)
{
	return -EINVAL;
}
static inline int find_acpi_cpu_topology_package(unsigned int cpu)
{
	return -EINVAL;
}
static inline int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
{
	return -EINVAL;
}
#endif
1311

L
Len Brown 已提交
1312
#endif	/*_LINUX_ACPI_H*/