1  /* SPDX-License-Identifier: GPL-2.0-or-later */
2  /*
3   *  acpi_bus.h - ACPI Bus Driver ($Revision: 22 $)
4   *
5   *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6   *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7   */
8  
9  #ifndef __ACPI_BUS_H__
10  #define __ACPI_BUS_H__
11  
12  #include <linux/completion.h>
13  #include <linux/container_of.h>
14  #include <linux/device.h>
15  #include <linux/kobject.h>
16  #include <linux/mutex.h>
17  #include <linux/property.h>
18  #include <linux/types.h>
19  
20  struct acpi_handle_list {
21  	u32 count;
22  	acpi_handle *handles;
23  };
24  
25  /* acpi_utils.h */
26  acpi_status
27  acpi_extract_package(union acpi_object *package,
28  		     struct acpi_buffer *format, struct acpi_buffer *buffer);
29  acpi_status
30  acpi_evaluate_integer(acpi_handle handle,
31  		      acpi_string pathname,
32  		      struct acpi_object_list *arguments, unsigned long long *data);
33  bool acpi_evaluate_reference(acpi_handle handle, acpi_string pathname,
34  			     struct acpi_object_list *arguments,
35  			     struct acpi_handle_list *list);
36  bool acpi_handle_list_equal(struct acpi_handle_list *list1,
37  			    struct acpi_handle_list *list2);
38  void acpi_handle_list_replace(struct acpi_handle_list *dst,
39  			      struct acpi_handle_list *src);
40  void acpi_handle_list_free(struct acpi_handle_list *list);
41  bool acpi_device_dep(acpi_handle target, acpi_handle match);
42  acpi_status
43  acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code,
44  		  struct acpi_buffer *status_buf);
45  
46  acpi_status
47  acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld);
48  
49  bool acpi_has_method(acpi_handle handle, char *name);
50  acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
51  				       u64 arg);
52  acpi_status acpi_evaluate_ej0(acpi_handle handle);
53  acpi_status acpi_evaluate_lck(acpi_handle handle, int lock);
54  acpi_status acpi_evaluate_reg(acpi_handle handle, u8 space_id, u32 function);
55  bool acpi_ata_match(acpi_handle handle);
56  bool acpi_bay_match(acpi_handle handle);
57  bool acpi_dock_match(acpi_handle handle);
58  
59  bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs);
60  union acpi_object *acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid,
61  			u64 rev, u64 func, union acpi_object *argv4);
62  #ifdef CONFIG_ACPI
63  static inline union acpi_object *
acpi_evaluate_dsm_typed(acpi_handle handle,const guid_t * guid,u64 rev,u64 func,union acpi_object * argv4,acpi_object_type type)64  acpi_evaluate_dsm_typed(acpi_handle handle, const guid_t *guid, u64 rev,
65  			u64 func, union acpi_object *argv4,
66  			acpi_object_type type)
67  {
68  	union acpi_object *obj;
69  
70  	obj = acpi_evaluate_dsm(handle, guid, rev, func, argv4);
71  	if (obj && obj->type != type) {
72  		ACPI_FREE(obj);
73  		obj = NULL;
74  	}
75  
76  	return obj;
77  }
78  #endif
79  
80  #define	ACPI_INIT_DSM_ARGV4(cnt, eles)			\
81  	{						\
82  	  .package.type = ACPI_TYPE_PACKAGE,		\
83  	  .package.count = (cnt),			\
84  	  .package.elements = (eles)			\
85  	}
86  
87  bool acpi_dev_found(const char *hid);
88  bool acpi_dev_present(const char *hid, const char *uid, s64 hrv);
89  bool acpi_reduced_hardware(void);
90  
91  #ifdef CONFIG_ACPI
92  
93  struct proc_dir_entry;
94  
95  #define ACPI_BUS_FILE_ROOT	"acpi"
96  extern struct proc_dir_entry *acpi_root_dir;
97  
98  enum acpi_bus_device_type {
99  	ACPI_BUS_TYPE_DEVICE = 0,
100  	ACPI_BUS_TYPE_POWER,
101  	ACPI_BUS_TYPE_PROCESSOR,
102  	ACPI_BUS_TYPE_THERMAL,
103  	ACPI_BUS_TYPE_POWER_BUTTON,
104  	ACPI_BUS_TYPE_SLEEP_BUTTON,
105  	ACPI_BUS_TYPE_ECDT_EC,
106  	ACPI_BUS_DEVICE_TYPE_COUNT
107  };
108  
109  struct acpi_driver;
110  struct acpi_device;
111  
112  /*
113   * ACPI Scan Handler
114   * -----------------
115   */
116  
117  struct acpi_hotplug_profile {
118  	struct kobject kobj;
119  	int (*scan_dependent)(struct acpi_device *adev);
120  	void (*notify_online)(struct acpi_device *adev);
121  	bool enabled:1;
122  	bool demand_offline:1;
123  };
124  
to_acpi_hotplug_profile(struct kobject * kobj)125  static inline struct acpi_hotplug_profile *to_acpi_hotplug_profile(
126  						struct kobject *kobj)
127  {
128  	return container_of(kobj, struct acpi_hotplug_profile, kobj);
129  }
130  
131  struct acpi_scan_handler {
132  	struct list_head list_node;
133  	const struct acpi_device_id *ids;
134  	bool (*match)(const char *idstr, const struct acpi_device_id **matchid);
135  	int (*attach)(struct acpi_device *dev, const struct acpi_device_id *id);
136  	void (*detach)(struct acpi_device *dev);
137  	void (*post_eject)(struct acpi_device *dev);
138  	void (*bind)(struct device *phys_dev);
139  	void (*unbind)(struct device *phys_dev);
140  	struct acpi_hotplug_profile hotplug;
141  };
142  
143  /*
144   * ACPI Hotplug Context
145   * --------------------
146   */
147  
148  typedef int (*acpi_hp_notify) (struct acpi_device *, u32);
149  typedef void (*acpi_hp_uevent) (struct acpi_device *, u32);
150  typedef void (*acpi_hp_fixup) (struct acpi_device *);
151  
152  struct acpi_hotplug_context {
153  	struct acpi_device *self;
154  	acpi_hp_notify notify;
155  	acpi_hp_uevent uevent;
156  	acpi_hp_fixup fixup;
157  };
158  
159  /*
160   * ACPI Driver
161   * -----------
162   */
163  
164  typedef int (*acpi_op_add) (struct acpi_device * device);
165  typedef void (*acpi_op_remove) (struct acpi_device *device);
166  typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
167  
168  struct acpi_device_ops {
169  	acpi_op_add add;
170  	acpi_op_remove remove;
171  	acpi_op_notify notify;
172  };
173  
174  #define ACPI_DRIVER_ALL_NOTIFY_EVENTS	0x1	/* system AND device events */
175  
176  struct acpi_driver {
177  	char name[80];
178  	char class[80];
179  	const struct acpi_device_id *ids; /* Supported Hardware IDs */
180  	unsigned int flags;
181  	struct acpi_device_ops ops;
182  	struct device_driver drv;
183  };
184  
185  /*
186   * ACPI Device
187   * -----------
188   */
189  
190  /* Status (_STA) */
191  
192  struct acpi_device_status {
193  	u32 present:1;
194  	u32 enabled:1;
195  	u32 show_in_ui:1;
196  	u32 functional:1;
197  	u32 battery_present:1;
198  	u32 reserved:27;
199  };
200  
201  /* Flags */
202  
203  struct acpi_device_flags {
204  	u32 dynamic_status:1;
205  	u32 removable:1;
206  	u32 ejectable:1;
207  	u32 power_manageable:1;
208  	u32 match_driver:1;
209  	u32 initialized:1;
210  	u32 visited:1;
211  	u32 hotplug_notify:1;
212  	u32 is_dock_station:1;
213  	u32 of_compatible_ok:1;
214  	u32 coherent_dma:1;
215  	u32 cca_seen:1;
216  	u32 enumeration_by_parent:1;
217  	u32 honor_deps:1;
218  	u32 reserved:18;
219  };
220  
221  /* File System */
222  
223  struct acpi_device_dir {
224  	struct proc_dir_entry *entry;
225  };
226  
227  #define acpi_device_dir(d)	((d)->dir.entry)
228  
229  /* Plug and Play */
230  
231  #define MAX_ACPI_DEVICE_NAME_LEN	40
232  #define MAX_ACPI_CLASS_NAME_LEN		20
233  typedef char acpi_bus_id[8];
234  typedef u64 acpi_bus_address;
235  typedef char acpi_device_name[MAX_ACPI_DEVICE_NAME_LEN];
236  typedef char acpi_device_class[MAX_ACPI_CLASS_NAME_LEN];
237  
238  struct acpi_hardware_id {
239  	struct list_head list;
240  	const char *id;
241  };
242  
243  struct acpi_pnp_type {
244  	u32 hardware_id:1;
245  	u32 bus_address:1;
246  	u32 platform_id:1;
247  	u32 backlight:1;
248  	u32 reserved:28;
249  };
250  
251  struct acpi_device_pnp {
252  	acpi_bus_id bus_id;		/* Object name */
253  	int instance_no;		/* Instance number of this object */
254  	struct acpi_pnp_type type;	/* ID type */
255  	acpi_bus_address bus_address;	/* _ADR */
256  	char *unique_id;		/* _UID */
257  	struct list_head ids;		/* _HID and _CIDs */
258  	acpi_device_name device_name;	/* Driver-determined */
259  	acpi_device_class device_class;	/*        "          */
260  };
261  
262  #define acpi_device_bid(d)	((d)->pnp.bus_id)
263  #define acpi_device_adr(d)	((d)->pnp.bus_address)
264  const char *acpi_device_hid(struct acpi_device *device);
265  #define acpi_device_uid(d)	((d)->pnp.unique_id)
266  #define acpi_device_name(d)	((d)->pnp.device_name)
267  #define acpi_device_class(d)	((d)->pnp.device_class)
268  
269  /* Power Management */
270  
271  struct acpi_device_power_flags {
272  	u32 explicit_get:1;	/* _PSC present? */
273  	u32 power_resources:1;	/* Power resources */
274  	u32 inrush_current:1;	/* Serialize Dx->D0 */
275  	u32 power_removed:1;	/* Optimize Dx->D0 */
276  	u32 ignore_parent:1;	/* Power is independent of parent power state */
277  	u32 dsw_present:1;	/* _DSW present? */
278  	u32 reserved:26;
279  };
280  
281  struct acpi_device_power_state {
282  	struct list_head resources;	/* Power resources referenced */
283  	struct {
284  		u8 valid:1;
285  		u8 explicit_set:1;	/* _PSx present? */
286  		u8 reserved:6;
287  	} flags;
288  	int power;		/* % Power (compared to D0) */
289  	int latency;		/* Dx->D0 time (microseconds) */
290  };
291  
292  struct acpi_device_power {
293  	int state;		/* Current state */
294  	struct acpi_device_power_flags flags;
295  	struct acpi_device_power_state states[ACPI_D_STATE_COUNT];	/* Power states (D0-D3Cold) */
296  	u8 state_for_enumeration; /* Deepest power state for enumeration */
297  };
298  
299  struct acpi_dep_data {
300  	struct list_head node;
301  	acpi_handle supplier;
302  	acpi_handle consumer;
303  	bool honor_dep;
304  	bool met;
305  	bool free_when_met;
306  };
307  
308  /* Performance Management */
309  
310  struct acpi_device_perf_flags {
311  	u8 reserved:8;
312  };
313  
314  struct acpi_device_perf_state {
315  	struct {
316  		u8 valid:1;
317  		u8 reserved:7;
318  	} flags;
319  	u8 power;		/* % Power (compared to P0) */
320  	u8 performance;		/* % Performance (    "   ) */
321  	int latency;		/* Px->P0 time (microseconds) */
322  };
323  
324  struct acpi_device_perf {
325  	int state;
326  	struct acpi_device_perf_flags flags;
327  	int state_count;
328  	struct acpi_device_perf_state *states;
329  };
330  
331  /* Wakeup Management */
332  struct acpi_device_wakeup_flags {
333  	u8 valid:1;		/* Can successfully enable wakeup? */
334  	u8 notifier_present:1;  /* Wake-up notify handler has been installed */
335  };
336  
337  struct acpi_device_wakeup_context {
338  	void (*func)(struct acpi_device_wakeup_context *context);
339  	struct device *dev;
340  };
341  
342  struct acpi_device_wakeup {
343  	acpi_handle gpe_device;
344  	u64 gpe_number;
345  	u64 sleep_state;
346  	struct list_head resources;
347  	struct acpi_device_wakeup_flags flags;
348  	struct acpi_device_wakeup_context context;
349  	struct wakeup_source *ws;
350  	int prepare_count;
351  	int enable_count;
352  };
353  
354  struct acpi_device_physical_node {
355  	struct list_head node;
356  	struct device *dev;
357  	unsigned int node_id;
358  	bool put_online:1;
359  };
360  
361  struct acpi_device_properties {
362  	struct list_head list;
363  	const guid_t *guid;
364  	union acpi_object *properties;
365  	void **bufs;
366  };
367  
368  /* ACPI Device Specific Data (_DSD) */
369  struct acpi_device_data {
370  	const union acpi_object *pointer;
371  	struct list_head properties;
372  	const union acpi_object *of_compatible;
373  	struct list_head subnodes;
374  };
375  
376  struct acpi_gpio_mapping;
377  
378  #define ACPI_DEVICE_SWNODE_ROOT			0
379  
380  /*
381   * The maximum expected number of CSI-2 data lanes.
382   *
383   * This number is not expected to ever have to be equal to or greater than the
384   * number of bits in an unsigned long variable, but if it needs to be increased
385   * above that limit, code will need to be adjusted accordingly.
386   */
387  #define ACPI_DEVICE_CSI2_DATA_LANES		8
388  
389  #define ACPI_DEVICE_SWNODE_PORT_NAME_LENGTH	8
390  
391  enum acpi_device_swnode_dev_props {
392  	ACPI_DEVICE_SWNODE_DEV_ROTATION,
393  	ACPI_DEVICE_SWNODE_DEV_CLOCK_FREQUENCY,
394  	ACPI_DEVICE_SWNODE_DEV_LED_MAX_MICROAMP,
395  	ACPI_DEVICE_SWNODE_DEV_FLASH_MAX_MICROAMP,
396  	ACPI_DEVICE_SWNODE_DEV_FLASH_MAX_TIMEOUT_US,
397  	ACPI_DEVICE_SWNODE_DEV_NUM_OF,
398  	ACPI_DEVICE_SWNODE_DEV_NUM_ENTRIES
399  };
400  
401  enum acpi_device_swnode_port_props {
402  	ACPI_DEVICE_SWNODE_PORT_REG,
403  	ACPI_DEVICE_SWNODE_PORT_NUM_OF,
404  	ACPI_DEVICE_SWNODE_PORT_NUM_ENTRIES
405  };
406  
407  enum acpi_device_swnode_ep_props {
408  	ACPI_DEVICE_SWNODE_EP_REMOTE_EP,
409  	ACPI_DEVICE_SWNODE_EP_BUS_TYPE,
410  	ACPI_DEVICE_SWNODE_EP_REG,
411  	ACPI_DEVICE_SWNODE_EP_CLOCK_LANES,
412  	ACPI_DEVICE_SWNODE_EP_DATA_LANES,
413  	ACPI_DEVICE_SWNODE_EP_LANE_POLARITIES,
414  	/* TX only */
415  	ACPI_DEVICE_SWNODE_EP_LINK_FREQUENCIES,
416  	ACPI_DEVICE_SWNODE_EP_NUM_OF,
417  	ACPI_DEVICE_SWNODE_EP_NUM_ENTRIES
418  };
419  
420  /*
421   * Each device has a root software node plus two times as many nodes as the
422   * number of CSI-2 ports.
423   */
424  #define ACPI_DEVICE_SWNODE_PORT(port)	(2 * (port) + 1)
425  #define ACPI_DEVICE_SWNODE_EP(endpoint)	\
426  		(ACPI_DEVICE_SWNODE_PORT(endpoint) + 1)
427  
428  /**
429   * struct acpi_device_software_node_port - MIPI DisCo for Imaging CSI-2 port
430   * @port_name: Port name.
431   * @data_lanes: "data-lanes" property values.
432   * @lane_polarities: "lane-polarities" property values.
433   * @link_frequencies: "link_frequencies" property values.
434   * @port_nr: Port number.
435   * @crs_crs2_local: _CRS CSI2 record present (i.e. this is a transmitter one).
436   * @port_props: Port properties.
437   * @ep_props: Endpoint properties.
438   * @remote_ep: Reference to the remote endpoint.
439   */
440  struct acpi_device_software_node_port {
441  	char port_name[ACPI_DEVICE_SWNODE_PORT_NAME_LENGTH + 1];
442  	u32 data_lanes[ACPI_DEVICE_CSI2_DATA_LANES];
443  	u32 lane_polarities[ACPI_DEVICE_CSI2_DATA_LANES + 1 /* clock lane */];
444  	u64 link_frequencies[ACPI_DEVICE_CSI2_DATA_LANES];
445  	unsigned int port_nr;
446  	bool crs_csi2_local;
447  
448  	struct property_entry port_props[ACPI_DEVICE_SWNODE_PORT_NUM_ENTRIES];
449  	struct property_entry ep_props[ACPI_DEVICE_SWNODE_EP_NUM_ENTRIES];
450  
451  	struct software_node_ref_args remote_ep[1];
452  };
453  
454  /**
455   * struct acpi_device_software_nodes - Software nodes for an ACPI device
456   * @dev_props: Device properties.
457   * @nodes: Software nodes for root as well as ports and endpoints.
458   * @nodeprts: Array of software node pointers, for (un)registering them.
459   * @ports: Information related to each port and endpoint within a port.
460   * @num_ports: The number of ports.
461   */
462  struct acpi_device_software_nodes {
463  	struct property_entry dev_props[ACPI_DEVICE_SWNODE_DEV_NUM_ENTRIES];
464  	struct software_node *nodes;
465  	const struct software_node **nodeptrs;
466  	struct acpi_device_software_node_port *ports;
467  	unsigned int num_ports;
468  };
469  
470  /* Device */
471  struct acpi_device {
472  	u32 pld_crc;
473  	int device_type;
474  	acpi_handle handle;		/* no handle for fixed hardware */
475  	struct fwnode_handle fwnode;
476  	struct list_head wakeup_list;
477  	struct list_head del_list;
478  	struct acpi_device_status status;
479  	struct acpi_device_flags flags;
480  	struct acpi_device_pnp pnp;
481  	struct acpi_device_power power;
482  	struct acpi_device_wakeup wakeup;
483  	struct acpi_device_perf performance;
484  	struct acpi_device_dir dir;
485  	struct acpi_device_data data;
486  	struct acpi_scan_handler *handler;
487  	struct acpi_hotplug_context *hp;
488  	struct acpi_device_software_nodes *swnodes;
489  	const struct acpi_gpio_mapping *driver_gpios;
490  	void *driver_data;
491  	struct device dev;
492  	unsigned int physical_node_count;
493  	unsigned int dep_unmet;
494  	struct list_head physical_node_list;
495  	struct mutex physical_node_lock;
496  	void (*remove)(struct acpi_device *);
497  };
498  
499  /* Non-device subnode */
500  struct acpi_data_node {
501  	struct list_head sibling;
502  	const char *name;
503  	acpi_handle handle;
504  	struct fwnode_handle fwnode;
505  	struct fwnode_handle *parent;
506  	struct acpi_device_data data;
507  	struct kobject kobj;
508  	struct completion kobj_done;
509  };
510  
511  extern const struct fwnode_operations acpi_device_fwnode_ops;
512  extern const struct fwnode_operations acpi_data_fwnode_ops;
513  extern const struct fwnode_operations acpi_static_fwnode_ops;
514  
515  bool is_acpi_device_node(const struct fwnode_handle *fwnode);
516  bool is_acpi_data_node(const struct fwnode_handle *fwnode);
517  
is_acpi_node(const struct fwnode_handle * fwnode)518  static inline bool is_acpi_node(const struct fwnode_handle *fwnode)
519  {
520  	return (is_acpi_device_node(fwnode) || is_acpi_data_node(fwnode));
521  }
522  
523  #define to_acpi_device_node(__fwnode)					\
524  	({								\
525  		typeof(__fwnode) __to_acpi_device_node_fwnode = __fwnode; \
526  									\
527  		is_acpi_device_node(__to_acpi_device_node_fwnode) ?	\
528  			container_of(__to_acpi_device_node_fwnode,	\
529  				     struct acpi_device, fwnode) :	\
530  			NULL;						\
531  	})
532  
533  #define to_acpi_data_node(__fwnode)					\
534  	({								\
535  		typeof(__fwnode) __to_acpi_data_node_fwnode = __fwnode;	\
536  									\
537  		is_acpi_data_node(__to_acpi_data_node_fwnode) ?		\
538  			container_of(__to_acpi_data_node_fwnode,	\
539  				     struct acpi_data_node, fwnode) :	\
540  			NULL;						\
541  	})
542  
is_acpi_static_node(const struct fwnode_handle * fwnode)543  static inline bool is_acpi_static_node(const struct fwnode_handle *fwnode)
544  {
545  	return !IS_ERR_OR_NULL(fwnode) &&
546  		fwnode->ops == &acpi_static_fwnode_ops;
547  }
548  
acpi_data_node_match(const struct fwnode_handle * fwnode,const char * name)549  static inline bool acpi_data_node_match(const struct fwnode_handle *fwnode,
550  					const char *name)
551  {
552  	return is_acpi_data_node(fwnode) ?
553  		(!strcmp(to_acpi_data_node(fwnode)->name, name)) : false;
554  }
555  
acpi_fwnode_handle(struct acpi_device * adev)556  static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
557  {
558  	return &adev->fwnode;
559  }
560  
acpi_driver_data(struct acpi_device * d)561  static inline void *acpi_driver_data(struct acpi_device *d)
562  {
563  	return d->driver_data;
564  }
565  
566  #define to_acpi_device(d)	container_of(d, struct acpi_device, dev)
567  #define to_acpi_driver(d)	container_of_const(d, struct acpi_driver, drv)
568  
acpi_dev_parent(struct acpi_device * adev)569  static inline struct acpi_device *acpi_dev_parent(struct acpi_device *adev)
570  {
571  	if (adev->dev.parent)
572  		return to_acpi_device(adev->dev.parent);
573  
574  	return NULL;
575  }
576  
acpi_set_device_status(struct acpi_device * adev,u32 sta)577  static inline void acpi_set_device_status(struct acpi_device *adev, u32 sta)
578  {
579  	*((u32 *)&adev->status) = sta;
580  }
581  
acpi_set_hp_context(struct acpi_device * adev,struct acpi_hotplug_context * hp)582  static inline void acpi_set_hp_context(struct acpi_device *adev,
583  				       struct acpi_hotplug_context *hp)
584  {
585  	hp->self = adev;
586  	adev->hp = hp;
587  }
588  
589  void acpi_initialize_hp_context(struct acpi_device *adev,
590  				struct acpi_hotplug_context *hp,
591  				acpi_hp_notify notify, acpi_hp_uevent uevent);
592  
593  /* acpi_device.dev.bus == &acpi_bus_type */
594  extern const struct bus_type acpi_bus_type;
595  
596  int acpi_bus_for_each_dev(int (*fn)(struct device *, void *), void *data);
597  int acpi_dev_for_each_child(struct acpi_device *adev,
598  			    int (*fn)(struct acpi_device *, void *), void *data);
599  int acpi_dev_for_each_child_reverse(struct acpi_device *adev,
600  				    int (*fn)(struct acpi_device *, void *),
601  				    void *data);
602  
603  /*
604   * Events
605   * ------
606   */
607  
608  struct acpi_bus_event {
609  	struct list_head node;
610  	acpi_device_class device_class;
611  	acpi_bus_id bus_id;
612  	u32 type;
613  	u32 data;
614  };
615  
616  extern struct kobject *acpi_kobj;
617  extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
618  void acpi_bus_private_data_handler(acpi_handle, void *);
619  int acpi_bus_get_private_data(acpi_handle, void **);
620  int acpi_bus_attach_private_data(acpi_handle, void *);
621  void acpi_bus_detach_private_data(acpi_handle);
622  int acpi_dev_install_notify_handler(struct acpi_device *adev,
623  				    u32 handler_type,
624  				    acpi_notify_handler handler, void *context);
625  void acpi_dev_remove_notify_handler(struct acpi_device *adev,
626  				    u32 handler_type,
627  				    acpi_notify_handler handler);
628  extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
629  extern int register_acpi_notifier(struct notifier_block *);
630  extern int unregister_acpi_notifier(struct notifier_block *);
631  
632  /*
633   * External Functions
634   */
635  
636  acpi_status acpi_bus_get_status_handle(acpi_handle handle,
637  				       unsigned long long *sta);
638  int acpi_bus_get_status(struct acpi_device *device);
639  
640  int acpi_bus_set_power(acpi_handle handle, int state);
641  const char *acpi_power_state_string(int state);
642  int acpi_device_set_power(struct acpi_device *device, int state);
643  int acpi_bus_init_power(struct acpi_device *device);
644  int acpi_device_fix_up_power(struct acpi_device *device);
645  void acpi_device_fix_up_power_extended(struct acpi_device *adev);
646  void acpi_device_fix_up_power_children(struct acpi_device *adev);
647  int acpi_bus_update_power(acpi_handle handle, int *state_p);
648  int acpi_device_update_power(struct acpi_device *device, int *state_p);
649  bool acpi_bus_power_manageable(acpi_handle handle);
650  void acpi_dev_power_up_children_with_adr(struct acpi_device *adev);
651  u8 acpi_dev_power_state_for_wake(struct acpi_device *adev);
652  int acpi_device_power_add_dependent(struct acpi_device *adev,
653  				    struct device *dev);
654  void acpi_device_power_remove_dependent(struct acpi_device *adev,
655  					struct device *dev);
656  
657  #ifdef CONFIG_PM
658  bool acpi_bus_can_wakeup(acpi_handle handle);
659  #else
acpi_bus_can_wakeup(acpi_handle handle)660  static inline bool acpi_bus_can_wakeup(acpi_handle handle) { return false; }
661  #endif
662  
663  void acpi_scan_lock_acquire(void);
664  void acpi_scan_lock_release(void);
665  void acpi_lock_hp_context(void);
666  void acpi_unlock_hp_context(void);
667  int acpi_scan_add_handler(struct acpi_scan_handler *handler);
668  /*
669   * use a macro to avoid include chaining to get THIS_MODULE
670   */
671  #define acpi_bus_register_driver(drv) \
672  	__acpi_bus_register_driver(drv, THIS_MODULE)
673  int __acpi_bus_register_driver(struct acpi_driver *driver, struct module *owner);
674  void acpi_bus_unregister_driver(struct acpi_driver *driver);
675  int acpi_bus_scan(acpi_handle handle);
676  void acpi_bus_trim(struct acpi_device *start);
677  acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
678  int acpi_match_device_ids(struct acpi_device *device,
679  			  const struct acpi_device_id *ids);
680  void acpi_set_modalias(struct acpi_device *adev, const char *default_id,
681  		       char *modalias, size_t len);
682  
acpi_device_enumerated(struct acpi_device * adev)683  static inline bool acpi_device_enumerated(struct acpi_device *adev)
684  {
685  	return adev && adev->flags.initialized && adev->flags.visited;
686  }
687  
688  /**
689   * module_acpi_driver(acpi_driver) - Helper macro for registering an ACPI driver
690   * @__acpi_driver: acpi_driver struct
691   *
692   * Helper macro for ACPI drivers which do not do anything special in module
693   * init/exit. This eliminates a lot of boilerplate. Each module may only
694   * use this macro once, and calling it replaces module_init() and module_exit()
695   */
696  #define module_acpi_driver(__acpi_driver) \
697  	module_driver(__acpi_driver, acpi_bus_register_driver, \
698  		      acpi_bus_unregister_driver)
699  
700  /*
701   * Bind physical devices with ACPI devices
702   */
703  struct acpi_bus_type {
704  	struct list_head list;
705  	const char *name;
706  	bool (*match)(struct device *dev);
707  	struct acpi_device * (*find_companion)(struct device *);
708  	void (*setup)(struct device *);
709  };
710  int register_acpi_bus_type(struct acpi_bus_type *);
711  int unregister_acpi_bus_type(struct acpi_bus_type *);
712  int acpi_bind_one(struct device *dev, struct acpi_device *adev);
713  int acpi_unbind_one(struct device *dev);
714  
715  enum acpi_bridge_type {
716  	ACPI_BRIDGE_TYPE_PCIE = 1,
717  	ACPI_BRIDGE_TYPE_CXL,
718  };
719  
720  struct acpi_pci_root {
721  	struct acpi_device * device;
722  	struct pci_bus *bus;
723  	u16 segment;
724  	int bridge_type;
725  	struct resource secondary;	/* downstream bus range */
726  
727  	u32 osc_support_set;		/* _OSC state of support bits */
728  	u32 osc_control_set;		/* _OSC state of control bits */
729  	u32 osc_ext_support_set;	/* _OSC state of extended support bits */
730  	u32 osc_ext_control_set;	/* _OSC state of extended control bits */
731  	phys_addr_t mcfg_addr;
732  };
733  
734  /* helper */
735  
736  struct iommu_ops;
737  
738  bool acpi_dma_supported(const struct acpi_device *adev);
739  enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev);
740  int acpi_iommu_fwspec_init(struct device *dev, u32 id,
741  			   struct fwnode_handle *fwnode);
742  int acpi_dma_get_range(struct device *dev, const struct bus_dma_region **map);
743  int acpi_dma_configure_id(struct device *dev, enum dev_dma_attr attr,
744  			   const u32 *input_id);
acpi_dma_configure(struct device * dev,enum dev_dma_attr attr)745  static inline int acpi_dma_configure(struct device *dev,
746  				     enum dev_dma_attr attr)
747  {
748  	return acpi_dma_configure_id(dev, attr, NULL);
749  }
750  struct acpi_device *acpi_find_child_device(struct acpi_device *parent,
751  					   u64 address, bool check_children);
752  struct acpi_device *acpi_find_child_by_adr(struct acpi_device *adev,
753  					   acpi_bus_address adr);
754  int acpi_is_root_bridge(acpi_handle);
755  struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
756  
757  int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
758  int acpi_disable_wakeup_device_power(struct acpi_device *dev);
759  
760  #ifdef CONFIG_X86
761  bool acpi_device_override_status(struct acpi_device *adev, unsigned long long *status);
762  bool acpi_quirk_skip_acpi_ac_and_battery(void);
763  int acpi_install_cmos_rtc_space_handler(acpi_handle handle);
764  void acpi_remove_cmos_rtc_space_handler(acpi_handle handle);
765  int acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip);
766  #else
acpi_device_override_status(struct acpi_device * adev,unsigned long long * status)767  static inline bool acpi_device_override_status(struct acpi_device *adev,
768  					       unsigned long long *status)
769  {
770  	return false;
771  }
acpi_quirk_skip_acpi_ac_and_battery(void)772  static inline bool acpi_quirk_skip_acpi_ac_and_battery(void)
773  {
774  	return false;
775  }
acpi_install_cmos_rtc_space_handler(acpi_handle handle)776  static inline int acpi_install_cmos_rtc_space_handler(acpi_handle handle)
777  {
778  	return 1;
779  }
acpi_remove_cmos_rtc_space_handler(acpi_handle handle)780  static inline void acpi_remove_cmos_rtc_space_handler(acpi_handle handle)
781  {
782  }
783  static inline int
acpi_quirk_skip_serdev_enumeration(struct device * controller_parent,bool * skip)784  acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip)
785  {
786  	*skip = false;
787  	return 0;
788  }
789  #endif
790  
791  #if IS_ENABLED(CONFIG_X86_ANDROID_TABLETS)
792  bool acpi_quirk_skip_i2c_client_enumeration(struct acpi_device *adev);
793  bool acpi_quirk_skip_gpio_event_handlers(void);
794  #else
acpi_quirk_skip_i2c_client_enumeration(struct acpi_device * adev)795  static inline bool acpi_quirk_skip_i2c_client_enumeration(struct acpi_device *adev)
796  {
797  	return false;
798  }
acpi_quirk_skip_gpio_event_handlers(void)799  static inline bool acpi_quirk_skip_gpio_event_handlers(void)
800  {
801  	return false;
802  }
803  #endif
804  
805  #ifdef CONFIG_PM
806  void acpi_pm_wakeup_event(struct device *dev);
807  acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
808  			void (*func)(struct acpi_device_wakeup_context *context));
809  acpi_status acpi_remove_pm_notifier(struct acpi_device *adev);
810  bool acpi_pm_device_can_wakeup(struct device *dev);
811  int acpi_pm_device_sleep_state(struct device *, int *, int);
812  int acpi_pm_set_device_wakeup(struct device *dev, bool enable);
813  #else
acpi_pm_wakeup_event(struct device * dev)814  static inline void acpi_pm_wakeup_event(struct device *dev)
815  {
816  }
acpi_add_pm_notifier(struct acpi_device * adev,struct device * dev,void (* func)(struct acpi_device_wakeup_context * context))817  static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
818  					       struct device *dev,
819  					       void (*func)(struct acpi_device_wakeup_context *context))
820  {
821  	return AE_SUPPORT;
822  }
acpi_remove_pm_notifier(struct acpi_device * adev)823  static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
824  {
825  	return AE_SUPPORT;
826  }
acpi_pm_device_can_wakeup(struct device * dev)827  static inline bool acpi_pm_device_can_wakeup(struct device *dev)
828  {
829  	return false;
830  }
acpi_pm_device_sleep_state(struct device * d,int * p,int m)831  static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
832  {
833  	if (p)
834  		*p = ACPI_STATE_D0;
835  
836  	return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3_COLD) ?
837  		m : ACPI_STATE_D0;
838  }
acpi_pm_set_device_wakeup(struct device * dev,bool enable)839  static inline int acpi_pm_set_device_wakeup(struct device *dev, bool enable)
840  {
841  	return -ENODEV;
842  }
843  #endif
844  
845  #ifdef CONFIG_ACPI_SYSTEM_POWER_STATES_SUPPORT
846  bool acpi_sleep_state_supported(u8 sleep_state);
847  #else
acpi_sleep_state_supported(u8 sleep_state)848  static inline bool acpi_sleep_state_supported(u8 sleep_state) { return false; }
849  #endif
850  
851  #ifdef CONFIG_ACPI_SLEEP
852  u32 acpi_target_system_state(void);
853  #else
acpi_target_system_state(void)854  static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
855  #endif
856  
acpi_device_power_manageable(struct acpi_device * adev)857  static inline bool acpi_device_power_manageable(struct acpi_device *adev)
858  {
859  	return adev->flags.power_manageable;
860  }
861  
acpi_device_can_wakeup(struct acpi_device * adev)862  static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
863  {
864  	return adev->wakeup.flags.valid;
865  }
866  
acpi_device_can_poweroff(struct acpi_device * adev)867  static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
868  {
869  	return adev->power.states[ACPI_STATE_D3_COLD].flags.valid ||
870  		((acpi_gbl_FADT.header.revision < 6) &&
871  		adev->power.states[ACPI_STATE_D3_HOT].flags.explicit_set);
872  }
873  
874  int acpi_dev_uid_to_integer(struct acpi_device *adev, u64 *integer);
875  
acpi_dev_hid_match(struct acpi_device * adev,const char * hid2)876  static inline bool acpi_dev_hid_match(struct acpi_device *adev, const char *hid2)
877  {
878  	const char *hid1 = acpi_device_hid(adev);
879  
880  	return hid1 && hid2 && !strcmp(hid1, hid2);
881  }
882  
acpi_str_uid_match(struct acpi_device * adev,const char * uid2)883  static inline bool acpi_str_uid_match(struct acpi_device *adev, const char *uid2)
884  {
885  	const char *uid1 = acpi_device_uid(adev);
886  
887  	return uid1 && uid2 && !strcmp(uid1, uid2);
888  }
889  
acpi_int_uid_match(struct acpi_device * adev,u64 uid2)890  static inline bool acpi_int_uid_match(struct acpi_device *adev, u64 uid2)
891  {
892  	u64 uid1;
893  
894  	return !acpi_dev_uid_to_integer(adev, &uid1) && uid1 == uid2;
895  }
896  
897  #define TYPE_ENTRY(type, x)			\
898  	const type: x,				\
899  	type: x
900  
901  #define ACPI_STR_TYPES(match)			\
902  	TYPE_ENTRY(unsigned char *, match),	\
903  	TYPE_ENTRY(signed char *, match),		\
904  	TYPE_ENTRY(char *, match),		\
905  	TYPE_ENTRY(void *, match)
906  
907  /**
908   * acpi_dev_uid_match - Match device by supplied UID
909   * @adev: ACPI device to match.
910   * @uid2: Unique ID of the device.
911   *
912   * Matches UID in @adev with given @uid2.
913   *
914   * Returns: %true if matches, %false otherwise.
915   */
916  #define acpi_dev_uid_match(adev, uid2)					\
917  	_Generic(uid2,							\
918  		 /* Treat @uid2 as a string for acpi string types */	\
919  		 ACPI_STR_TYPES(acpi_str_uid_match),			\
920  		 /* Treat as an integer otherwise */			\
921  		 default: acpi_int_uid_match)(adev, uid2)
922  
923  /**
924   * acpi_dev_hid_uid_match - Match device by supplied HID and UID
925   * @adev: ACPI device to match.
926   * @hid2: Hardware ID of the device.
927   * @uid2: Unique ID of the device, pass NULL to not check _UID.
928   *
929   * Matches HID and UID in @adev with given @hid2 and @uid2. Absence of @uid2
930   * will be treated as a match. If user wants to validate @uid2, it should be
931   * done before calling this function.
932   *
933   * Returns: %true if matches or @uid2 is NULL, %false otherwise.
934   */
935  #define acpi_dev_hid_uid_match(adev, hid2, uid2)			\
936  	(acpi_dev_hid_match(adev, hid2) &&				\
937  		/* Distinguish integer 0 from NULL @uid2 */		\
938  		(_Generic(uid2,	ACPI_STR_TYPES(!(uid2)), default: 0) ||	\
939  		acpi_dev_uid_match(adev, uid2)))
940  
941  void acpi_dev_clear_dependencies(struct acpi_device *supplier);
942  bool acpi_dev_ready_for_enumeration(const struct acpi_device *device);
943  struct acpi_device *acpi_dev_get_next_consumer_dev(struct acpi_device *supplier,
944  						   struct acpi_device *start);
945  
946  /**
947   * for_each_acpi_consumer_dev - iterate over the consumer ACPI devices for a
948   *				given supplier
949   * @supplier: Pointer to the supplier's ACPI device
950   * @consumer: Pointer to &struct acpi_device to hold the consumer, initially NULL
951   */
952  #define for_each_acpi_consumer_dev(supplier, consumer)			\
953  	for (consumer = acpi_dev_get_next_consumer_dev(supplier, NULL);	\
954  	     consumer;							\
955  	     consumer = acpi_dev_get_next_consumer_dev(supplier, consumer))
956  
957  struct acpi_device *
958  acpi_dev_get_next_match_dev(struct acpi_device *adev, const char *hid, const char *uid, s64 hrv);
959  struct acpi_device *
960  acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv);
961  
962  /**
963   * for_each_acpi_dev_match - iterate over ACPI devices that matching the criteria
964   * @adev: pointer to the matching ACPI device, NULL at the end of the loop
965   * @hid: Hardware ID of the device.
966   * @uid: Unique ID of the device, pass NULL to not check _UID
967   * @hrv: Hardware Revision of the device, pass -1 to not check _HRV
968   *
969   * The caller is responsible for invoking acpi_dev_put() on the returned device.
970   */
971  #define for_each_acpi_dev_match(adev, hid, uid, hrv)			\
972  	for (adev = acpi_dev_get_first_match_dev(hid, uid, hrv);	\
973  	     adev;							\
974  	     adev = acpi_dev_get_next_match_dev(adev, hid, uid, hrv))
975  
acpi_dev_get(struct acpi_device * adev)976  static inline struct acpi_device *acpi_dev_get(struct acpi_device *adev)
977  {
978  	return adev ? to_acpi_device(get_device(&adev->dev)) : NULL;
979  }
980  
acpi_dev_put(struct acpi_device * adev)981  static inline void acpi_dev_put(struct acpi_device *adev)
982  {
983  	if (adev)
984  		put_device(&adev->dev);
985  }
986  
987  struct acpi_device *acpi_fetch_acpi_dev(acpi_handle handle);
988  struct acpi_device *acpi_get_acpi_dev(acpi_handle handle);
989  
acpi_put_acpi_dev(struct acpi_device * adev)990  static inline void acpi_put_acpi_dev(struct acpi_device *adev)
991  {
992  	acpi_dev_put(adev);
993  }
994  
995  int acpi_wait_for_acpi_ipmi(void);
996  
997  int acpi_scan_add_dep(acpi_handle handle, struct acpi_handle_list *dep_devices);
998  u32 arch_acpi_add_auto_dep(acpi_handle handle);
999  #else	/* CONFIG_ACPI */
1000  
register_acpi_bus_type(void * bus)1001  static inline int register_acpi_bus_type(void *bus) { return 0; }
unregister_acpi_bus_type(void * bus)1002  static inline int unregister_acpi_bus_type(void *bus) { return 0; }
1003  
acpi_wait_for_acpi_ipmi(void)1004  static inline int acpi_wait_for_acpi_ipmi(void) { return 0; }
1005  
1006  #endif				/* CONFIG_ACPI */
1007  
1008  #endif /*__ACPI_BUS_H__*/
1009