acpi.h 24.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 24 25 26 27
/*
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#ifndef _LINUX_ACPI_H
#define _LINUX_ACPI_H

28
#include <linux/errno.h>
29
#include <linux/ioport.h>	/* for struct resource */
30
#include <linux/resource_ext.h>
31
#include <linux/device.h>
32
#include <linux/property.h>
33

L
Linus Torvalds 已提交
34 35 36
#ifndef _LINUX
#define _LINUX
#endif
37 38 39
#include <acpi/acpi.h>

#ifdef	CONFIG_ACPI
L
Linus Torvalds 已提交
40 41

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

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

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

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

61 62 63 64 65
static inline bool has_acpi_companion(struct device *dev)
{
	return is_acpi_node(dev->fwnode);
}

66 67 68 69 70 71
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));
}

72 73 74 75 76
static inline const char *acpi_dev_name(struct acpi_device *adev)
{
	return dev_name(&adev->dev);
}

L
Linus Torvalds 已提交
77 78 79 80
enum acpi_irq_model_id {
	ACPI_IRQ_MODEL_PIC = 0,
	ACPI_IRQ_MODEL_IOAPIC,
	ACPI_IRQ_MODEL_IOSAPIC,
J
John Keller 已提交
81
	ACPI_IRQ_MODEL_PLATFORM,
82
	ACPI_IRQ_MODEL_GIC,
L
Linus Torvalds 已提交
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
	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 */

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

110 111
typedef int (*acpi_tbl_entry_handler)(struct acpi_subtable_header *header,
				      const unsigned long end);
L
Linus Torvalds 已提交
112

113 114 115 116 117 118 119 120
#ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
void acpi_initrd_override(void *data, size_t size);
#else
static inline void acpi_initrd_override(void *data, size_t size)
{
}
#endif

121 122 123 124
#define BAD_MADT_ENTRY(entry, end) (					    \
		(!entry) || (unsigned long)entry + sizeof(*entry) > end ||  \
		((struct acpi_subtable_header *)entry)->length < sizeof(*entry))

L
Linus Torvalds 已提交
125
char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
Y
Yinghai Lu 已提交
126
void __acpi_unmap_table(char *map, unsigned long size);
127
int early_acpi_boot_init(void);
L
Linus Torvalds 已提交
128
int acpi_boot_init (void);
129
void acpi_boot_table_init (void);
130
int acpi_mps_check (void);
L
Linus Torvalds 已提交
131 132 133
int acpi_numa_init (void);

int acpi_table_init (void);
134
int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
135 136 137 138
int __init acpi_parse_entries(char *id, unsigned long table_size,
			      acpi_tbl_entry_handler handler,
			      struct acpi_table_header *table_header,
			      int entry_id, unsigned int max_entries);
139
int __init acpi_table_parse_entries(char *id, unsigned long table_size,
140 141 142 143 144 145
				    int entry_id,
				    acpi_tbl_entry_handler handler,
				    unsigned int max_entries);
int acpi_table_parse_madt(enum acpi_madt_type id,
			  acpi_tbl_entry_handler handler,
			  unsigned int max_entries);
146
int acpi_parse_mcfg (struct acpi_table_header *header);
147
void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
L
Linus Torvalds 已提交
148 149 150

/* the following four functions are architecture-dependent */
void acpi_numa_slit_init (struct acpi_table_slit *slit);
151
void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);
152
void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);
153
int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);
L
Linus Torvalds 已提交
154 155
void acpi_numa_arch_fixup(void);

156 157 158 159 160
#ifndef PHYS_CPUID_INVALID
typedef u32 phys_cpuid_t;
#define PHYS_CPUID_INVALID (phys_cpuid_t)(-1)
#endif

L
Linus Torvalds 已提交
161 162
#ifdef CONFIG_ACPI_HOTPLUG_CPU
/* Arch dependent functions for cpu hotplug support */
163
int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, int *pcpu);
164
int acpi_unmap_cpu(int cpu);
L
Linus Torvalds 已提交
165 166
#endif /* CONFIG_ACPI_HOTPLUG_CPU */

167 168 169 170
#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr);
#endif

171 172
int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
173
int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base);
174 175
void acpi_irq_stats_init(void);
extern u32 acpi_irq_handled;
176
extern u32 acpi_irq_not_handled;
L
Linus Torvalds 已提交
177

178
extern int sbf_port;
179
extern unsigned long acpi_realmode_flags;
L
Linus Torvalds 已提交
180

181
int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
L
Linus Torvalds 已提交
182
int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
183
int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);
L
Linus Torvalds 已提交
184

