// SPDX-License-Identifier: GPL-2.0-or-later /* * acpi_utils.c - ACPI Utility Functions ($Revision: 10 $) * * Copyright (C) 2001, 2002 Andy Grover <[email protected]> * Copyright (C) 2001, 2002 Paul Diefenbaugh <[email protected]> */ #define pr_fmt(fmt) … #include <linux/kernel.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/init.h> #include <linux/types.h> #include <linux/hardirq.h> #include <linux/acpi.h> #include <linux/dynamic_debug.h> #include "internal.h" #include "sleep.h" /* -------------------------------------------------------------------------- Object Evaluation Helpers -------------------------------------------------------------------------- */ static void acpi_util_eval_error(acpi_handle h, acpi_string p, acpi_status s) { … } acpi_status acpi_extract_package(union acpi_object *package, struct acpi_buffer *format, struct acpi_buffer *buffer) { … } EXPORT_SYMBOL(…); acpi_status acpi_evaluate_integer(acpi_handle handle, acpi_string pathname, struct acpi_object_list *arguments, unsigned long long *data) { … } EXPORT_SYMBOL(…); int acpi_get_local_u64_address(acpi_handle handle, u64 *addr) { … } EXPORT_SYMBOL(…); int acpi_get_local_address(acpi_handle handle, u32 *addr) { … } EXPORT_SYMBOL(…); #define ACPI_MAX_SUB_BUF_SIZE … const char *acpi_get_subsystem_id(acpi_handle handle) { … } EXPORT_SYMBOL_GPL(…); bool acpi_evaluate_reference(acpi_handle handle, acpi_string pathname, struct acpi_object_list *arguments, struct acpi_handle_list *list) { … } EXPORT_SYMBOL(…); /** * acpi_handle_list_equal - Check if two ACPI handle lists are the same * @list1: First list to compare. * @list2: Second list to compare. * * Return true if the given ACPI handle lists are of the same size and * contain the same ACPI handles in the same order. Otherwise, return false. */ bool acpi_handle_list_equal(struct acpi_handle_list *list1, struct acpi_handle_list *list2) { … } EXPORT_SYMBOL_GPL(…); /** * acpi_handle_list_replace - Replace one ACPI handle list with another * @dst: ACPI handle list to replace. * @src: Source ACPI handle list. * * Free the handles table in @dst, move the handles table from @src to @dst, * copy count from @src to @dst and clear @src. */ void acpi_handle_list_replace(struct acpi_handle_list *dst, struct acpi_handle_list *src) { … } EXPORT_SYMBOL_GPL(…); /** * acpi_handle_list_free - Free the handles table in an ACPI handle list * @list: ACPI handle list to free. * * Free the handles table in @list and clear its count field. */ void acpi_handle_list_free(struct acpi_handle_list *list) { … } EXPORT_SYMBOL_GPL(…); /** * acpi_device_dep - Check ACPI device dependency * @target: ACPI handle of the target ACPI device. * @match: ACPI handle to look up in the target's _DEP list. * * Return true if @match is present in the list returned by _DEP for * @target or false otherwise. */ bool acpi_device_dep(acpi_handle target, acpi_handle match) { … } EXPORT_SYMBOL_GPL(…); acpi_status acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld) { … } EXPORT_SYMBOL(…); /** * acpi_evaluate_ost: Evaluate _OST for hotplug operations * @handle: ACPI device handle * @source_event: source event code * @status_code: status code * @status_buf: optional detailed information (NULL if none) * * Evaluate _OST for hotplug operations. All ACPI hotplug handlers * must call this function when evaluating _OST for hotplug operations. * When the platform does not support _OST, this function has no effect. */ acpi_status acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code, struct acpi_buffer *status_buf) { … } EXPORT_SYMBOL(…); /** * acpi_handle_path: Return the object path of handle * @handle: ACPI device handle * * Caller must free the returned buffer */ char *acpi_handle_path(acpi_handle handle) { … } /** * acpi_handle_printk: Print message with ACPI prefix and object path * @level: log level * @handle: ACPI device handle * @fmt: format string * * This function is called through acpi_handle_<level> macros and prints * a message with ACPI prefix and object path. This function acquires * the global namespace mutex to obtain an object path. In interrupt * context, it shows the object path as <n/a>. */ void acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...) { … } EXPORT_SYMBOL(…); #if defined(CONFIG_DYNAMIC_DEBUG) /** * __acpi_handle_debug: pr_debug with ACPI prefix and object path * @descriptor: Dynamic Debug descriptor * @handle: ACPI device handle * @fmt: format string * * This function is called through acpi_handle_debug macro and debug * prints a message with ACPI prefix and object path. This function * acquires the global namespace mutex to obtain an object path. In * interrupt context, it shows the object path as <n/a>. */ void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...) { … } EXPORT_SYMBOL(…); #endif /** * acpi_evaluation_failure_warn - Log evaluation failure warning. * @handle: Parent object handle. * @name: Name of the object whose evaluation has failed. * @status: Status value returned by the failing object evaluation. */ void acpi_evaluation_failure_warn(acpi_handle handle, const char *name, acpi_status status) { … } EXPORT_SYMBOL_GPL(…); /** * acpi_has_method: Check whether @handle has a method named @name * @handle: ACPI device handle * @name: name of object or method * * Check whether @handle has a method named @name. */ bool acpi_has_method(acpi_handle handle, char *name) { … } EXPORT_SYMBOL(…); acpi_status acpi_execute_simple_method(acpi_handle handle, char *method, u64 arg) { … } EXPORT_SYMBOL(…); /** * acpi_evaluate_ej0: Evaluate _EJ0 method for hotplug operations * @handle: ACPI device handle * * Evaluate device's _EJ0 method for hotplug operations. */ acpi_status acpi_evaluate_ej0(acpi_handle handle) { … } /** * acpi_evaluate_lck: Evaluate _LCK method to lock/unlock device * @handle: ACPI device handle * @lock: lock device if non-zero, otherwise unlock device * * Evaluate device's _LCK method if present to lock/unlock device */ acpi_status acpi_evaluate_lck(acpi_handle handle, int lock) { … } /** * acpi_evaluate_reg: Evaluate _REG method to register OpRegion presence * @handle: ACPI device handle * @space_id: ACPI address space id to register OpRegion presence for * @function: Parameter to pass to _REG one of ACPI_REG_CONNECT or * ACPI_REG_DISCONNECT * * Evaluate device's _REG method to register OpRegion presence. */ acpi_status acpi_evaluate_reg(acpi_handle handle, u8 space_id, u32 function) { … } EXPORT_SYMBOL(…); /** * acpi_evaluate_dsm - evaluate device's _DSM method * @handle: ACPI device handle * @guid: GUID of requested functions, should be 16 bytes * @rev: revision number of requested function * @func: requested function number * @argv4: the function specific parameter * * Evaluate device's _DSM method with specified GUID, revision id and * function number. Caller needs to free the returned object. * * Though ACPI defines the fourth parameter for _DSM should be a package, * some old BIOSes do expect a buffer or an integer etc. */ union acpi_object * acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 func, union acpi_object *argv4) { … } EXPORT_SYMBOL(…); /** * acpi_check_dsm - check if _DSM method supports requested functions. * @handle: ACPI device handle * @guid: GUID of requested functions, should be 16 bytes at least * @rev: revision number of requested functions * @funcs: bitmap of requested functions * * Evaluate device's _DSM method to check whether it supports requested * functions. Currently only support 64 functions at maximum, should be * enough for now. */ bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs) { … } EXPORT_SYMBOL(…); /** * acpi_dev_uid_to_integer - treat ACPI device _UID as integer * @adev: ACPI device to get _UID from * @integer: output buffer for integer * * Considers _UID as integer and converts it to @integer. * * Returns 0 on success, or negative error code otherwise. */ int acpi_dev_uid_to_integer(struct acpi_device *adev, u64 *integer) { … } EXPORT_SYMBOL(…); /** * acpi_dev_found - Detect presence of a given ACPI device in the namespace. * @hid: Hardware ID of the device. * * Return %true if the device was present at the moment of invocation. * Note that if the device is pluggable, it may since have disappeared. * * For this function to work, acpi_bus_scan() must have been executed * which happens in the subsys_initcall() subsection. Hence, do not * call from a subsys_initcall() or earlier (use acpi_get_devices() * instead). Calling from module_init() is fine (which is synonymous * with device_initcall()). */ bool acpi_dev_found(const char *hid) { … } EXPORT_SYMBOL(…); struct acpi_dev_match_info { … }; static int acpi_dev_match_cb(struct device *dev, const void *data) { … } /** * acpi_dev_present - Detect that a given ACPI device is present * @hid: Hardware ID of the device. * @uid: Unique ID of the device, pass NULL to not check _UID * @hrv: Hardware Revision of the device, pass -1 to not check _HRV * * Return %true if a matching device was present at the moment of invocation. * Note that if the device is pluggable, it may since have disappeared. * * Note that unlike acpi_dev_found() this function checks the status * of the device. So for devices which are present in the DSDT, but * which are disabled (their _STA callback returns 0) this function * will return false. * * For this function to work, acpi_bus_scan() must have been executed * which happens in the subsys_initcall() subsection. Hence, do not * call from a subsys_initcall() or earlier (use acpi_get_devices() * instead). Calling from module_init() is fine (which is synonymous * with device_initcall()). */ bool acpi_dev_present(const char *hid, const char *uid, s64 hrv) { … } EXPORT_SYMBOL(…); /** * acpi_dev_get_next_match_dev - Return the next match of ACPI device * @adev: Pointer to the previous ACPI device matching this @hid, @uid and @hrv * @hid: Hardware ID of the device. * @uid: Unique ID of the device, pass NULL to not check _UID * @hrv: Hardware Revision of the device, pass -1 to not check _HRV * * Return the next match of ACPI device if another matching device was present * at the moment of invocation, or NULL otherwise. * * The caller is responsible for invoking acpi_dev_put() on the returned device. * On the other hand the function invokes acpi_dev_put() on the given @adev * assuming that its reference counter had been increased beforehand. * * See additional information in acpi_dev_present() as well. */ struct acpi_device * acpi_dev_get_next_match_dev(struct acpi_device *adev, const char *hid, const char *uid, s64 hrv) { … } EXPORT_SYMBOL(…); /** * acpi_dev_get_first_match_dev - Return the first match of ACPI device * @hid: Hardware ID of the device. * @uid: Unique ID of the device, pass NULL to not check _UID * @hrv: Hardware Revision of the device, pass -1 to not check _HRV * * Return the first match of ACPI device if a matching device was present * at the moment of invocation, or NULL otherwise. * * The caller is responsible for invoking acpi_dev_put() on the returned device. * * See additional information in acpi_dev_present() as well. */ struct acpi_device * acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv) { … } EXPORT_SYMBOL(…); /** * acpi_reduced_hardware - Return if this is an ACPI-reduced-hw machine * * Return true when running on an ACPI-reduced-hw machine, false otherwise. */ bool acpi_reduced_hardware(void) { … } EXPORT_SYMBOL_GPL(…); /* * acpi_backlight= handling, this is done here rather then in video_detect.c * because __setup cannot be used in modules. */ char acpi_video_backlight_string[16]; EXPORT_SYMBOL(…); static int __init acpi_backlight(char *str) { … } __setup(…); /** * acpi_match_platform_list - Check if the system matches with a given list * @plat: pointer to acpi_platform_list table terminated by a NULL entry * * Return the matched index if the system is found in the platform list. * Otherwise, return a negative error code. */ int acpi_match_platform_list(const struct acpi_platform_list *plat) { … } EXPORT_SYMBOL(…);
Codebase Browser
linux