1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright 2012 Advanced Micro Devices, Inc.
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21  * OTHER DEALINGS IN THE SOFTWARE.
22  *
23  */
24 
25 #include <linux/pci.h>
26 #include <linux/acpi.h>
27 #include <linux/backlight.h>
28 #include <linux/slab.h>
29 #include <linux/power_supply.h>
30 #include <linux/pm_runtime.h>
31 #include <linux/suspend.h>
32 #include <acpi/video.h>
33 #include <acpi/actbl.h>
34 
35 #include "amdgpu.h"
36 #include "amdgpu_pm.h"
37 #include "amdgpu_display.h"
38 #include "amd_acpi.h"
39 #include "atom.h"
40 
41 struct amdgpu_atif_notification_cfg {
42 	bool enabled;
43 	int command_code;
44 };
45 
46 struct amdgpu_atif_notifications {
47 	bool thermal_state;
48 	bool forced_power_state;
49 	bool system_power_state;
50 	bool brightness_change;
51 	bool dgpu_display_event;
52 	bool gpu_package_power_limit;
53 };
54 
55 struct amdgpu_atif_functions {
56 	bool system_params;
57 	bool sbios_requests;
58 	bool temperature_change;
59 	bool query_backlight_transfer_characteristics;
60 	bool ready_to_undock;
61 	bool external_gpu_information;
62 };
63 
64 struct amdgpu_atif {
65 	acpi_handle handle;
66 
67 	struct amdgpu_atif_notifications notifications;
68 	struct amdgpu_atif_functions functions;
69 	struct amdgpu_atif_notification_cfg notification_cfg;
70 	struct backlight_device *bd;
71 	struct amdgpu_dm_backlight_caps backlight_caps;
72 };
73 
74 struct amdgpu_atcs_functions {
75 	bool get_ext_state;
76 	bool pcie_perf_req;
77 	bool pcie_dev_rdy;
78 	bool pcie_bus_width;
79 	bool power_shift_control;
80 };
81 
82 struct amdgpu_atcs {
83 	acpi_handle handle;
84 
85 	struct amdgpu_atcs_functions functions;
86 };
87 
88 static struct amdgpu_acpi_priv {
89 	struct amdgpu_atif atif;
90 	struct amdgpu_atcs atcs;
91 } amdgpu_acpi_priv;
92 
93 /* Call the ATIF method
94  */
95 /**
96  * amdgpu_atif_call - call an ATIF method
97  *
98  * @atif: atif structure
99  * @function: the ATIF function to execute
100  * @params: ATIF function params
101  *
102  * Executes the requested ATIF function (all asics).
103  * Returns a pointer to the acpi output buffer.
104  */
105 static union acpi_object *amdgpu_atif_call(struct amdgpu_atif *atif,
106 					   int function,
107 					   struct acpi_buffer *params)
108 {
109 	acpi_status status;
110 	union acpi_object atif_arg_elements[2];
111 	struct acpi_object_list atif_arg;
112 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
113 
114 	atif_arg.count = 2;
115 	atif_arg.pointer = &atif_arg_elements[0];
116 
117 	atif_arg_elements[0].type = ACPI_TYPE_INTEGER;
118 	atif_arg_elements[0].integer.value = function;
119 
120 	if (params) {
121 		atif_arg_elements[1].type = ACPI_TYPE_BUFFER;
122 		atif_arg_elements[1].buffer.length = params->length;
123 		atif_arg_elements[1].buffer.pointer = params->pointer;
124 	} else {
125 		/* We need a second fake parameter */
126 		atif_arg_elements[1].type = ACPI_TYPE_INTEGER;
127 		atif_arg_elements[1].integer.value = 0;
128 	}
129 
130 	status = acpi_evaluate_object(atif->handle, NULL, &atif_arg,
131 				      &buffer);
132 
133 	/* Fail only if calling the method fails and ATIF is supported */
134 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
135 		DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n",
136 				 acpi_format_exception(status));
137 		kfree(buffer.pointer);
138 		return NULL;
139 	}
140 
141 	return buffer.pointer;
142 }
143 
144 /**
145  * amdgpu_atif_parse_notification - parse supported notifications
146  *
147  * @n: supported notifications struct
148  * @mask: supported notifications mask from ATIF
149  *
150  * Use the supported notifications mask from ATIF function
151  * ATIF_FUNCTION_VERIFY_INTERFACE to determine what notifications
152  * are supported (all asics).
153  */
154 static void amdgpu_atif_parse_notification(struct amdgpu_atif_notifications *n, u32 mask)
155 {
156 	n->thermal_state = mask & ATIF_THERMAL_STATE_CHANGE_REQUEST_SUPPORTED;
157 	n->forced_power_state = mask & ATIF_FORCED_POWER_STATE_CHANGE_REQUEST_SUPPORTED;
158 	n->system_power_state = mask & ATIF_SYSTEM_POWER_SOURCE_CHANGE_REQUEST_SUPPORTED;
159 	n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED;
160 	n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED;
161 	n->gpu_package_power_limit = mask & ATIF_GPU_PACKAGE_POWER_LIMIT_REQUEST_SUPPORTED;
162 }
163 
164 /**
165  * amdgpu_atif_parse_functions - parse supported functions
166  *
167  * @f: supported functions struct
168  * @mask: supported functions mask from ATIF
169  *
170  * Use the supported functions mask from ATIF function
171  * ATIF_FUNCTION_VERIFY_INTERFACE to determine what functions
172  * are supported (all asics).
173  */
174 static void amdgpu_atif_parse_functions(struct amdgpu_atif_functions *f, u32 mask)
175 {
176 	f->system_params = mask & ATIF_GET_SYSTEM_PARAMETERS_SUPPORTED;
177 	f->sbios_requests = mask & ATIF_GET_SYSTEM_BIOS_REQUESTS_SUPPORTED;
178 	f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED;
179 	f->query_backlight_transfer_characteristics =
180 		mask & ATIF_QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS_SUPPORTED;
181 	f->ready_to_undock = mask & ATIF_READY_TO_UNDOCK_NOTIFICATION_SUPPORTED;
182 	f->external_gpu_information = mask & ATIF_GET_EXTERNAL_GPU_INFORMATION_SUPPORTED;
183 }
184 
185 /**
186  * amdgpu_atif_verify_interface - verify ATIF
187  *
188  * @atif: amdgpu atif struct
189  *
190  * Execute the ATIF_FUNCTION_VERIFY_INTERFACE ATIF function
191  * to initialize ATIF and determine what features are supported
192  * (all asics).
193  * returns 0 on success, error on failure.
194  */
195 static int amdgpu_atif_verify_interface(struct amdgpu_atif *atif)
196 {
197 	union acpi_object *info;
198 	struct atif_verify_interface output;
199 	size_t size;
200 	int err = 0;
201 
202 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_VERIFY_INTERFACE, NULL);
203 	if (!info)
204 		return -EIO;
205 
206 	memset(&output, 0, sizeof(output));
207 
208 	size = *(u16 *) info->buffer.pointer;
209 	if (size < 12) {
210 		DRM_INFO("ATIF buffer is too small: %zu\n", size);
211 		err = -EINVAL;
212 		goto out;
213 	}
214 	size = min(sizeof(output), size);
215 
216 	memcpy(&output, info->buffer.pointer, size);
217 
218 	/* TODO: check version? */
219 	DRM_DEBUG_DRIVER("ATIF version %u\n", output.version);
220 
221 	amdgpu_atif_parse_notification(&atif->notifications, output.notification_mask);
222 	amdgpu_atif_parse_functions(&atif->functions, output.function_bits);
223 
224 out:
225 	kfree(info);
226 	return err;
227 }
228 
229 /**
230  * amdgpu_atif_get_notification_params - determine notify configuration
231  *
232  * @atif: acpi handle
233  *
234  * Execute the ATIF_FUNCTION_GET_SYSTEM_PARAMETERS ATIF function
235  * to determine if a notifier is used and if so which one
236  * (all asics).  This is either Notify(VGA, 0x81) or Notify(VGA, n)
237  * where n is specified in the result if a notifier is used.
238  * Returns 0 on success, error on failure.
239  */
240 static int amdgpu_atif_get_notification_params(struct amdgpu_atif *atif)
241 {
242 	union acpi_object *info;
243 	struct amdgpu_atif_notification_cfg *n = &atif->notification_cfg;
244 	struct atif_system_params params;
245 	size_t size;
246 	int err = 0;
247 
248 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS,
249 				NULL);
250 	if (!info) {
251 		err = -EIO;
252 		goto out;
253 	}
254 
255 	size = *(u16 *) info->buffer.pointer;
256 	if (size < 10) {
257 		err = -EINVAL;
258 		goto out;
259 	}
260 
261 	memset(&params, 0, sizeof(params));
262 	size = min(sizeof(params), size);
263 	memcpy(&params, info->buffer.pointer, size);
264 
265 	DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n",
266 			params.flags, params.valid_mask);
267 	params.flags = params.flags & params.valid_mask;
268 
269 	if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_NONE) {
270 		n->enabled = false;
271 		n->command_code = 0;
272 	} else if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_81) {
273 		n->enabled = true;
274 		n->command_code = 0x81;
275 	} else {
276 		if (size < 11) {
277 			err = -EINVAL;
278 			goto out;
279 		}
280 		n->enabled = true;
281 		n->command_code = params.command_code;
282 	}
283 
284 out:
285 	DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n",
286 			(n->enabled ? "enabled" : "disabled"),
287 			n->command_code);
288 	kfree(info);
289 	return err;
290 }
291 
292 /**
293  * amdgpu_atif_query_backlight_caps - get min and max backlight input signal
294  *
295  * @atif: acpi handle
296  *
297  * Execute the QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS ATIF function
298  * to determine the acceptable range of backlight values
299  *
300  * Backlight_caps.caps_valid will be set to true if the query is successful
301  *
302  * The input signals are in range 0-255
303  *
304  * This function assumes the display with backlight is the first LCD
305  *
306  * Returns 0 on success, error on failure.
307  */
308 static int amdgpu_atif_query_backlight_caps(struct amdgpu_atif *atif)
309 {
310 	union acpi_object *info;
311 	struct atif_qbtc_output characteristics;
312 	struct atif_qbtc_arguments arguments;
313 	struct acpi_buffer params;
314 	size_t size;
315 	int err = 0;
316 
317 	arguments.size = sizeof(arguments);
318 	arguments.requested_display = ATIF_QBTC_REQUEST_LCD1;
319 
320 	params.length = sizeof(arguments);
321 	params.pointer = (void *)&arguments;
322 
323 	info = amdgpu_atif_call(atif,
324 		ATIF_FUNCTION_QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS,
325 		&params);
326 	if (!info) {
327 		err = -EIO;
328 		goto out;
329 	}
330 
331 	size = *(u16 *) info->buffer.pointer;
332 	if (size < 10) {
333 		err = -EINVAL;
334 		goto out;
335 	}
336 
337 	memset(&characteristics, 0, sizeof(characteristics));
338 	size = min(sizeof(characteristics), size);
339 	memcpy(&characteristics, info->buffer.pointer, size);
340 
341 	atif->backlight_caps.caps_valid = true;
342 	atif->backlight_caps.min_input_signal =
343 			characteristics.min_input_signal;
344 	atif->backlight_caps.max_input_signal =
345 			characteristics.max_input_signal;
346 out:
347 	kfree(info);
348 	return err;
349 }
350 
351 /**
352  * amdgpu_atif_get_sbios_requests - get requested sbios event
353  *
354  * @atif: acpi handle
355  * @req: atif sbios request struct
356  *
357  * Execute the ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS ATIF function
358  * to determine what requests the sbios is making to the driver
359  * (all asics).
360  * Returns 0 on success, error on failure.
361  */
362 static int amdgpu_atif_get_sbios_requests(struct amdgpu_atif *atif,
363 					  struct atif_sbios_requests *req)
364 {
365 	union acpi_object *info;
366 	size_t size;
367 	int count = 0;
368 
369 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS,
370 				NULL);
371 	if (!info)
372 		return -EIO;
373 
374 	size = *(u16 *)info->buffer.pointer;
375 	if (size < 0xd) {
376 		count = -EINVAL;
377 		goto out;
378 	}
379 	memset(req, 0, sizeof(*req));
380 
381 	size = min(sizeof(*req), size);
382 	memcpy(req, info->buffer.pointer, size);
383 	DRM_DEBUG_DRIVER("SBIOS pending requests: %#x\n", req->pending);
384 
385 	count = hweight32(req->pending);
386 
387 out:
388 	kfree(info);
389 	return count;
390 }
391 
392 /**
393  * amdgpu_atif_handler - handle ATIF notify requests
394  *
395  * @adev: amdgpu_device pointer
396  * @event: atif sbios request struct
397  *
398  * Checks the acpi event and if it matches an atif event,
399  * handles it.
400  *
401  * Returns:
402  * NOTIFY_BAD or NOTIFY_DONE, depending on the event.
403  */
404 static int amdgpu_atif_handler(struct amdgpu_device *adev,
405 			       struct acpi_bus_event *event)
406 {
407 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
408 	int count;
409 
410 	DRM_DEBUG_DRIVER("event, device_class = %s, type = %#x\n",
411 			event->device_class, event->type);
412 
413 	if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
414 		return NOTIFY_DONE;
415 
416 	/* Is this actually our event? */
417 	if (!atif->notification_cfg.enabled ||
418 	    event->type != atif->notification_cfg.command_code) {
419 		/* These events will generate keypresses otherwise */
420 		if (event->type == ACPI_VIDEO_NOTIFY_PROBE)
421 			return NOTIFY_BAD;
422 		else
423 			return NOTIFY_DONE;
424 	}
425 
426 	if (atif->functions.sbios_requests) {
427 		struct atif_sbios_requests req;
428 
429 		/* Check pending SBIOS requests */
430 		count = amdgpu_atif_get_sbios_requests(atif, &req);
431 
432 		if (count <= 0)
433 			return NOTIFY_BAD;
434 
435 		DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count);
436 
437 		if (req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) {
438 			if (atif->bd) {
439 				DRM_DEBUG_DRIVER("Changing brightness to %d\n",
440 						 req.backlight_level);
441 				/*
442 				 * XXX backlight_device_set_brightness() is
443 				 * hardwired to post BACKLIGHT_UPDATE_SYSFS.
444 				 * It probably should accept 'reason' parameter.
445 				 */
446 				backlight_device_set_brightness(atif->bd, req.backlight_level);
447 			}
448 		}
449 
450 		if (req.pending & ATIF_DGPU_DISPLAY_EVENT) {
451 			if (adev->flags & AMD_IS_PX) {
452 				pm_runtime_get_sync(adev_to_drm(adev)->dev);
453 				/* Just fire off a uevent and let userspace tell us what to do */
454 				drm_helper_hpd_irq_event(adev_to_drm(adev));
455 				pm_runtime_mark_last_busy(adev_to_drm(adev)->dev);
456 				pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);
457 			}
458 		}
459 		/* TODO: check other events */
460 	}
461 
462 	/* We've handled the event, stop the notifier chain. The ACPI interface
463 	 * overloads ACPI_VIDEO_NOTIFY_PROBE, we don't want to send that to
464 	 * userspace if the event was generated only to signal a SBIOS
465 	 * request.
466 	 */
467 	return NOTIFY_BAD;
468 }
469 
470 /* Call the ATCS method
471  */
472 /**
473  * amdgpu_atcs_call - call an ATCS method
474  *
475  * @atcs: atcs structure
476  * @function: the ATCS function to execute
477  * @params: ATCS function params
478  *
479  * Executes the requested ATCS function (all asics).
480  * Returns a pointer to the acpi output buffer.
481  */
482 static union acpi_object *amdgpu_atcs_call(struct amdgpu_atcs *atcs,
483 					   int function,
484 					   struct acpi_buffer *params)
485 {
486 	acpi_status status;
487 	union acpi_object atcs_arg_elements[2];
488 	struct acpi_object_list atcs_arg;
489 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
490 
491 	atcs_arg.count = 2;
492 	atcs_arg.pointer = &atcs_arg_elements[0];
493 
494 	atcs_arg_elements[0].type = ACPI_TYPE_INTEGER;
495 	atcs_arg_elements[0].integer.value = function;
496 
497 	if (params) {
498 		atcs_arg_elements[1].type = ACPI_TYPE_BUFFER;
499 		atcs_arg_elements[1].buffer.length = params->length;
500 		atcs_arg_elements[1].buffer.pointer = params->pointer;
501 	} else {
502 		/* We need a second fake parameter */
503 		atcs_arg_elements[1].type = ACPI_TYPE_INTEGER;
504 		atcs_arg_elements[1].integer.value = 0;
505 	}
506 
507 	status = acpi_evaluate_object(atcs->handle, NULL, &atcs_arg, &buffer);
508 
509 	/* Fail only if calling the method fails and ATIF is supported */
510 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
511 		DRM_DEBUG_DRIVER("failed to evaluate ATCS got %s\n",
512 				 acpi_format_exception(status));
513 		kfree(buffer.pointer);
514 		return NULL;
515 	}
516 
517 	return buffer.pointer;
518 }
519 
520 /**
521  * amdgpu_atcs_parse_functions - parse supported functions
522  *
523  * @f: supported functions struct
524  * @mask: supported functions mask from ATCS
525  *
526  * Use the supported functions mask from ATCS function
527  * ATCS_FUNCTION_VERIFY_INTERFACE to determine what functions
528  * are supported (all asics).
529  */
530 static void amdgpu_atcs_parse_functions(struct amdgpu_atcs_functions *f, u32 mask)
531 {
532 	f->get_ext_state = mask & ATCS_GET_EXTERNAL_STATE_SUPPORTED;
533 	f->pcie_perf_req = mask & ATCS_PCIE_PERFORMANCE_REQUEST_SUPPORTED;
534 	f->pcie_dev_rdy = mask & ATCS_PCIE_DEVICE_READY_NOTIFICATION_SUPPORTED;
535 	f->pcie_bus_width = mask & ATCS_SET_PCIE_BUS_WIDTH_SUPPORTED;
536 	f->power_shift_control = mask & ATCS_SET_POWER_SHIFT_CONTROL_SUPPORTED;
537 }
538 
539 /**
540  * amdgpu_atcs_verify_interface - verify ATCS
541  *
542  * @atcs: amdgpu atcs struct
543  *
544  * Execute the ATCS_FUNCTION_VERIFY_INTERFACE ATCS function
545  * to initialize ATCS and determine what features are supported
546  * (all asics).
547  * returns 0 on success, error on failure.
548  */
549 static int amdgpu_atcs_verify_interface(struct amdgpu_atcs *atcs)
550 {
551 	union acpi_object *info;
552 	struct atcs_verify_interface output;
553 	size_t size;
554 	int err = 0;
555 
556 	info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_VERIFY_INTERFACE, NULL);
557 	if (!info)
558 		return -EIO;
559 
560 	memset(&output, 0, sizeof(output));
561 
562 	size = *(u16 *) info->buffer.pointer;
563 	if (size < 8) {
564 		DRM_INFO("ATCS buffer is too small: %zu\n", size);
565 		err = -EINVAL;
566 		goto out;
567 	}
568 	size = min(sizeof(output), size);
569 
570 	memcpy(&output, info->buffer.pointer, size);
571 
572 	/* TODO: check version? */
573 	DRM_DEBUG_DRIVER("ATCS version %u\n", output.version);
574 
575 	amdgpu_atcs_parse_functions(&atcs->functions, output.function_bits);
576 
577 out:
578 	kfree(info);
579 	return err;
580 }
581 
582 /**
583  * amdgpu_acpi_is_pcie_performance_request_supported
584  *
585  * @adev: amdgpu_device pointer
586  *
587  * Check if the ATCS pcie_perf_req and pcie_dev_rdy methods
588  * are supported (all asics).
589  * returns true if supported, false if not.
590  */
591 bool amdgpu_acpi_is_pcie_performance_request_supported(struct amdgpu_device *adev)
592 {
593 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
594 
595 	if (atcs->functions.pcie_perf_req && atcs->functions.pcie_dev_rdy)
596 		return true;
597 
598 	return false;
599 }
600 
601 /**
602  * amdgpu_acpi_is_power_shift_control_supported
603  *
604  * Check if the ATCS power shift control method
605  * is supported.
606  * returns true if supported, false if not.
607  */
608 bool amdgpu_acpi_is_power_shift_control_supported(void)
609 {
610 	return amdgpu_acpi_priv.atcs.functions.power_shift_control;
611 }
612 
613 /**
614  * amdgpu_acpi_pcie_notify_device_ready
615  *
616  * @adev: amdgpu_device pointer
617  *
618  * Executes the PCIE_DEVICE_READY_NOTIFICATION method
619  * (all asics).
620  * returns 0 on success, error on failure.
621  */
622 int amdgpu_acpi_pcie_notify_device_ready(struct amdgpu_device *adev)
623 {
624 	union acpi_object *info;
625 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
626 
627 	if (!atcs->functions.pcie_dev_rdy)
628 		return -EINVAL;
629 
630 	info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION, NULL);
631 	if (!info)
632 		return -EIO;
633 
634 	kfree(info);
635 
636 	return 0;
637 }
638 
639 /**
640  * amdgpu_acpi_pcie_performance_request
641  *
642  * @adev: amdgpu_device pointer
643  * @perf_req: requested perf level (pcie gen speed)
644  * @advertise: set advertise caps flag if set
645  *
646  * Executes the PCIE_PERFORMANCE_REQUEST method to
647  * change the pcie gen speed (all asics).
648  * returns 0 on success, error on failure.
649  */
650 int amdgpu_acpi_pcie_performance_request(struct amdgpu_device *adev,
651 					 u8 perf_req, bool advertise)
652 {
653 	union acpi_object *info;
654 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
655 	struct atcs_pref_req_input atcs_input;
656 	struct atcs_pref_req_output atcs_output;
657 	struct acpi_buffer params;
658 	size_t size;
659 	u32 retry = 3;
660 
661 	if (amdgpu_acpi_pcie_notify_device_ready(adev))
662 		return -EINVAL;
663 
664 	if (!atcs->functions.pcie_perf_req)
665 		return -EINVAL;
666 
667 	atcs_input.size = sizeof(struct atcs_pref_req_input);
668 	/* client id (bit 2-0: func num, 7-3: dev num, 15-8: bus num) */
669 	atcs_input.client_id = adev->pdev->devfn | (adev->pdev->bus->number << 8);
670 	atcs_input.valid_flags_mask = ATCS_VALID_FLAGS_MASK;
671 	atcs_input.flags = ATCS_WAIT_FOR_COMPLETION;
672 	if (advertise)
673 		atcs_input.flags |= ATCS_ADVERTISE_CAPS;
674 	atcs_input.req_type = ATCS_PCIE_LINK_SPEED;
675 	atcs_input.perf_req = perf_req;
676 
677 	params.length = sizeof(struct atcs_pref_req_input);
678 	params.pointer = &atcs_input;
679 
680 	while (retry--) {
681 		info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST, &params);
682 		if (!info)
683 			return -EIO;
684 
685 		memset(&atcs_output, 0, sizeof(atcs_output));
686 
687 		size = *(u16 *) info->buffer.pointer;
688 		if (size < 3) {
689 			DRM_INFO("ATCS buffer is too small: %zu\n", size);
690 			kfree(info);
691 			return -EINVAL;
692 		}
693 		size = min(sizeof(atcs_output), size);
694 
695 		memcpy(&atcs_output, info->buffer.pointer, size);
696 
697 		kfree(info);
698 
699 		switch (atcs_output.ret_val) {
700 		case ATCS_REQUEST_REFUSED:
701 		default:
702 			return -EINVAL;
703 		case ATCS_REQUEST_COMPLETE:
704 			return 0;
705 		case ATCS_REQUEST_IN_PROGRESS:
706 			udelay(10);
707 			break;
708 		}
709 	}
710 
711 	return 0;
712 }
713 
714 /**
715  * amdgpu_acpi_power_shift_control
716  *
717  * @adev: amdgpu_device pointer
718  * @dev_state: device acpi state
719  * @drv_state: driver state
720  *
721  * Executes the POWER_SHIFT_CONTROL method to
722  * communicate current dGPU device state and
723  * driver state to APU/SBIOS.
724  * returns 0 on success, error on failure.
725  */
726 int amdgpu_acpi_power_shift_control(struct amdgpu_device *adev,
727 				    u8 dev_state, bool drv_state)
728 {
729 	union acpi_object *info;
730 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
731 	struct atcs_pwr_shift_input atcs_input;
732 	struct acpi_buffer params;
733 
734 	if (!amdgpu_acpi_is_power_shift_control_supported())
735 		return -EINVAL;
736 
737 	atcs_input.size = sizeof(struct atcs_pwr_shift_input);
738 	/* dGPU id (bit 2-0: func num, 7-3: dev num, 15-8: bus num) */
739 	atcs_input.dgpu_id = adev->pdev->devfn | (adev->pdev->bus->number << 8);
740 	atcs_input.dev_acpi_state = dev_state;
741 	atcs_input.drv_state = drv_state;
742 
743 	params.length = sizeof(struct atcs_pwr_shift_input);
744 	params.pointer = &atcs_input;
745 
746 	info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_POWER_SHIFT_CONTROL, &params);
747 	if (!info) {
748 		DRM_ERROR("ATCS PSC update failed\n");
749 		return -EIO;
750 	}
751 
752 	return 0;
753 }
754 
755 /**
756  * amdgpu_acpi_smart_shift_update - update dGPU device state to SBIOS
757  *
758  * @dev: drm_device pointer
759  * @ss_state: current smart shift event
760  *
761  * returns 0 on success,
762  * otherwise return error number.
763  */
764 int amdgpu_acpi_smart_shift_update(struct drm_device *dev, enum amdgpu_ss ss_state)
765 {
766 	struct amdgpu_device *adev = drm_to_adev(dev);
767 	int r;
768 
769 	if (!amdgpu_device_supports_smart_shift(dev))
770 		return 0;
771 
772 	switch (ss_state) {
773 	/* SBIOS trigger “stop”, “enable” and “start” at D0, Driver Operational.
774 	 * SBIOS trigger “stop” at D3, Driver Not Operational.
775 	 * SBIOS trigger “stop” and “disable” at D0, Driver NOT operational.
776 	 */
777 	case AMDGPU_SS_DRV_LOAD:
778 		r = amdgpu_acpi_power_shift_control(adev,
779 						    AMDGPU_ATCS_PSC_DEV_STATE_D0,
780 						    AMDGPU_ATCS_PSC_DRV_STATE_OPR);
781 		break;
782 	case AMDGPU_SS_DEV_D0:
783 		r = amdgpu_acpi_power_shift_control(adev,
784 						    AMDGPU_ATCS_PSC_DEV_STATE_D0,
785 						    AMDGPU_ATCS_PSC_DRV_STATE_OPR);
786 		break;
787 	case AMDGPU_SS_DEV_D3:
788 		r = amdgpu_acpi_power_shift_control(adev,
789 						    AMDGPU_ATCS_PSC_DEV_STATE_D3_HOT,
790 						    AMDGPU_ATCS_PSC_DRV_STATE_NOT_OPR);
791 		break;
792 	case AMDGPU_SS_DRV_UNLOAD:
793 		r = amdgpu_acpi_power_shift_control(adev,
794 						    AMDGPU_ATCS_PSC_DEV_STATE_D0,
795 						    AMDGPU_ATCS_PSC_DRV_STATE_NOT_OPR);
796 		break;
797 	default:
798 		return -EINVAL;
799 	}
800 
801 	return r;
802 }
803 
804 /**
805  * amdgpu_acpi_event - handle notify events
806  *
807  * @nb: notifier block
808  * @val: val
809  * @data: acpi event
810  *
811  * Calls relevant amdgpu functions in response to various
812  * acpi events.
813  * Returns NOTIFY code
814  */
815 static int amdgpu_acpi_event(struct notifier_block *nb,
816 			     unsigned long val,
817 			     void *data)
818 {
819 	struct amdgpu_device *adev = container_of(nb, struct amdgpu_device, acpi_nb);
820 	struct acpi_bus_event *entry = (struct acpi_bus_event *)data;
821 
822 	if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) {
823 		if (power_supply_is_system_supplied() > 0)
824 			DRM_DEBUG_DRIVER("pm: AC\n");
825 		else
826 			DRM_DEBUG_DRIVER("pm: DC\n");
827 
828 		amdgpu_pm_acpi_event_handler(adev);
829 	}
830 
831 	/* Check for pending SBIOS requests */
832 	return amdgpu_atif_handler(adev, entry);
833 }
834 
835 /* Call all ACPI methods here */
836 /**
837  * amdgpu_acpi_init - init driver acpi support
838  *
839  * @adev: amdgpu_device pointer
840  *
841  * Verifies the AMD ACPI interfaces and registers with the acpi
842  * notifier chain (all asics).
843  * Returns 0 on success, error on failure.
844  */
845 int amdgpu_acpi_init(struct amdgpu_device *adev)
846 {
847 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
848 
849 	if (atif->notifications.brightness_change) {
850 		if (adev->dc_enabled) {
851 #if defined(CONFIG_DRM_AMD_DC)
852 			struct amdgpu_display_manager *dm = &adev->dm;
853 
854 			if (dm->backlight_dev[0])
855 				atif->bd = dm->backlight_dev[0];
856 #endif
857 		} else {
858 			struct drm_encoder *tmp;
859 
860 			/* Find the encoder controlling the brightness */
861 			list_for_each_entry(tmp, &adev_to_drm(adev)->mode_config.encoder_list,
862 					    head) {
863 				struct amdgpu_encoder *enc = to_amdgpu_encoder(tmp);
864 
865 				if ((enc->devices & (ATOM_DEVICE_LCD_SUPPORT)) &&
866 				    enc->enc_priv) {
867 					struct amdgpu_encoder_atom_dig *dig = enc->enc_priv;
868 
869 					if (dig->bl_dev) {
870 						atif->bd = dig->bl_dev;
871 						break;
872 					}
873 				}
874 			}
875 		}
876 	}
877 	adev->acpi_nb.notifier_call = amdgpu_acpi_event;
878 	register_acpi_notifier(&adev->acpi_nb);
879 
880 	return 0;
881 }
882 
883 void amdgpu_acpi_get_backlight_caps(struct amdgpu_dm_backlight_caps *caps)
884 {
885 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
886 
887 	caps->caps_valid = atif->backlight_caps.caps_valid;
888 	caps->min_input_signal = atif->backlight_caps.min_input_signal;
889 	caps->max_input_signal = atif->backlight_caps.max_input_signal;
890 }
891 
892 /**
893  * amdgpu_acpi_fini - tear down driver acpi support
894  *
895  * @adev: amdgpu_device pointer
896  *
897  * Unregisters with the acpi notifier chain (all asics).
898  */
899 void amdgpu_acpi_fini(struct amdgpu_device *adev)
900 {
901 	unregister_acpi_notifier(&adev->acpi_nb);
902 }
903 
904 /**
905  * amdgpu_atif_pci_probe_handle - look up the ATIF handle
906  *
907  * @pdev: pci device
908  *
909  * Look up the ATIF handles (all asics).
910  * Returns true if the handle is found, false if not.
911  */
912 static bool amdgpu_atif_pci_probe_handle(struct pci_dev *pdev)
913 {
914 	char acpi_method_name[255] = { 0 };
915 	struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
916 	acpi_handle dhandle, atif_handle;
917 	acpi_status status;
918 	int ret;
919 
920 	dhandle = ACPI_HANDLE(&pdev->dev);
921 	if (!dhandle)
922 		return false;
923 
924 	status = acpi_get_handle(dhandle, "ATIF", &atif_handle);
925 	if (ACPI_FAILURE(status))
926 		return false;
927 
928 	amdgpu_acpi_priv.atif.handle = atif_handle;
929 	acpi_get_name(amdgpu_acpi_priv.atif.handle, ACPI_FULL_PATHNAME, &buffer);
930 	DRM_DEBUG_DRIVER("Found ATIF handle %s\n", acpi_method_name);
931 	ret = amdgpu_atif_verify_interface(&amdgpu_acpi_priv.atif);
932 	if (ret) {
933 		amdgpu_acpi_priv.atif.handle = 0;
934 		return false;
935 	}
936 	return true;
937 }
938 
939 /**
940  * amdgpu_atcs_pci_probe_handle - look up the ATCS handle
941  *
942  * @pdev: pci device
943  *
944  * Look up the ATCS handles (all asics).
945  * Returns true if the handle is found, false if not.
946  */
947 static bool amdgpu_atcs_pci_probe_handle(struct pci_dev *pdev)
948 {
949 	char acpi_method_name[255] = { 0 };
950 	struct acpi_buffer buffer = { sizeof(acpi_method_name), acpi_method_name };
951 	acpi_handle dhandle, atcs_handle;
952 	acpi_status status;
953 	int ret;
954 
955 	dhandle = ACPI_HANDLE(&pdev->dev);
956 	if (!dhandle)
957 		return false;
958 
959 	status = acpi_get_handle(dhandle, "ATCS", &atcs_handle);
960 	if (ACPI_FAILURE(status))
961 		return false;
962 
963 	amdgpu_acpi_priv.atcs.handle = atcs_handle;
964 	acpi_get_name(amdgpu_acpi_priv.atcs.handle, ACPI_FULL_PATHNAME, &buffer);
965 	DRM_DEBUG_DRIVER("Found ATCS handle %s\n", acpi_method_name);
966 	ret = amdgpu_atcs_verify_interface(&amdgpu_acpi_priv.atcs);
967 	if (ret) {
968 		amdgpu_acpi_priv.atcs.handle = 0;
969 		return false;
970 	}
971 	return true;
972 }
973 
974 /*
975  * amdgpu_acpi_detect - detect ACPI ATIF/ATCS methods
976  *
977  * Check if we have the ATIF/ATCS methods and populate
978  * the structures in the driver.
979  */
980 void amdgpu_acpi_detect(void)
981 {
982 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
983 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
984 	struct pci_dev *pdev = NULL;
985 	int ret;
986 
987 	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
988 		if (!atif->handle)
989 			amdgpu_atif_pci_probe_handle(pdev);
990 		if (!atcs->handle)
991 			amdgpu_atcs_pci_probe_handle(pdev);
992 	}
993 
994 	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_OTHER << 8, pdev)) != NULL) {
995 		if (!atif->handle)
996 			amdgpu_atif_pci_probe_handle(pdev);
997 		if (!atcs->handle)
998 			amdgpu_atcs_pci_probe_handle(pdev);
999 	}
1000 
1001 	if (atif->functions.sbios_requests && !atif->functions.system_params) {
1002 		/* XXX check this workraround, if sbios request function is
1003 		 * present we have to see how it's configured in the system
1004 		 * params
1005 		 */
1006 		atif->functions.system_params = true;
1007 	}
1008 
1009 	if (atif->functions.system_params) {
1010 		ret = amdgpu_atif_get_notification_params(atif);
1011 		if (ret) {
1012 			DRM_DEBUG_DRIVER("Call to GET_SYSTEM_PARAMS failed: %d\n",
1013 					ret);
1014 			/* Disable notification */
1015 			atif->notification_cfg.enabled = false;
1016 		}
1017 	}
1018 
1019 	if (atif->functions.query_backlight_transfer_characteristics) {
1020 		ret = amdgpu_atif_query_backlight_caps(atif);
1021 		if (ret) {
1022 			DRM_DEBUG_DRIVER("Call to QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS failed: %d\n",
1023 					ret);
1024 			atif->backlight_caps.caps_valid = false;
1025 		}
1026 	} else {
1027 		atif->backlight_caps.caps_valid = false;
1028 	}
1029 }
1030 
1031 #if IS_ENABLED(CONFIG_SUSPEND)
1032 /**
1033  * amdgpu_acpi_is_s3_active
1034  *
1035  * @adev: amdgpu_device_pointer
1036  *
1037  * returns true if supported, false if not.
1038  */
1039 bool amdgpu_acpi_is_s3_active(struct amdgpu_device *adev)
1040 {
1041 	return !(adev->flags & AMD_IS_APU) ||
1042 		(pm_suspend_target_state == PM_SUSPEND_MEM);
1043 }
1044 
1045 /**
1046  * amdgpu_acpi_should_gpu_reset
1047  *
1048  * @adev: amdgpu_device_pointer
1049  *
1050  * returns true if should reset GPU, false if not
1051  */
1052 bool amdgpu_acpi_should_gpu_reset(struct amdgpu_device *adev)
1053 {
1054 	if (adev->flags & AMD_IS_APU)
1055 		return false;
1056 
1057 	if (amdgpu_sriov_vf(adev))
1058 		return false;
1059 
1060 	return pm_suspend_target_state != PM_SUSPEND_TO_IDLE;
1061 }
1062 
1063 /**
1064  * amdgpu_acpi_is_s0ix_active
1065  *
1066  * @adev: amdgpu_device_pointer
1067  *
1068  * returns true if supported, false if not.
1069  */
1070 bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev)
1071 {
1072 	if (!(adev->flags & AMD_IS_APU) ||
1073 	    (pm_suspend_target_state != PM_SUSPEND_TO_IDLE))
1074 		return false;
1075 
1076 	if (adev->asic_type < CHIP_RAVEN)
1077 		return false;
1078 
1079 	/*
1080 	 * If ACPI_FADT_LOW_POWER_S0 is not set in the FADT, it is generally
1081 	 * risky to do any special firmware-related preparations for entering
1082 	 * S0ix even though the system is suspending to idle, so return false
1083 	 * in that case.
1084 	 */
1085 	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
1086 		dev_warn_once(adev->dev,
1087 			      "Power consumption will be higher as BIOS has not been configured for suspend-to-idle.\n"
1088 			      "To use suspend-to-idle change the sleep mode in BIOS setup.\n");
1089 
1090 #if !IS_ENABLED(CONFIG_AMD_PMC)
1091 	dev_warn_once(adev->dev,
1092 		      "Power consumption will be higher as the kernel has not been compiled with CONFIG_AMD_PMC.\n");
1093 #endif /* CONFIG_AMD_PMC */
1094 	return true;
1095 }
1096 
1097 #endif /* CONFIG_SUSPEND */
1098