185
#ifdef CONFIG_X86_IO_APIC
186
extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity);
187
#else
188
#define acpi_get_override_irq(gsi, trigger, polarity) (-1)
189
#endif
L
Linus Torvalds 已提交
190 191 192 193 194 195 196 197 198 199
/*
 * 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 已提交
200
void acpi_penalize_isa_irq(int irq, int active);
L
Linus Torvalds 已提交
201 202 203 204 205

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);
206 207
extern int ec_transaction(u8 command,
                          const u8 *wdata, unsigned wdata_len,
T
Thomas Renninger 已提交
208
                          u8 *rdata, unsigned rdata_len);
S
Seth Forshee 已提交
209
extern acpi_handle ec_get_handle(void);
L
Linus Torvalds 已提交
210

211 212
extern bool acpi_is_pnp_device(struct acpi_device *);

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
#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 */

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
#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

#if defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE)

extern long acpi_video_get_capabilities(acpi_handle graphics_dev_handle);
249
extern long acpi_is_video_device(acpi_handle handle);
250 251
extern void acpi_video_dmi_promote_vendor(void);
extern void acpi_video_dmi_demote_vendor(void);
252 253 254 255 256 257 258 259 260 261
extern int acpi_video_backlight_support(void);
extern int acpi_video_display_switch_support(void);

#else

static inline long acpi_video_get_capabilities(acpi_handle graphics_dev_handle)
{
	return 0;
}

262
static inline long acpi_is_video_device(acpi_handle handle)
263 264 265 266
{
	return 0;
}

267 268 269 270 271 272 273 274
static inline void acpi_video_dmi_promote_vendor(void)
{
}

static inline void acpi_video_dmi_demote_vendor(void)
{
}

275 276 277 278 279 280 281 282 283 284 285 286
static inline int acpi_video_backlight_support(void)
{
	return 0;
}

static inline int acpi_video_display_switch_support(void)
{
	return 0;
}

#endif /* defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE) */

L
Linus Torvalds 已提交
287
extern int acpi_blacklisted(void);
288
extern void acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d);
L
Lin Ming 已提交
289
extern void acpi_osi_setup(char *str);
L
Linus Torvalds 已提交
290 291

#ifdef CONFIG_ACPI_NUMA
292
int acpi_get_node(acpi_handle handle);
L
Linus Torvalds 已提交
293
#else
294
static inline int acpi_get_node(acpi_handle handle)
295 296 297
{
	return 0;
}
L
Linus Torvalds 已提交
298
#endif
299
extern int acpi_paddr_to_node(u64 start_addr, u64 size);
L
Linus Torvalds 已提交
300 301 302

extern int pnpacpi_disabled;

303 304
#define PXM_INVAL	(-1)

305 306 307
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,
308
				     struct resource_win *win);
309
bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
310
					 struct resource_win *win);
311 312 313 314
unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
				 struct resource *res);

315 316 317 318
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);
319 320 321 322 323 324 325 326
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);
}
327

328
int acpi_check_resource_conflict(const struct resource *res);
329

330 331 332
int acpi_check_region(resource_size_t start, resource_size_t n,
		      const char *name);

333 334
int acpi_resources_are_enforced(void);

335
#ifdef CONFIG_HIBERNATION
336
void __init acpi_no_s4_hw_signature(void);
337 338 339
#endif

#ifdef CONFIG_PM_SLEEP
340
void __init acpi_old_suspend_ordering(void);
341
void __init acpi_nvs_nosave(void);
342
void __init acpi_nvs_nosave_s3(void);
343
#endif /* CONFIG_PM_SLEEP */
344

S
Shaohua Li 已提交
345
struct acpi_osc_context {
346
	char *uuid_str;			/* UUID string */
S
Shaohua Li 已提交
347
	int rev;
348 349
	struct acpi_buffer cap;		/* list of DWORD capabilities */
	struct acpi_buffer ret;		/* free by caller if success */
S
Shaohua Li 已提交
350 351
};

352
acpi_status acpi_str_to_uuid(char *str, u8 *uuid);
S
Shaohua Li 已提交
353 354
acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);

355 356 357 358
/* 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 */
359

360 361 362 363 364 365
/* _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 */
366

