/* * Copyright 2012 Advanced Micro Devices, Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. * */ #include <linux/pci.h>#include <linux/acpi.h>#include <linux/slab.h>#include <linux/power_supply.h>#include <linux/pm_runtime.h>#include <acpi/video.h>#include <acpi/actbl.h> #include <drm/drm_crtc_helper.h>#include "amdgpu.h"#include "amdgpu_pm.h"#include "amdgpu_display.h"#include "amd_acpi.h"#include "atom.h" struct amdgpu_atif_notification_cfg {	bool enabled;	int command_code;}; struct amdgpu_atif_notifications {	bool thermal_state;	bool forced_power_state;	bool system_power_state;	bool brightness_change;	bool dgpu_display_event;	bool gpu_package_power_limit;}; struct amdgpu_atif_functions {	bool system_params;	bool sbios_requests;	bool temperature_change;	bool query_backlight_transfer_characteristics;	bool ready_to_undock;	bool external_gpu_information;}; struct amdgpu_atif {	acpi_handle handle; 	struct amdgpu_atif_notifications notifications;	struct amdgpu_atif_functions functions;	struct amdgpu_atif_notification_cfg notification_cfg;#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE)	struct backlight_device *bd;#endif	struct amdgpu_dm_backlight_caps backlight_caps;}; /* Call the ATIF method *//** * amdgpu_atif_call - call an ATIF method * * @handle: acpi handle * @function: the ATIF function to execute * @params: ATIF function params * * Executes the requested ATIF function (all asics). * Returns a pointer to the acpi output buffer. */static union acpi_object *amdgpu_atif_call(struct amdgpu_atif *atif,					   int function,					   struct acpi_buffer *params){	acpi_status status;	union acpi_object atif_arg_elements[2];	struct acpi_object_list atif_arg;	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 	atif_arg.count = 2;	atif_arg.pointer = &atif_arg_elements[0]; 	atif_arg_elements[0].type = ACPI_TYPE_INTEGER;	atif_arg_elements[0].integer.value = function; 	if (params) {		atif_arg_elements[1].type = ACPI_TYPE_BUFFER;		atif_arg_elements[1].buffer.length = params->length;		atif_arg_elements[1].buffer.pointer = params->pointer;	} else {		/* We need a second fake parameter */		atif_arg_elements[1].type = ACPI_TYPE_INTEGER;		atif_arg_elements[1].integer.value = 0;	} 	status = acpi_evaluate_object(atif->handle, NULL, &atif_arg,				      &buffer); 	/* Fail only if calling the method fails and ATIF is supported */	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {		DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n",				 acpi_format_exception(status));		kfree(buffer.pointer);		return NULL;	} 	return buffer.pointer;} /** * amdgpu_atif_parse_notification - parse supported notifications * * @n: supported notifications struct * @mask: supported notifications mask from ATIF * * Use the supported notifications mask from ATIF function * ATIF_FUNCTION_VERIFY_INTERFACE to determine what notifications * are supported (all asics). */static void amdgpu_atif_parse_notification(struct amdgpu_atif_notifications *n, u32 mask){	n->thermal_state = mask & ATIF_THERMAL_STATE_CHANGE_REQUEST_SUPPORTED;	n->forced_power_state = mask & ATIF_FORCED_POWER_STATE_CHANGE_REQUEST_SUPPORTED;	n->system_power_state = mask & ATIF_SYSTEM_POWER_SOURCE_CHANGE_REQUEST_SUPPORTED;	n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED;	n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED;	n->gpu_package_power_limit = mask & ATIF_GPU_PACKAGE_POWER_LIMIT_REQUEST_SUPPORTED;} /** * amdgpu_atif_parse_functions - parse supported functions * * @f: supported functions struct * @mask: supported functions mask from ATIF * * Use the supported functions mask from ATIF function * ATIF_FUNCTION_VERIFY_INTERFACE to determine what functions * are supported (all asics). */static void amdgpu_atif_parse_functions(struct amdgpu_atif_functions *f, u32 mask){	f->system_params = mask & ATIF_GET_SYSTEM_PARAMETERS_SUPPORTED;	f->sbios_requests = mask & ATIF_GET_SYSTEM_BIOS_REQUESTS_SUPPORTED;	f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED;	f->query_backlight_transfer_characteristics =		mask & ATIF_QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS_SUPPORTED;	f->ready_to_undock = mask & ATIF_READY_TO_UNDOCK_NOTIFICATION_SUPPORTED;	f->external_gpu_information = mask & ATIF_GET_EXTERNAL_GPU_INFORMATION_SUPPORTED;} /** * amdgpu_atif_verify_interface - verify ATIF * * @handle: acpi handle * @atif: amdgpu atif struct * * Execute the ATIF_FUNCTION_VERIFY_INTERFACE ATIF function * to initialize ATIF and determine what features are supported * (all asics). * returns 0 on success, error on failure. */static int amdgpu_atif_verify_interface(struct amdgpu_atif *atif){	union acpi_object *info;	struct atif_verify_interface output;	size_t size;	int err = 0; 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_VERIFY_INTERFACE, NULL);	if (!info)		return -EIO; 	memset(&output, 0, sizeof(output)); 	size = *(u16 *) info->buffer.pointer;	if (size < 12) {		DRM_INFO("ATIF buffer is too small: %zu\n", size);		err = -EINVAL;		goto out;	}	size = min(sizeof(output), size); 	memcpy(&output, info->buffer.pointer, size); 	/* TODO: check version? */	DRM_DEBUG_DRIVER("ATIF version %u\n", output.version); 	amdgpu_atif_parse_notification(&atif->notifications, output.notification_mask);	amdgpu_atif_parse_functions(&atif->functions, output.function_bits); out:	kfree(info);	return err;} static acpi_handle amdgpu_atif_probe_handle(acpi_handle dhandle){	acpi_handle handle = NULL;	char acpi_method_name[255] = { 0 };	struct acpi_buffer buffer = { sizeof(acpi_method_name), acpi_method_name };	acpi_status status; 	/* For PX/HG systems, ATIF and ATPX are in the iGPU's namespace, on dGPU only	 * systems, ATIF is in the dGPU's namespace.	 */	status = acpi_get_handle(dhandle, "ATIF", &handle);	if (ACPI_SUCCESS(status))		goto out; 	if (amdgpu_has_atpx()) {		status = acpi_get_handle(amdgpu_atpx_get_dhandle(), "ATIF",					 &handle);		if (ACPI_SUCCESS(status))			goto out;	} 	DRM_DEBUG_DRIVER("No ATIF handle found\n");	return NULL;out:	acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);	DRM_DEBUG_DRIVER("Found ATIF handle %s\n", acpi_method_name);	return handle;} /** * amdgpu_atif_get_notification_params - determine notify configuration * * @handle: acpi handle * @n: atif notification configuration struct * * Execute the ATIF_FUNCTION_GET_SYSTEM_PARAMETERS ATIF function * to determine if a notifier is used and if so which one * (all asics).  This is either Notify(VGA, 0x81) or Notify(VGA, n) * where n is specified in the result if a notifier is used. * Returns 0 on success, error on failure. */static int amdgpu_atif_get_notification_params(struct amdgpu_atif *atif){	union acpi_object *info;	struct amdgpu_atif_notification_cfg *n = &atif->notification_cfg;	struct atif_system_params params;	size_t size;	int err = 0; 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS,				NULL);	if (!info) {		err = -EIO;		goto out;	} 	size = *(u16 *) info->buffer.pointer;	if (size < 10) {		err = -EINVAL;		goto out;	} 	memset(&params, 0, sizeof(params));	size = min(sizeof(params), size);	memcpy(&params, info->buffer.pointer, size); 	DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n",			params.flags, params.valid_mask);	params.flags = params.flags & params.valid_mask; 	if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_NONE) {		n->enabled = false;		n->command_code = 0;	} else if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_81) {		n->enabled = true;		n->command_code = 0x81;	} else {		if (size < 11) {			err = -EINVAL;			goto out;		}		n->enabled = true;		n->command_code = params.command_code;	} out:	DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n",			(n->enabled ? "enabled" : "disabled"),			n->command_code);	kfree(info);	return err;} /** * amdgpu_atif_query_backlight_caps - get min and max backlight input signal * * @handle: acpi handle * * Execute the QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS ATIF function * to determine the acceptable range of backlight values * * Backlight_caps.caps_valid will be set to true if the query is successful * * The input signals are in range 0-255 * * This function assumes the display with backlight is the first LCD * * Returns 0 on success, error on failure. */static int amdgpu_atif_query_backlight_caps(struct amdgpu_atif *atif){	union acpi_object *info;	struct atif_qbtc_output characteristics;	struct atif_qbtc_arguments arguments;	struct acpi_buffer params;	size_t size;	int err = 0; 	arguments.size = sizeof(arguments);	arguments.requested_display = ATIF_QBTC_REQUEST_LCD1; 	params.length = sizeof(arguments);	params.pointer = (void *)&arguments; 	info = amdgpu_atif_call(atif,		ATIF_FUNCTION_QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS,		&params);	if (!info) {		err = -EIO;		goto out;	} 	size = *(u16 *) info->buffer.pointer;	if (size < 10) {		err = -EINVAL;		goto out;	} 	memset(&characteristics, 0, sizeof(characteristics));	size = min(sizeof(characteristics), size);	memcpy(&characteristics, info->buffer.pointer, size); 	atif->backlight_caps.caps_valid = true;	atif->backlight_caps.min_input_signal =			characteristics.min_input_signal;	atif->backlight_caps.max_input_signal =			characteristics.max_input_signal;out:	kfree(info);	return err;} /** * amdgpu_atif_get_sbios_requests - get requested sbios event * * @handle: acpi handle * @req: atif sbios request struct * * Execute the ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS ATIF function * to determine what requests the sbios is making to the driver * (all asics). * Returns 0 on success, error on failure. */static int amdgpu_atif_get_sbios_requests(struct amdgpu_atif *atif,					  struct atif_sbios_requests *req){	union acpi_object *info;	size_t size;	int count = 0; 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS,				NULL);	if (!info)		return -EIO; 	size = *(u16 *)info->buffer.pointer;	if (size < 0xd) {		count = -EINVAL;		goto out;	}	memset(req, 0, sizeof(*req)); 	size = min(sizeof(*req), size);	memcpy(req, info->buffer.pointer, size);	DRM_DEBUG_DRIVER("SBIOS pending requests: %#x\n", req->pending); 	count = hweight32(req->pending); out:	kfree(info);	return count;} /** * amdgpu_atif_handler - handle ATIF notify requests * * @adev: amdgpu_device pointer * @event: atif sbios request struct * * Checks the acpi event and if it matches an atif event, * handles it. * * Returns: * NOTIFY_BAD or NOTIFY_DONE, depending on the event. */static int amdgpu_atif_handler(struct amdgpu_device *adev,			       struct acpi_bus_event *event){	struct amdgpu_atif *atif = adev->atif;	int count; 	DRM_DEBUG_DRIVER("event, device_class = %s, type = %#x\n",			event->device_class, event->type); 	if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)		return NOTIFY_DONE; 	/* Is this actually our event? */	if (!atif ||	    !atif->notification_cfg.enabled ||	    event->type != atif->notification_cfg.command_code) {		/* These events will generate keypresses otherwise */		if (event->type == ACPI_VIDEO_NOTIFY_PROBE)			return NOTIFY_BAD;		else			return NOTIFY_DONE;	} 	if (atif->functions.sbios_requests) {		struct atif_sbios_requests req; 		/* Check pending SBIOS requests */		count = amdgpu_atif_get_sbios_requests(atif, &req); 		if (count <= 0)			return NOTIFY_BAD; 		DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count); 		if (req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) {#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE)			if (atif->bd) {				DRM_DEBUG_DRIVER("Changing brightness to %d\n",						 req.backlight_level);				/*				 * XXX backlight_device_set_brightness() is				 * hardwired to post BACKLIGHT_UPDATE_SYSFS.				 * It probably should accept 'reason' parameter.				 */				backlight_device_set_brightness(atif->bd, req.backlight_level);			}#endif		} 		if (req.pending & ATIF_DGPU_DISPLAY_EVENT) {			if (adev->flags & AMD_IS_PX) {				pm_runtime_get_sync(adev_to_drm(adev)->dev);				/* Just fire off a uevent and let userspace tell us what to do */				drm_helper_hpd_irq_event(adev_to_drm(adev));				pm_runtime_mark_last_busy(adev_to_drm(adev)->dev);				pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);			}		}		/* TODO: check other events */	} 	/* We've handled the event, stop the notifier chain. The ACPI interface	 * overloads ACPI_VIDEO_NOTIFY_PROBE, we don't want to send that to	 * userspace if the event was generated only to signal a SBIOS	 * request.	 */	return NOTIFY_BAD;} /* Call the ATCS method *//** * amdgpu_atcs_call - call an ATCS method * * @handle: acpi handle * @function: the ATCS function to execute * @params: ATCS function params * * Executes the requested ATCS function (all asics). * Returns a pointer to the acpi output buffer. */static union acpi_object *amdgpu_atcs_call(acpi_handle handle, int function,					   struct acpi_buffer *params){	acpi_status status;

Lines 1–500 of 913. Load more