Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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