367 368 369 370 371 372 373
/* 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
S
Shaohua Li 已提交
374

375 376
extern bool osc_sb_apei_support_acked;

377
/* PCI Host Bridge _OSC: Capabilities DWORD 2: Support Field */
378 379 380
#define OSC_PCI_EXT_CONFIG_SUPPORT		0x00000001
#define OSC_PCI_ASPM_SUPPORT			0x00000002
#define OSC_PCI_CLOCK_PM_SUPPORT		0x00000004
381
#define OSC_PCI_SEGMENT_GROUPS_SUPPORT		0x00000008
382
#define OSC_PCI_MSI_SUPPORT			0x00000010
383 384 385 386
#define OSC_PCI_SUPPORT_MASKS			0x0000001f

/* PCI Host Bridge _OSC: Capabilities DWORD 3: Control Field */
#define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL	0x00000001
387
#define OSC_PCI_SHPC_NATIVE_HP_CONTROL		0x00000002
388 389
#define OSC_PCI_EXPRESS_PME_CONTROL		0x00000004
#define OSC_PCI_EXPRESS_AER_CONTROL		0x00000008
390
#define OSC_PCI_EXPRESS_CAPABILITY_CONTROL	0x00000010
391
#define OSC_PCI_CONTROL_MASKS			0x0000001f
392

393 394 395 396 397 398 399 400 401 402 403
#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

404 405
extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
					     u32 *mask, u32 req);
406 407 408

/* Enable _OST when all relevant hotplug operations are enabled */
#if defined(CONFIG_ACPI_HOTPLUG_CPU) &&			\
409
	defined(CONFIG_ACPI_HOTPLUG_MEMORY) &&		\
410
	defined(CONFIG_ACPI_CONTAINER)
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
#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

442 443
extern void acpi_early_init(void);

H
Huang Ying 已提交
444 445 446 447 448
extern int acpi_nvs_register(__u64 start, __u64 size);

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

449 450 451
const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
					       const struct device *dev);

452 453
extern bool acpi_driver_match_device(struct device *dev,
				     const struct device_driver *drv);
454 455
int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
int acpi_device_modalias(struct device *, char *, int);
456
void acpi_walk_dep_device_list(acpi_handle handle);
457

458
struct platform_device *acpi_create_platform_device(struct acpi_device *);
459 460
#define ACPI_PTR(_ptr)	(_ptr)

461 462 463 464
#else	/* !CONFIG_ACPI */

#define acpi_disabled 1

465 466 467 468
#define ACPI_COMPANION(dev)		(NULL)
#define ACPI_COMPANION_SET(dev, adev)	do { } while (0)
#define ACPI_HANDLE(dev)		(NULL)

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
struct fwnode_handle;

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

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

static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
{
	return NULL;
}

486 487 488 489 490
static inline bool has_acpi_companion(struct device *dev)
{
	return false;
}

491 492 493 494 495
static inline const char *acpi_dev_name(struct acpi_device *adev)
{
	return NULL;
}

496
static inline void acpi_early_init(void) { }
A
Andrew Morton 已提交
497

498 499 500 501
static inline int early_acpi_boot_init(void)
{
	return 0;
}
A
Andrew Morton 已提交
502 503 504 505 506
static inline int acpi_boot_init(void)
{
	return 0;
}

507
static inline void acpi_boot_table_init(void)
A
Andrew Morton 已提交
508
{
509
	return;
A
Andrew Morton 已提交
510 511
}

512 513 514 515 516
static inline int acpi_mps_check(void)
{
	return 0;
}

517 518 519 520 521
static inline int acpi_check_resource_conflict(struct resource *res)
{
	return 0;
}

522 523 524 525 526 527
static inline int acpi_check_region(resource_size_t start, resource_size_t n,
				    const char *name)
{
	return 0;
}

528 529 530 531
struct acpi_table_header;
static inline int acpi_table_parse(char *id,
				int (*handler)(struct acpi_table_header *))
{
532
	return -ENODEV;
533
}
534

H
Huang Ying 已提交
535
static inline int acpi_nvs_register(__u64 start, __u64 size)
536 537 538
{
	return 0;
}
H
Huang Ying 已提交
539 540 541 542 543 544 545

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

546 547 548 549 550 551 552 553 554 555 556 557 558 559
struct acpi_device_id;

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

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

560 561 562 563 564 565 566 567 568 569 570 571
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;
}

572 573
#define ACPI_PTR(_ptr)	(NULL)

H
Huang Ying 已提交
574
#endif	/* !CONFIG_ACPI */
575

576 577 578 579 580 581
#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);
582 583 584 585 586 587 588

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);

589
#ifdef CONFIG_X86
590 591 592 593 594 595 596
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 */
597 598 599 600
#else
#define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0)
#endif

