acpi.h 33 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124
  1. /*
  2. * acpi.h - ACPI Interface
  3. *
  4. * Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  5. *
  6. * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  19. */
  20. #ifndef _LINUX_ACPI_H
  21. #define _LINUX_ACPI_H
  22. #include <linux/errno.h>
  23. #include <linux/ioport.h> /* for struct resource */
  24. #include <linux/resource_ext.h>
  25. #include <linux/device.h>
  26. #include <linux/property.h>
  27. #ifndef _LINUX
  28. #define _LINUX
  29. #endif
  30. #include <acpi/acpi.h>
  31. #ifdef CONFIG_ACPI
  32. #include <linux/list.h>
  33. #include <linux/mod_devicetable.h>
  34. #include <linux/dynamic_debug.h>
  35. #include <linux/module.h>
  36. #include <linux/mutex.h>
  37. #include <acpi/acpi_bus.h>
  38. #include <acpi/acpi_drivers.h>
  39. #include <acpi/acpi_numa.h>
  40. #include <acpi/acpi_io.h>
  41. #include <asm/acpi.h>
  42. static inline acpi_handle acpi_device_handle(struct acpi_device *adev)
  43. {
  44. return adev ? adev->handle : NULL;
  45. }
  46. #define ACPI_COMPANION(dev) to_acpi_device_node((dev)->fwnode)
  47. #define ACPI_COMPANION_SET(dev, adev) set_primary_fwnode(dev, (adev) ? \
  48. acpi_fwnode_handle(adev) : NULL)
  49. #define ACPI_HANDLE(dev) acpi_device_handle(ACPI_COMPANION(dev))
  50. /**
  51. * ACPI_DEVICE_CLASS - macro used to describe an ACPI device with
  52. * the PCI-defined class-code information
  53. *
  54. * @_cls : the class, subclass, prog-if triple for this device
  55. * @_msk : the class mask for this device
  56. *
  57. * This macro is used to create a struct acpi_device_id that matches a
  58. * specific PCI class. The .id and .driver_data fields will be left
  59. * initialized with the default value.
  60. */
  61. #define ACPI_DEVICE_CLASS(_cls, _msk) .cls = (_cls), .cls_msk = (_msk),
  62. static inline bool has_acpi_companion(struct device *dev)
  63. {
  64. return is_acpi_device_node(dev->fwnode);
  65. }
  66. static inline void acpi_preset_companion(struct device *dev,
  67. struct acpi_device *parent, u64 addr)
  68. {
  69. ACPI_COMPANION_SET(dev, acpi_find_child_device(parent, addr, NULL));
  70. }
  71. static inline const char *acpi_dev_name(struct acpi_device *adev)
  72. {
  73. return dev_name(&adev->dev);
  74. }
  75. struct device *acpi_get_first_physical_node(struct acpi_device *adev);
  76. enum acpi_irq_model_id {
  77. ACPI_IRQ_MODEL_PIC = 0,
  78. ACPI_IRQ_MODEL_IOAPIC,
  79. ACPI_IRQ_MODEL_IOSAPIC,
  80. ACPI_IRQ_MODEL_PLATFORM,
  81. ACPI_IRQ_MODEL_GIC,
  82. ACPI_IRQ_MODEL_COUNT
  83. };
  84. extern enum acpi_irq_model_id acpi_irq_model;
  85. enum acpi_interrupt_id {
  86. ACPI_INTERRUPT_PMI = 1,
  87. ACPI_INTERRUPT_INIT,
  88. ACPI_INTERRUPT_CPEI,
  89. ACPI_INTERRUPT_COUNT
  90. };
  91. #define ACPI_SPACE_MEM 0
  92. enum acpi_address_range_id {
  93. ACPI_ADDRESS_RANGE_MEMORY = 1,
  94. ACPI_ADDRESS_RANGE_RESERVED = 2,
  95. ACPI_ADDRESS_RANGE_ACPI = 3,
  96. ACPI_ADDRESS_RANGE_NVS = 4,
  97. ACPI_ADDRESS_RANGE_COUNT
  98. };
  99. /* Table Handlers */
  100. typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table);
  101. typedef int (*acpi_tbl_entry_handler)(struct acpi_subtable_header *header,
  102. const unsigned long end);
  103. /* Debugger support */
  104. struct acpi_debugger_ops {
  105. int (*create_thread)(acpi_osd_exec_callback function, void *context);
  106. ssize_t (*write_log)(const char *msg);
  107. ssize_t (*read_cmd)(char *buffer, size_t length);
  108. int (*wait_command_ready)(bool single_step, char *buffer, size_t length);
  109. int (*notify_command_complete)(void);
  110. };
  111. struct acpi_debugger {
  112. const struct acpi_debugger_ops *ops;
  113. struct module *owner;
  114. struct mutex lock;
  115. };
  116. #ifdef CONFIG_ACPI_DEBUGGER
  117. int __init acpi_debugger_init(void);
  118. int acpi_register_debugger(struct module *owner,
  119. const struct acpi_debugger_ops *ops);
  120. void acpi_unregister_debugger(const struct acpi_debugger_ops *ops);
  121. int acpi_debugger_create_thread(acpi_osd_exec_callback function, void *context);
  122. ssize_t acpi_debugger_write_log(const char *msg);
  123. ssize_t acpi_debugger_read_cmd(char *buffer, size_t buffer_length);
  124. int acpi_debugger_wait_command_ready(void);
  125. int acpi_debugger_notify_command_complete(void);
  126. #else
  127. static inline int acpi_debugger_init(void)
  128. {
  129. return -ENODEV;
  130. }
  131. static inline int acpi_register_debugger(struct module *owner,
  132. const struct acpi_debugger_ops *ops)
  133. {
  134. return -ENODEV;
  135. }
  136. static inline void acpi_unregister_debugger(const struct acpi_debugger_ops *ops)
  137. {
  138. }
  139. static inline int acpi_debugger_create_thread(acpi_osd_exec_callback function,
  140. void *context)
  141. {
  142. return -ENODEV;
  143. }
  144. static inline int acpi_debugger_write_log(const char *msg)
  145. {
  146. return -ENODEV;
  147. }
  148. static inline int acpi_debugger_read_cmd(char *buffer, u32 buffer_length)
  149. {
  150. return -ENODEV;
  151. }
  152. static inline int acpi_debugger_wait_command_ready(void)
  153. {
  154. return -ENODEV;
  155. }
  156. static inline int acpi_debugger_notify_command_complete(void)
  157. {
  158. return -ENODEV;
  159. }
  160. #endif
  161. #define BAD_MADT_ENTRY(entry, end) ( \
  162. (!entry) || (unsigned long)entry + sizeof(*entry) > end || \
  163. ((struct acpi_subtable_header *)entry)->length < sizeof(*entry))
  164. struct acpi_subtable_proc {
  165. int id;
  166. acpi_tbl_entry_handler handler;
  167. int count;
  168. };
  169. char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
  170. void __acpi_unmap_table(char *map, unsigned long size);
  171. int early_acpi_boot_init(void);
  172. int acpi_boot_init (void);
  173. void acpi_boot_table_init (void);
  174. int acpi_mps_check (void);
  175. int acpi_numa_init (void);
  176. int acpi_table_init (void);
  177. int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
  178. int __init acpi_parse_entries(char *id, unsigned long table_size,
  179. acpi_tbl_entry_handler handler,
  180. struct acpi_table_header *table_header,
  181. int entry_id, unsigned int max_entries);
  182. int __init acpi_table_parse_entries(char *id, unsigned long table_size,
  183. int entry_id,
  184. acpi_tbl_entry_handler handler,
  185. unsigned int max_entries);
  186. int __init acpi_table_parse_entries(char *id, unsigned long table_size,
  187. int entry_id,
  188. acpi_tbl_entry_handler handler,
  189. unsigned int max_entries);
  190. int __init acpi_table_parse_entries_array(char *id, unsigned long table_size,
  191. struct acpi_subtable_proc *proc, int proc_num,
  192. unsigned int max_entries);
  193. int acpi_table_parse_madt(enum acpi_madt_type id,
  194. acpi_tbl_entry_handler handler,
  195. unsigned int max_entries);
  196. int acpi_parse_mcfg (struct acpi_table_header *header);
  197. void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
  198. /* the following numa functions are architecture-dependent */
  199. void acpi_numa_slit_init (struct acpi_table_slit *slit);
  200. #if defined(CONFIG_X86) || defined(CONFIG_IA64)
  201. void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);
  202. #else
  203. static inline void
  204. acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa) { }
  205. #endif
  206. void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);
  207. #ifdef CONFIG_ARM64
  208. void acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa);
  209. #else
  210. static inline void
  211. acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa) { }
  212. #endif
  213. int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);
  214. #ifndef PHYS_CPUID_INVALID
  215. typedef u32 phys_cpuid_t;
  216. #define PHYS_CPUID_INVALID (phys_cpuid_t)(-1)
  217. #endif
  218. static inline bool invalid_logical_cpuid(u32 cpuid)
  219. {
  220. return (int)cpuid < 0;
  221. }
  222. static inline bool invalid_phys_cpuid(phys_cpuid_t phys_id)
  223. {
  224. return phys_id == PHYS_CPUID_INVALID;
  225. }
  226. /* Validate the processor object's proc_id */
  227. bool acpi_processor_validate_proc_id(int proc_id);
  228. #ifdef CONFIG_ACPI_HOTPLUG_CPU
  229. /* Arch dependent functions for cpu hotplug support */
  230. int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, int *pcpu);
  231. int acpi_unmap_cpu(int cpu);
  232. int acpi_map_cpu2node(acpi_handle handle, int cpu, int physid);
  233. #endif /* CONFIG_ACPI_HOTPLUG_CPU */
  234. void acpi_set_processor_mapping(void);
  235. #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
  236. int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr);
  237. #endif
  238. int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
  239. int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
  240. int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base);
  241. void acpi_irq_stats_init(void);
  242. extern u32 acpi_irq_handled;
  243. extern u32 acpi_irq_not_handled;
  244. extern unsigned int acpi_sci_irq;
  245. extern bool acpi_no_s5;
  246. #define INVALID_ACPI_IRQ ((unsigned)-1)
  247. static inline bool acpi_sci_irq_valid(void)
  248. {
  249. return acpi_sci_irq != INVALID_ACPI_IRQ;
  250. }
  251. extern int sbf_port;
  252. extern unsigned long acpi_realmode_flags;
  253. int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
  254. int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
  255. int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);
  256. void acpi_set_irq_model(enum acpi_irq_model_id model,
  257. struct fwnode_handle *fwnode);
  258. #ifdef CONFIG_X86_IO_APIC
  259. extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity);
  260. #else
  261. #define acpi_get_override_irq(gsi, trigger, polarity) (-1)
  262. #endif
  263. /*
  264. * This function undoes the effect of one call to acpi_register_gsi().
  265. * If this matches the last registration, any IRQ resources for gsi
  266. * are freed.
  267. */
  268. void acpi_unregister_gsi (u32 gsi);
  269. struct pci_dev;
  270. int acpi_pci_irq_enable (struct pci_dev *dev);
  271. void acpi_penalize_isa_irq(int irq, int active);
  272. bool acpi_isa_irq_available(int irq);
  273. void acpi_pci_irq_disable (struct pci_dev *dev);
  274. extern int ec_read(u8 addr, u8 *val);
  275. extern int ec_write(u8 addr, u8 val);
  276. extern int ec_transaction(u8 command,
  277. const u8 *wdata, unsigned wdata_len,
  278. u8 *rdata, unsigned rdata_len);
  279. extern acpi_handle ec_get_handle(void);
  280. extern bool acpi_is_pnp_device(struct acpi_device *);
  281. #if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
  282. typedef void (*wmi_notify_handler) (u32 value, void *context);
  283. extern acpi_status wmi_evaluate_method(const char *guid, u8 instance,
  284. u32 method_id,
  285. const struct acpi_buffer *in,
  286. struct acpi_buffer *out);
  287. extern acpi_status wmi_query_block(const char *guid, u8 instance,
  288. struct acpi_buffer *out);
  289. extern acpi_status wmi_set_block(const char *guid, u8 instance,
  290. const struct acpi_buffer *in);
  291. extern acpi_status wmi_install_notify_handler(const char *guid,
  292. wmi_notify_handler handler, void *data);
  293. extern acpi_status wmi_remove_notify_handler(const char *guid);
  294. extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out);
  295. extern bool wmi_has_guid(const char *guid);
  296. #endif /* CONFIG_ACPI_WMI */
  297. #define ACPI_VIDEO_OUTPUT_SWITCHING 0x0001
  298. #define ACPI_VIDEO_DEVICE_POSTING 0x0002
  299. #define ACPI_VIDEO_ROM_AVAILABLE 0x0004
  300. #define ACPI_VIDEO_BACKLIGHT 0x0008
  301. #define ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR 0x0010
  302. #define ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO 0x0020
  303. #define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VENDOR 0x0040
  304. #define ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO 0x0080
  305. #define ACPI_VIDEO_BACKLIGHT_DMI_VENDOR 0x0100
  306. #define ACPI_VIDEO_BACKLIGHT_DMI_VIDEO 0x0200
  307. #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR 0x0400
  308. #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO 0x0800
  309. extern char acpi_video_backlight_string[];
  310. extern long acpi_is_video_device(acpi_handle handle);
  311. extern int acpi_blacklisted(void);
  312. extern void acpi_osi_setup(char *str);
  313. extern bool acpi_osi_is_win8(void);
  314. #ifdef CONFIG_ACPI_NUMA
  315. int acpi_map_pxm_to_online_node(int pxm);
  316. int acpi_get_node(acpi_handle handle);
  317. #else
  318. static inline int acpi_map_pxm_to_online_node(int pxm)
  319. {
  320. return 0;
  321. }
  322. static inline int acpi_get_node(acpi_handle handle)
  323. {
  324. return 0;
  325. }
  326. #endif
  327. extern int acpi_paddr_to_node(u64 start_addr, u64 size);
  328. extern int pnpacpi_disabled;
  329. #define PXM_INVAL (-1)
  330. bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res);
  331. bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res);
  332. bool acpi_dev_resource_address_space(struct acpi_resource *ares,
  333. struct resource_win *win);
  334. bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
  335. struct resource_win *win);
  336. unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
  337. unsigned int acpi_dev_get_irq_type(int triggering, int polarity);
  338. bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
  339. struct resource *res);
  340. void acpi_dev_free_resource_list(struct list_head *list);
  341. int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
  342. int (*preproc)(struct acpi_resource *, void *),
  343. void *preproc_data);
  344. int acpi_dev_filter_resource_type(struct acpi_resource *ares,
  345. unsigned long types);
  346. static inline int acpi_dev_filter_resource_type_cb(struct acpi_resource *ares,
  347. void *arg)
  348. {
  349. return acpi_dev_filter_resource_type(ares, (unsigned long)arg);
  350. }
  351. int acpi_check_resource_conflict(const struct resource *res);
  352. int acpi_check_region(resource_size_t start, resource_size_t n,
  353. const char *name);
  354. int acpi_resources_are_enforced(void);
  355. #ifdef CONFIG_HIBERNATION
  356. void __init acpi_no_s4_hw_signature(void);
  357. #endif
  358. #ifdef CONFIG_PM_SLEEP
  359. void __init acpi_old_suspend_ordering(void);
  360. void __init acpi_nvs_nosave(void);
  361. void __init acpi_nvs_nosave_s3(void);
  362. #endif /* CONFIG_PM_SLEEP */
  363. struct acpi_osc_context {
  364. char *uuid_str; /* UUID string */
  365. int rev;
  366. struct acpi_buffer cap; /* list of DWORD capabilities */
  367. struct acpi_buffer ret; /* free by caller if success */
  368. };
  369. acpi_status acpi_str_to_uuid(char *str, u8 *uuid);
  370. acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);
  371. /* Indexes into _OSC Capabilities Buffer (DWORDs 2 & 3 are device-specific) */
  372. #define OSC_QUERY_DWORD 0 /* DWORD 1 */
  373. #define OSC_SUPPORT_DWORD 1 /* DWORD 2 */
  374. #define OSC_CONTROL_DWORD 2 /* DWORD 3 */
  375. /* _OSC Capabilities DWORD 1: Query/Control and Error Returns (generic) */
  376. #define OSC_QUERY_ENABLE 0x00000001 /* input */
  377. #define OSC_REQUEST_ERROR 0x00000002 /* return */
  378. #define OSC_INVALID_UUID_ERROR 0x00000004 /* return */
  379. #define OSC_INVALID_REVISION_ERROR 0x00000008 /* return */
  380. #define OSC_CAPABILITIES_MASK_ERROR 0x00000010 /* return */
  381. /* Platform-Wide Capabilities _OSC: Capabilities DWORD 2: Support Field */
  382. #define OSC_SB_PAD_SUPPORT 0x00000001
  383. #define OSC_SB_PPC_OST_SUPPORT 0x00000002
  384. #define OSC_SB_PR3_SUPPORT 0x00000004
  385. #define OSC_SB_HOTPLUG_OST_SUPPORT 0x00000008
  386. #define OSC_SB_APEI_SUPPORT 0x00000010
  387. #define OSC_SB_CPC_SUPPORT 0x00000020
  388. #define OSC_SB_CPCV2_SUPPORT 0x00000040
  389. #define OSC_SB_PCLPI_SUPPORT 0x00000080
  390. #define OSC_SB_OSLPI_SUPPORT 0x00000100
  391. extern bool osc_sb_apei_support_acked;
  392. extern bool osc_pc_lpi_support_confirmed;
  393. /* PCI Host Bridge _OSC: Capabilities DWORD 2: Support Field */
  394. #define OSC_PCI_EXT_CONFIG_SUPPORT 0x00000001
  395. #define OSC_PCI_ASPM_SUPPORT 0x00000002
  396. #define OSC_PCI_CLOCK_PM_SUPPORT 0x00000004
  397. #define OSC_PCI_SEGMENT_GROUPS_SUPPORT 0x00000008
  398. #define OSC_PCI_MSI_SUPPORT 0x00000010
  399. #define OSC_PCI_SUPPORT_MASKS 0x0000001f
  400. /* PCI Host Bridge _OSC: Capabilities DWORD 3: Control Field */
  401. #define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL 0x00000001
  402. #define OSC_PCI_SHPC_NATIVE_HP_CONTROL 0x00000002
  403. #define OSC_PCI_EXPRESS_PME_CONTROL 0x00000004
  404. #define OSC_PCI_EXPRESS_AER_CONTROL 0x00000008
  405. #define OSC_PCI_EXPRESS_CAPABILITY_CONTROL 0x00000010
  406. #define OSC_PCI_CONTROL_MASKS 0x0000001f
  407. #define ACPI_GSB_ACCESS_ATTRIB_QUICK 0x00000002
  408. #define ACPI_GSB_ACCESS_ATTRIB_SEND_RCV 0x00000004
  409. #define ACPI_GSB_ACCESS_ATTRIB_BYTE 0x00000006
  410. #define ACPI_GSB_ACCESS_ATTRIB_WORD 0x00000008
  411. #define ACPI_GSB_ACCESS_ATTRIB_BLOCK 0x0000000A
  412. #define ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE 0x0000000B
  413. #define ACPI_GSB_ACCESS_ATTRIB_WORD_CALL 0x0000000C
  414. #define ACPI_GSB_ACCESS_ATTRIB_BLOCK_CALL 0x0000000D
  415. #define ACPI_GSB_ACCESS_ATTRIB_RAW_BYTES 0x0000000E
  416. #define ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS 0x0000000F
  417. extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
  418. u32 *mask, u32 req);
  419. /* Enable _OST when all relevant hotplug operations are enabled */
  420. #if defined(CONFIG_ACPI_HOTPLUG_CPU) && \
  421. defined(CONFIG_ACPI_HOTPLUG_MEMORY) && \
  422. defined(CONFIG_ACPI_CONTAINER)
  423. #define ACPI_HOTPLUG_OST
  424. #endif
  425. /* _OST Source Event Code (OSPM Action) */
  426. #define ACPI_OST_EC_OSPM_SHUTDOWN 0x100
  427. #define ACPI_OST_EC_OSPM_EJECT 0x103
  428. #define ACPI_OST_EC_OSPM_INSERTION 0x200
  429. /* _OST General Processing Status Code */
  430. #define ACPI_OST_SC_SUCCESS 0x0
  431. #define ACPI_OST_SC_NON_SPECIFIC_FAILURE 0x1
  432. #define ACPI_OST_SC_UNRECOGNIZED_NOTIFY 0x2
  433. /* _OST OS Shutdown Processing (0x100) Status Code */
  434. #define ACPI_OST_SC_OS_SHUTDOWN_DENIED 0x80
  435. #define ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS 0x81
  436. #define ACPI_OST_SC_OS_SHUTDOWN_COMPLETED 0x82
  437. #define ACPI_OST_SC_OS_SHUTDOWN_NOT_SUPPORTED 0x83
  438. /* _OST Ejection Request (0x3, 0x103) Status Code */
  439. #define ACPI_OST_SC_EJECT_NOT_SUPPORTED 0x80
  440. #define ACPI_OST_SC_DEVICE_IN_USE 0x81
  441. #define ACPI_OST_SC_DEVICE_BUSY 0x82
  442. #define ACPI_OST_SC_EJECT_DEPENDENCY_BUSY 0x83
  443. #define ACPI_OST_SC_EJECT_IN_PROGRESS 0x84
  444. /* _OST Insertion Request (0x200) Status Code */
  445. #define ACPI_OST_SC_INSERT_IN_PROGRESS 0x80
  446. #define ACPI_OST_SC_DRIVER_LOAD_FAILURE 0x81
  447. #define ACPI_OST_SC_INSERT_NOT_SUPPORTED 0x82
  448. extern void acpi_early_init(void);
  449. extern void acpi_subsystem_init(void);
  450. extern int acpi_nvs_register(__u64 start, __u64 size);
  451. extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
  452. void *data);
  453. const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
  454. const struct device *dev);
  455. extern bool acpi_driver_match_device(struct device *dev,
  456. const struct device_driver *drv);
  457. int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
  458. int acpi_device_modalias(struct device *, char *, int);
  459. void acpi_walk_dep_device_list(acpi_handle handle);
  460. struct platform_device *acpi_create_platform_device(struct acpi_device *);
  461. #define ACPI_PTR(_ptr) (_ptr)
  462. static inline void acpi_device_set_enumerated(struct acpi_device *adev)
  463. {
  464. adev->flags.visited = true;
  465. }
  466. static inline void acpi_device_clear_enumerated(struct acpi_device *adev)
  467. {
  468. adev->flags.visited = false;
  469. }
  470. enum acpi_reconfig_event {
  471. ACPI_RECONFIG_DEVICE_ADD = 0,
  472. ACPI_RECONFIG_DEVICE_REMOVE,
  473. };
  474. int acpi_reconfig_notifier_register(struct notifier_block *nb);
  475. int acpi_reconfig_notifier_unregister(struct notifier_block *nb);
  476. #else /* !CONFIG_ACPI */
  477. #define acpi_disabled 1
  478. #define ACPI_COMPANION(dev) (NULL)
  479. #define ACPI_COMPANION_SET(dev, adev) do { } while (0)
  480. #define ACPI_HANDLE(dev) (NULL)
  481. #define ACPI_DEVICE_CLASS(_cls, _msk) .cls = (0), .cls_msk = (0),
  482. struct fwnode_handle;
  483. static inline bool acpi_dev_found(const char *hid)
  484. {
  485. return false;
  486. }
  487. static inline bool is_acpi_node(struct fwnode_handle *fwnode)
  488. {
  489. return false;
  490. }
  491. static inline bool is_acpi_device_node(struct fwnode_handle *fwnode)
  492. {
  493. return false;
  494. }
  495. static inline struct acpi_device *to_acpi_device_node(struct fwnode_handle *fwnode)
  496. {
  497. return NULL;
  498. }
  499. static inline bool is_acpi_data_node(struct fwnode_handle *fwnode)
  500. {
  501. return false;
  502. }
  503. static inline struct acpi_data_node *to_acpi_data_node(struct fwnode_handle *fwnode)
  504. {
  505. return NULL;
  506. }
  507. static inline bool acpi_data_node_match(struct fwnode_handle *fwnode,
  508. const char *name)
  509. {
  510. return false;
  511. }
  512. static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
  513. {
  514. return NULL;
  515. }
  516. static inline bool has_acpi_companion(struct device *dev)
  517. {
  518. return false;
  519. }
  520. static inline void acpi_preset_companion(struct device *dev,
  521. struct acpi_device *parent, u64 addr)
  522. {
  523. }
  524. static inline const char *acpi_dev_name(struct acpi_device *adev)
  525. {
  526. return NULL;
  527. }
  528. static inline struct device *acpi_get_first_physical_node(struct acpi_device *adev)
  529. {
  530. return NULL;
  531. }
  532. static inline void acpi_early_init(void) { }
  533. static inline void acpi_subsystem_init(void) { }
  534. static inline int early_acpi_boot_init(void)
  535. {
  536. return 0;
  537. }
  538. static inline int acpi_boot_init(void)
  539. {
  540. return 0;
  541. }
  542. static inline void acpi_boot_table_init(void)
  543. {
  544. return;
  545. }
  546. static inline int acpi_mps_check(void)
  547. {
  548. return 0;
  549. }
  550. static inline int acpi_check_resource_conflict(struct resource *res)
  551. {
  552. return 0;
  553. }
  554. static inline int acpi_check_region(resource_size_t start, resource_size_t n,
  555. const char *name)
  556. {
  557. return 0;
  558. }
  559. struct acpi_table_header;
  560. static inline int acpi_table_parse(char *id,
  561. int (*handler)(struct acpi_table_header *))
  562. {
  563. return -ENODEV;
  564. }
  565. static inline int acpi_nvs_register(__u64 start, __u64 size)
  566. {
  567. return 0;
  568. }
  569. static inline int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
  570. void *data)
  571. {
  572. return 0;
  573. }
  574. struct acpi_device_id;
  575. static inline const struct acpi_device_id *acpi_match_device(
  576. const struct acpi_device_id *ids, const struct device *dev)
  577. {
  578. return NULL;
  579. }
  580. static inline bool acpi_driver_match_device(struct device *dev,
  581. const struct device_driver *drv)
  582. {
  583. return false;
  584. }
  585. static inline union acpi_object *acpi_evaluate_dsm(acpi_handle handle,
  586. const u8 *uuid,
  587. int rev, int func,
  588. union acpi_object *argv4)
  589. {
  590. return NULL;
  591. }
  592. static inline int acpi_device_uevent_modalias(struct device *dev,
  593. struct kobj_uevent_env *env)
  594. {
  595. return -ENODEV;
  596. }
  597. static inline int acpi_device_modalias(struct device *dev,
  598. char *buf, int size)
  599. {
  600. return -ENODEV;
  601. }
  602. static inline bool acpi_dma_supported(struct acpi_device *adev)
  603. {
  604. return false;
  605. }
  606. static inline enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
  607. {
  608. return DEV_DMA_NOT_SUPPORTED;
  609. }
  610. #define ACPI_PTR(_ptr) (NULL)
  611. static inline void acpi_device_set_enumerated(struct acpi_device *adev)
  612. {
  613. }
  614. static inline void acpi_device_clear_enumerated(struct acpi_device *adev)
  615. {
  616. }
  617. static inline int acpi_reconfig_notifier_register(struct notifier_block *nb)
  618. {
  619. return -EINVAL;
  620. }
  621. static inline int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
  622. {
  623. return -EINVAL;
  624. }
  625. #endif /* !CONFIG_ACPI */
  626. #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
  627. int acpi_ioapic_add(acpi_handle root);
  628. #else
  629. static inline int acpi_ioapic_add(acpi_handle root) { return 0; }
  630. #endif
  631. #ifdef CONFIG_ACPI
  632. void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
  633. u32 pm1a_ctrl, u32 pm1b_ctrl));
  634. acpi_status acpi_os_prepare_sleep(u8 sleep_state,
  635. u32 pm1a_control, u32 pm1b_control);
  636. void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
  637. u32 val_a, u32 val_b));
  638. acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state,
  639. u32 val_a, u32 val_b);
  640. #ifdef CONFIG_X86
  641. void arch_reserve_mem_area(acpi_physical_address addr, size_t size);
  642. #else
  643. static inline void arch_reserve_mem_area(acpi_physical_address addr,
  644. size_t size)
  645. {
  646. }
  647. #endif /* CONFIG_X86 */
  648. #else
  649. #define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0)
  650. #endif
  651. #if defined(CONFIG_ACPI) && defined(CONFIG_PM)
  652. int acpi_dev_runtime_suspend(struct device *dev);
  653. int acpi_dev_runtime_resume(struct device *dev);
  654. int acpi_subsys_runtime_suspend(struct device *dev);
  655. int acpi_subsys_runtime_resume(struct device *dev);
  656. struct acpi_device *acpi_dev_pm_get_node(struct device *dev);
  657. int acpi_dev_pm_attach(struct device *dev, bool power_on);
  658. #else
  659. static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; }
  660. static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; }
  661. static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }
  662. static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }
  663. static inline struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
  664. {
  665. return NULL;
  666. }
  667. static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
  668. {
  669. return -ENODEV;
  670. }
  671. #endif
  672. #if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)
  673. int acpi_dev_suspend_late(struct device *dev);
  674. int acpi_dev_resume_early(struct device *dev);
  675. int acpi_subsys_prepare(struct device *dev);
  676. void acpi_subsys_complete(struct device *dev);
  677. int acpi_subsys_suspend_late(struct device *dev);
  678. int acpi_subsys_resume_early(struct device *dev);
  679. int acpi_subsys_suspend(struct device *dev);
  680. int acpi_subsys_freeze(struct device *dev);
  681. #else
  682. static inline int acpi_dev_suspend_late(struct device *dev) { return 0; }
  683. static inline int acpi_dev_resume_early(struct device *dev) { return 0; }
  684. static inline int acpi_subsys_prepare(struct device *dev) { return 0; }
  685. static inline void acpi_subsys_complete(struct device *dev) {}
  686. static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; }
  687. static inline int acpi_subsys_resume_early(struct device *dev) { return 0; }
  688. static inline int acpi_subsys_suspend(struct device *dev) { return 0; }
  689. static inline int acpi_subsys_freeze(struct device *dev) { return 0; }
  690. #endif
  691. #ifdef CONFIG_ACPI
  692. __printf(3, 4)
  693. void acpi_handle_printk(const char *level, acpi_handle handle,
  694. const char *fmt, ...);
  695. #else /* !CONFIG_ACPI */
  696. static inline __printf(3, 4) void
  697. acpi_handle_printk(const char *level, void *handle, const char *fmt, ...) {}
  698. #endif /* !CONFIG_ACPI */
  699. #if defined(CONFIG_ACPI) && defined(CONFIG_DYNAMIC_DEBUG)
  700. __printf(3, 4)
  701. void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...);
  702. #else
  703. #define __acpi_handle_debug(descriptor, handle, fmt, ...) \
  704. acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__);
  705. #endif
  706. /*
  707. * acpi_handle_<level>: Print message with ACPI prefix and object path
  708. *
  709. * These interfaces acquire the global namespace mutex to obtain an object
  710. * path. In interrupt context, it shows the object path as <n/a>.
  711. */
  712. #define acpi_handle_emerg(handle, fmt, ...) \
  713. acpi_handle_printk(KERN_EMERG, handle, fmt, ##__VA_ARGS__)
  714. #define acpi_handle_alert(handle, fmt, ...) \
  715. acpi_handle_printk(KERN_ALERT, handle, fmt, ##__VA_ARGS__)
  716. #define acpi_handle_crit(handle, fmt, ...) \
  717. acpi_handle_printk(KERN_CRIT, handle, fmt, ##__VA_ARGS__)
  718. #define acpi_handle_err(handle, fmt, ...) \
  719. acpi_handle_printk(KERN_ERR, handle, fmt, ##__VA_ARGS__)
  720. #define acpi_handle_warn(handle, fmt, ...) \
  721. acpi_handle_printk(KERN_WARNING, handle, fmt, ##__VA_ARGS__)
  722. #define acpi_handle_notice(handle, fmt, ...) \
  723. acpi_handle_printk(KERN_NOTICE, handle, fmt, ##__VA_ARGS__)
  724. #define acpi_handle_info(handle, fmt, ...) \
  725. acpi_handle_printk(KERN_INFO, handle, fmt, ##__VA_ARGS__)
  726. #if defined(DEBUG)
  727. #define acpi_handle_debug(handle, fmt, ...) \
  728. acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__)
  729. #else
  730. #if defined(CONFIG_DYNAMIC_DEBUG)
  731. #define acpi_handle_debug(handle, fmt, ...) \
  732. do { \
  733. DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
  734. if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
  735. __acpi_handle_debug(&descriptor, handle, pr_fmt(fmt), \
  736. ##__VA_ARGS__); \
  737. } while (0)
  738. #else
  739. #define acpi_handle_debug(handle, fmt, ...) \
  740. ({ \
  741. if (0) \
  742. acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__); \
  743. 0; \
  744. })
  745. #endif
  746. #endif
  747. struct acpi_gpio_params {
  748. unsigned int crs_entry_index;
  749. unsigned int line_index;
  750. bool active_low;
  751. };
  752. struct acpi_gpio_mapping {
  753. const char *name;
  754. const struct acpi_gpio_params *data;
  755. unsigned int size;
  756. };
  757. #if defined(CONFIG_ACPI) && defined(CONFIG_GPIOLIB)
  758. int acpi_dev_add_driver_gpios(struct acpi_device *adev,
  759. const struct acpi_gpio_mapping *gpios);
  760. static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev)
  761. {
  762. if (adev)
  763. adev->driver_gpios = NULL;
  764. }
  765. int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index);
  766. #else
  767. static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
  768. const struct acpi_gpio_mapping *gpios)
  769. {
  770. return -ENXIO;
  771. }
  772. static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
  773. static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
  774. {
  775. return -ENXIO;
  776. }
  777. #endif
  778. /* Device properties */
  779. #define MAX_ACPI_REFERENCE_ARGS 8
  780. struct acpi_reference_args {
  781. struct acpi_device *adev;
  782. size_t nargs;
  783. u64 args[MAX_ACPI_REFERENCE_ARGS];
  784. };
  785. #ifdef CONFIG_ACPI
  786. int acpi_dev_get_property(struct acpi_device *adev, const char *name,
  787. acpi_object_type type, const union acpi_object **obj);
  788. int __acpi_node_get_property_reference(struct fwnode_handle *fwnode,
  789. const char *name, size_t index, size_t num_args,
  790. struct acpi_reference_args *args);
  791. static inline int acpi_node_get_property_reference(struct fwnode_handle *fwnode,
  792. const char *name, size_t index,
  793. struct acpi_reference_args *args)
  794. {
  795. return __acpi_node_get_property_reference(fwnode, name, index,
  796. MAX_ACPI_REFERENCE_ARGS, args);
  797. }
  798. int acpi_node_prop_get(struct fwnode_handle *fwnode, const char *propname,
  799. void **valptr);
  800. int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
  801. enum dev_prop_type proptype, void *val);
  802. int acpi_node_prop_read(struct fwnode_handle *fwnode, const char *propname,
  803. enum dev_prop_type proptype, void *val, size_t nval);
  804. int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
  805. enum dev_prop_type proptype, void *val, size_t nval);
  806. struct fwnode_handle *acpi_get_next_subnode(struct device *dev,
  807. struct fwnode_handle *subnode);
  808. struct acpi_probe_entry;
  809. typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *,
  810. struct acpi_probe_entry *);
  811. #define ACPI_TABLE_ID_LEN 5
  812. /**
  813. * struct acpi_probe_entry - boot-time probing entry
  814. * @id: ACPI table name
  815. * @type: Optional subtable type to match
  816. * (if @id contains subtables)
  817. * @subtable_valid: Optional callback to check the validity of
  818. * the subtable
  819. * @probe_table: Callback to the driver being probed when table
  820. * match is successful
  821. * @probe_subtbl: Callback to the driver being probed when table and
  822. * subtable match (and optional callback is successful)
  823. * @driver_data: Sideband data provided back to the driver
  824. */
  825. struct acpi_probe_entry {
  826. __u8 id[ACPI_TABLE_ID_LEN];
  827. __u8 type;
  828. acpi_probe_entry_validate_subtbl subtable_valid;
  829. union {
  830. acpi_tbl_table_handler probe_table;
  831. acpi_tbl_entry_handler probe_subtbl;
  832. };
  833. kernel_ulong_t driver_data;
  834. };
  835. #define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, valid, data, fn) \
  836. static const struct acpi_probe_entry __acpi_probe_##name \
  837. __used __section(__##table##_acpi_probe_table) \
  838. = { \
  839. .id = table_id, \
  840. .type = subtable, \
  841. .subtable_valid = valid, \
  842. .probe_table = (acpi_tbl_table_handler)fn, \
  843. .driver_data = data, \
  844. }
  845. #define ACPI_PROBE_TABLE(name) __##name##_acpi_probe_table
  846. #define ACPI_PROBE_TABLE_END(name) __##name##_acpi_probe_table_end
  847. int __acpi_probe_device_table(struct acpi_probe_entry *start, int nr);
  848. #define acpi_probe_device_table(t) \
  849. ({ \
  850. extern struct acpi_probe_entry ACPI_PROBE_TABLE(t), \
  851. ACPI_PROBE_TABLE_END(t); \
  852. __acpi_probe_device_table(&ACPI_PROBE_TABLE(t), \
  853. (&ACPI_PROBE_TABLE_END(t) - \
  854. &ACPI_PROBE_TABLE(t))); \
  855. })
  856. #else
  857. static inline int acpi_dev_get_property(struct acpi_device *adev,
  858. const char *name, acpi_object_type type,
  859. const union acpi_object **obj)
  860. {
  861. return -ENXIO;
  862. }
  863. static inline int
  864. __acpi_node_get_property_reference(struct fwnode_handle *fwnode,
  865. const char *name, size_t index, size_t num_args,
  866. struct acpi_reference_args *args)
  867. {
  868. return -ENXIO;
  869. }
  870. static inline int acpi_node_get_property_reference(struct fwnode_handle *fwnode,
  871. const char *name, size_t index,
  872. struct acpi_reference_args *args)
  873. {
  874. return -ENXIO;
  875. }
  876. static inline int acpi_node_prop_get(struct fwnode_handle *fwnode,
  877. const char *propname,
  878. void **valptr)
  879. {
  880. return -ENXIO;
  881. }
  882. static inline int acpi_dev_prop_get(struct acpi_device *adev,
  883. const char *propname,
  884. void **valptr)
  885. {
  886. return -ENXIO;
  887. }
  888. static inline int acpi_dev_prop_read_single(struct acpi_device *adev,
  889. const char *propname,
  890. enum dev_prop_type proptype,
  891. void *val)
  892. {
  893. return -ENXIO;
  894. }
  895. static inline int acpi_node_prop_read(struct fwnode_handle *fwnode,
  896. const char *propname,
  897. enum dev_prop_type proptype,
  898. void *val, size_t nval)
  899. {
  900. return -ENXIO;
  901. }
  902. static inline int acpi_dev_prop_read(struct acpi_device *adev,
  903. const char *propname,
  904. enum dev_prop_type proptype,
  905. void *val, size_t nval)
  906. {
  907. return -ENXIO;
  908. }
  909. static inline struct fwnode_handle *acpi_get_next_subnode(struct device *dev,
  910. struct fwnode_handle *subnode)
  911. {
  912. return NULL;
  913. }
  914. #define ACPI_DECLARE_PROBE_ENTRY(table, name, table_id, subtable, valid, data, fn) \
  915. static const void * __acpi_table_##name[] \
  916. __attribute__((unused)) \
  917. = { (void *) table_id, \
  918. (void *) subtable, \
  919. (void *) valid, \
  920. (void *) fn, \
  921. (void *) data }
  922. #define acpi_probe_device_table(t) ({ int __r = 0; __r;})
  923. #endif
  924. #ifdef CONFIG_ACPI_TABLE_UPGRADE
  925. void acpi_table_upgrade(void);
  926. #else
  927. static inline void acpi_table_upgrade(void) { }
  928. #endif
  929. #if defined(CONFIG_ACPI) && defined(CONFIG_ACPI_WATCHDOG)
  930. extern bool acpi_has_watchdog(void);
  931. #else
  932. static inline bool acpi_has_watchdog(void) { return false; }
  933. #endif
  934. #ifdef CONFIG_ACPI_SPCR_TABLE
  935. int parse_spcr(bool earlycon);
  936. #else
  937. static inline int parse_spcr(bool earlycon) { return 0; }
  938. #endif
  939. #endif /*_LINUX_ACPI_H*/