601
#if defined(CONFIG_ACPI) && defined(CONFIG_PM)
602 603 604 605
int acpi_dev_runtime_suspend(struct device *dev);
int acpi_dev_runtime_resume(struct device *dev);
int acpi_subsys_runtime_suspend(struct device *dev);
int acpi_subsys_runtime_resume(struct device *dev);
606 607
struct acpi_device *acpi_dev_pm_get_node(struct device *dev);
int acpi_dev_pm_attach(struct device *dev, bool power_on);
608 609 610 611 612
#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; }
613 614 615 616 617 618 619 620
static inline struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
{
	return NULL;
}
static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
{
	return -ENODEV;
}
621 622
#endif

623
#if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)
624 625 626
int acpi_dev_suspend_late(struct device *dev);
int acpi_dev_resume_early(struct device *dev);
int acpi_subsys_prepare(struct device *dev);
627
void acpi_subsys_complete(struct device *dev);
628 629
int acpi_subsys_suspend_late(struct device *dev);
int acpi_subsys_resume_early(struct device *dev);
630 631
int acpi_subsys_suspend(struct device *dev);
int acpi_subsys_freeze(struct device *dev);
632 633 634 635
#else
static inline int acpi_dev_suspend_late(struct device *dev) { return 0; }
static inline int acpi_dev_resume_early(struct device *dev) { return 0; }
static inline int acpi_subsys_prepare(struct device *dev) { return 0; }
636
static inline void acpi_subsys_complete(struct device *dev) {}
637 638
static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; }
static inline int acpi_subsys_resume_early(struct device *dev) { return 0; }
639 640
static inline int acpi_subsys_suspend(struct device *dev) { return 0; }
static inline int acpi_subsys_freeze(struct device *dev) { return 0; }
641 642
#endif

643 644 645 646 647 648 649 650 651
#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 已提交
652 653 654 655 656 657 658 659
#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

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
/*
 * 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 已提交
681
#if defined(DEBUG)
682 683 684
#define acpi_handle_debug(handle, fmt, ...)				\
	acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__)
#else
B
Bjørn Mork 已提交
685 686 687 688 689 690 691 692 693
#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
694 695 696 697 698 699 700
#define acpi_handle_debug(handle, fmt, ...)				\
({									\
	if (0)								\
		acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__); \
	0;								\
})
#endif
B
Bjørn Mork 已提交
701
#endif
702

703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
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;
};

#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;
}
#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) {}
#endif

733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
/* Device properties */

#define MAX_ACPI_REFERENCE_ARGS	8
struct acpi_reference_args {
	struct acpi_device *adev;
	size_t nargs;
	u64 args[MAX_ACPI_REFERENCE_ARGS];
};

#ifdef CONFIG_ACPI
int acpi_dev_get_property(struct acpi_device *adev, const char *name,
			  acpi_object_type type, const union acpi_object **obj);
int acpi_dev_get_property_array(struct acpi_device *adev, const char *name,
				acpi_object_type type,
				const union acpi_object **obj);
748 749
int acpi_dev_get_property_reference(struct acpi_device *adev,
				    const char *name, size_t index,
750
				    struct acpi_reference_args *args);
751 752 753 754 755 756 757

int acpi_dev_prop_get(struct acpi_device *adev, const char *propname,
		      void **valptr);
int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
			      enum dev_prop_type proptype, void *val);
int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
		       enum dev_prop_type proptype, void *val, size_t nval);
758 759 760

struct acpi_device *acpi_get_next_child(struct device *dev,
					struct acpi_device *child);
761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
#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;
}
static inline int acpi_dev_get_property_array(struct acpi_device *adev,
					      const char *name,
					      acpi_object_type type,
					      const union acpi_object **obj)
{
	return -ENXIO;
}
static inline int acpi_dev_get_property_reference(struct acpi_device *adev,
				const char *name, const char *cells_name,
				size_t index, struct acpi_reference_args *args)
{
	return -ENXIO;
}
781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804

static inline int acpi_dev_prop_get(struct acpi_device *adev,
				    const char *propname,
				    void **valptr)
{
	return -ENXIO;
}

static inline int acpi_dev_prop_read_single(struct acpi_device *adev,
					    const char *propname,
					    enum dev_prop_type proptype,
					    void *val)
{
	return -ENXIO;
}

static inline int acpi_dev_prop_read(struct acpi_device *adev,
				     const char *propname,
				     enum dev_prop_type proptype,
				     void *val, size_t nval)
{
	return -ENXIO;
}

805 806 807 808 809 810
static inline struct acpi_device *acpi_get_next_child(struct device *dev,
						      struct acpi_device *child)
{
	return NULL;
}

811 812
#endif

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