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/xarray.h>
30 #include <linux/power_supply.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/suspend.h>
33 #include <acpi/video.h>
34 #include <acpi/actbl.h>
35 
36 #include "amdgpu.h"
37 #include "amdgpu_pm.h"
38 #include "amdgpu_display.h"
39 #include "amd_acpi.h"
40 #include "atom.h"
41 
42 /* Declare GUID for AMD _DSM method for XCCs */
43 static const guid_t amd_xcc_dsm_guid = GUID_INIT(0x8267f5d5, 0xa556, 0x44f2,
44 						 0xb8, 0xb4, 0x45, 0x56, 0x2e,
45 						 0x8c, 0x5b, 0xec);
46 
47 #define AMD_XCC_HID_START 3000
48 #define AMD_XCC_DSM_GET_NUM_FUNCS 0
49 #define AMD_XCC_DSM_GET_SUPP_MODE 1
50 #define AMD_XCC_DSM_GET_XCP_MODE 2
51 #define AMD_XCC_DSM_GET_VF_XCC_MAPPING 4
52 #define AMD_XCC_DSM_GET_TMR_INFO 5
53 #define AMD_XCC_DSM_NUM_FUNCS 5
54 
55 #define AMD_XCC_MAX_HID 24
56 
57 struct xarray numa_info_xa;
58 
59 /* Encapsulates the XCD acpi object information */
60 struct amdgpu_acpi_xcc_info {
61 	struct list_head list;
62 	struct amdgpu_numa_info *numa_info;
63 	uint8_t xcp_node;
64 	uint8_t phy_id;
65 	acpi_handle handle;
66 };
67 
68 struct amdgpu_acpi_dev_info {
69 	struct list_head list;
70 	struct list_head xcc_list;
71 	uint32_t sbdf;
72 	uint16_t supp_xcp_mode;
73 	uint16_t xcp_mode;
74 	uint16_t mem_mode;
75 	uint64_t tmr_base;
76 	uint64_t tmr_size;
77 };
78 
79 struct list_head amdgpu_acpi_dev_list;
80 
81 struct amdgpu_atif_notification_cfg {
82 	bool enabled;
83 	int command_code;
84 };
85 
86 struct amdgpu_atif_notifications {
87 	bool thermal_state;
88 	bool forced_power_state;
89 	bool system_power_state;
90 	bool brightness_change;
91 	bool dgpu_display_event;
92 	bool gpu_package_power_limit;
93 };
94 
95 struct amdgpu_atif_functions {
96 	bool system_params;
97 	bool sbios_requests;
98 	bool temperature_change;
99 	bool query_backlight_transfer_characteristics;
100 	bool ready_to_undock;
101 	bool external_gpu_information;
102 };
103 
104 struct amdgpu_atif {
105 	acpi_handle handle;
106 
107 	struct amdgpu_atif_notifications notifications;
108 	struct amdgpu_atif_functions functions;
109 	struct amdgpu_atif_notification_cfg notification_cfg;
110 	struct backlight_device *bd;
111 	struct amdgpu_dm_backlight_caps backlight_caps;
112 };
113 
114 struct amdgpu_atcs_functions {
115 	bool get_ext_state;
116 	bool pcie_perf_req;
117 	bool pcie_dev_rdy;
118 	bool pcie_bus_width;
119 	bool power_shift_control;
120 };
121 
122 struct amdgpu_atcs {
123 	acpi_handle handle;
124 
125 	struct amdgpu_atcs_functions functions;
126 };
127 
128 static struct amdgpu_acpi_priv {
129 	struct amdgpu_atif atif;
130 	struct amdgpu_atcs atcs;
131 } amdgpu_acpi_priv;
132 
133 /* Call the ATIF method
134  */
135 /**
136  * amdgpu_atif_call - call an ATIF method
137  *
138  * @atif: atif structure
139  * @function: the ATIF function to execute
140  * @params: ATIF function params
141  *
142  * Executes the requested ATIF function (all asics).
143  * Returns a pointer to the acpi output buffer.
144  */
amdgpu_atif_call(struct amdgpu_atif * atif,int function,struct acpi_buffer * params)145 static union acpi_object *amdgpu_atif_call(struct amdgpu_atif *atif,
146 					   int function,
147 					   struct acpi_buffer *params)
148 {
149 	acpi_status status;
150 	union acpi_object *obj;
151 	union acpi_object atif_arg_elements[2];
152 	struct acpi_object_list atif_arg;
153 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
154 
155 	atif_arg.count = 2;
156 	atif_arg.pointer = &atif_arg_elements[0];
157 
158 	atif_arg_elements[0].type = ACPI_TYPE_INTEGER;
159 	atif_arg_elements[0].integer.value = function;
160 
161 	if (params) {
162 		atif_arg_elements[1].type = ACPI_TYPE_BUFFER;
163 		atif_arg_elements[1].buffer.length = params->length;
164 		atif_arg_elements[1].buffer.pointer = params->pointer;
165 	} else {
166 		/* We need a second fake parameter */
167 		atif_arg_elements[1].type = ACPI_TYPE_INTEGER;
168 		atif_arg_elements[1].integer.value = 0;
169 	}
170 
171 	status = acpi_evaluate_object(atif->handle, NULL, &atif_arg,
172 				      &buffer);
173 	obj = (union acpi_object *)buffer.pointer;
174 
175 	/* Fail if calling the method fails */
176 	if (ACPI_FAILURE(status)) {
177 		DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n",
178 				 acpi_format_exception(status));
179 		kfree(obj);
180 		return NULL;
181 	}
182 
183 	if (obj->type != ACPI_TYPE_BUFFER) {
184 		DRM_DEBUG_DRIVER("bad object returned from ATIF: %d\n",
185 				 obj->type);
186 		kfree(obj);
187 		return NULL;
188 	}
189 
190 	return obj;
191 }
192 
193 /**
194  * amdgpu_atif_parse_notification - parse supported notifications
195  *
196  * @n: supported notifications struct
197  * @mask: supported notifications mask from ATIF
198  *
199  * Use the supported notifications mask from ATIF function
200  * ATIF_FUNCTION_VERIFY_INTERFACE to determine what notifications
201  * are supported (all asics).
202  */
amdgpu_atif_parse_notification(struct amdgpu_atif_notifications * n,u32 mask)203 static void amdgpu_atif_parse_notification(struct amdgpu_atif_notifications *n, u32 mask)
204 {
205 	n->thermal_state = mask & ATIF_THERMAL_STATE_CHANGE_REQUEST_SUPPORTED;
206 	n->forced_power_state = mask & ATIF_FORCED_POWER_STATE_CHANGE_REQUEST_SUPPORTED;
207 	n->system_power_state = mask & ATIF_SYSTEM_POWER_SOURCE_CHANGE_REQUEST_SUPPORTED;
208 	n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED;
209 	n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED;
210 	n->gpu_package_power_limit = mask & ATIF_GPU_PACKAGE_POWER_LIMIT_REQUEST_SUPPORTED;
211 }
212 
213 /**
214  * amdgpu_atif_parse_functions - parse supported functions
215  *
216  * @f: supported functions struct
217  * @mask: supported functions mask from ATIF
218  *
219  * Use the supported functions mask from ATIF function
220  * ATIF_FUNCTION_VERIFY_INTERFACE to determine what functions
221  * are supported (all asics).
222  */
amdgpu_atif_parse_functions(struct amdgpu_atif_functions * f,u32 mask)223 static void amdgpu_atif_parse_functions(struct amdgpu_atif_functions *f, u32 mask)
224 {
225 	f->system_params = mask & ATIF_GET_SYSTEM_PARAMETERS_SUPPORTED;
226 	f->sbios_requests = mask & ATIF_GET_SYSTEM_BIOS_REQUESTS_SUPPORTED;
227 	f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED;
228 	f->query_backlight_transfer_characteristics =
229 		mask & ATIF_QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS_SUPPORTED;
230 	f->ready_to_undock = mask & ATIF_READY_TO_UNDOCK_NOTIFICATION_SUPPORTED;
231 	f->external_gpu_information = mask & ATIF_GET_EXTERNAL_GPU_INFORMATION_SUPPORTED;
232 }
233 
234 /**
235  * amdgpu_atif_verify_interface - verify ATIF
236  *
237  * @atif: amdgpu atif struct
238  *
239  * Execute the ATIF_FUNCTION_VERIFY_INTERFACE ATIF function
240  * to initialize ATIF and determine what features are supported
241  * (all asics).
242  * returns 0 on success, error on failure.
243  */
amdgpu_atif_verify_interface(struct amdgpu_atif * atif)244 static int amdgpu_atif_verify_interface(struct amdgpu_atif *atif)
245 {
246 	union acpi_object *info;
247 	struct atif_verify_interface output;
248 	size_t size;
249 	int err = 0;
250 
251 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_VERIFY_INTERFACE, NULL);
252 	if (!info)
253 		return -EIO;
254 
255 	memset(&output, 0, sizeof(output));
256 
257 	size = *(u16 *) info->buffer.pointer;
258 	if (size < 12) {
259 		DRM_INFO("ATIF buffer is too small: %zu\n", size);
260 		err = -EINVAL;
261 		goto out;
262 	}
263 	size = min(sizeof(output), size);
264 
265 	memcpy(&output, info->buffer.pointer, size);
266 
267 	/* TODO: check version? */
268 	DRM_DEBUG_DRIVER("ATIF version %u\n", output.version);
269 
270 	amdgpu_atif_parse_notification(&atif->notifications, output.notification_mask);
271 	amdgpu_atif_parse_functions(&atif->functions, output.function_bits);
272 
273 out:
274 	kfree(info);
275 	return err;
276 }
277 
278 /**
279  * amdgpu_atif_get_notification_params - determine notify configuration
280  *
281  * @atif: acpi handle
282  *
283  * Execute the ATIF_FUNCTION_GET_SYSTEM_PARAMETERS ATIF function
284  * to determine if a notifier is used and if so which one
285  * (all asics).  This is either Notify(VGA, 0x81) or Notify(VGA, n)
286  * where n is specified in the result if a notifier is used.
287  * Returns 0 on success, error on failure.
288  */
amdgpu_atif_get_notification_params(struct amdgpu_atif * atif)289 static int amdgpu_atif_get_notification_params(struct amdgpu_atif *atif)
290 {
291 	union acpi_object *info;
292 	struct amdgpu_atif_notification_cfg *n = &atif->notification_cfg;
293 	struct atif_system_params params;
294 	size_t size;
295 	int err = 0;
296 
297 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS,
298 				NULL);
299 	if (!info) {
300 		err = -EIO;
301 		goto out;
302 	}
303 
304 	size = *(u16 *) info->buffer.pointer;
305 	if (size < 10) {
306 		err = -EINVAL;
307 		goto out;
308 	}
309 
310 	memset(&params, 0, sizeof(params));
311 	size = min(sizeof(params), size);
312 	memcpy(&params, info->buffer.pointer, size);
313 
314 	DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n",
315 			params.flags, params.valid_mask);
316 	params.flags = params.flags & params.valid_mask;
317 
318 	if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_NONE) {
319 		n->enabled = false;
320 		n->command_code = 0;
321 	} else if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_81) {
322 		n->enabled = true;
323 		n->command_code = 0x81;
324 	} else {
325 		if (size < 11) {
326 			err = -EINVAL;
327 			goto out;
328 		}
329 		n->enabled = true;
330 		n->command_code = params.command_code;
331 	}
332 
333 out:
334 	DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n",
335 			(n->enabled ? "enabled" : "disabled"),
336 			n->command_code);
337 	kfree(info);
338 	return err;
339 }
340 
341 /**
342  * amdgpu_atif_query_backlight_caps - get min and max backlight input signal
343  *
344  * @atif: acpi handle
345  *
346  * Execute the QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS ATIF function
347  * to determine the acceptable range of backlight values
348  *
349  * Backlight_caps.caps_valid will be set to true if the query is successful
350  *
351  * The input signals are in range 0-255
352  *
353  * This function assumes the display with backlight is the first LCD
354  *
355  * Returns 0 on success, error on failure.
356  */
amdgpu_atif_query_backlight_caps(struct amdgpu_atif * atif)357 static int amdgpu_atif_query_backlight_caps(struct amdgpu_atif *atif)
358 {
359 	union acpi_object *info;
360 	struct atif_qbtc_output characteristics;
361 	struct atif_qbtc_arguments arguments;
362 	struct acpi_buffer params;
363 	size_t size;
364 	int err = 0;
365 
366 	arguments.size = sizeof(arguments);
367 	arguments.requested_display = ATIF_QBTC_REQUEST_LCD1;
368 
369 	params.length = sizeof(arguments);
370 	params.pointer = (void *)&arguments;
371 
372 	info = amdgpu_atif_call(atif,
373 		ATIF_FUNCTION_QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS,
374 		&params);
375 	if (!info) {
376 		err = -EIO;
377 		goto out;
378 	}
379 
380 	size = *(u16 *) info->buffer.pointer;
381 	if (size < 10) {
382 		err = -EINVAL;
383 		goto out;
384 	}
385 
386 	memset(&characteristics, 0, sizeof(characteristics));
387 	size = min(sizeof(characteristics), size);
388 	memcpy(&characteristics, info->buffer.pointer, size);
389 
390 	atif->backlight_caps.caps_valid = true;
391 	atif->backlight_caps.min_input_signal =
392 			characteristics.min_input_signal;
393 	atif->backlight_caps.max_input_signal =
394 			characteristics.max_input_signal;
395 	atif->backlight_caps.ac_level = characteristics.ac_level;
396 	atif->backlight_caps.dc_level = characteristics.dc_level;
397 out:
398 	kfree(info);
399 	return err;
400 }
401 
402 /**
403  * amdgpu_atif_get_sbios_requests - get requested sbios event
404  *
405  * @atif: acpi handle
406  * @req: atif sbios request struct
407  *
408  * Execute the ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS ATIF function
409  * to determine what requests the sbios is making to the driver
410  * (all asics).
411  * Returns 0 on success, error on failure.
412  */
amdgpu_atif_get_sbios_requests(struct amdgpu_atif * atif,struct atif_sbios_requests * req)413 static int amdgpu_atif_get_sbios_requests(struct amdgpu_atif *atif,
414 					  struct atif_sbios_requests *req)
415 {
416 	union acpi_object *info;
417 	size_t size;
418 	int count = 0;
419 
420 	info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS,
421 				NULL);
422 	if (!info)
423 		return -EIO;
424 
425 	size = *(u16 *)info->buffer.pointer;
426 	if (size < 0xd) {
427 		count = -EINVAL;
428 		goto out;
429 	}
430 	memset(req, 0, sizeof(*req));
431 
432 	size = min(sizeof(*req), size);
433 	memcpy(req, info->buffer.pointer, size);
434 	DRM_DEBUG_DRIVER("SBIOS pending requests: %#x\n", req->pending);
435 
436 	count = hweight32(req->pending);
437 
438 out:
439 	kfree(info);
440 	return count;
441 }
442 
443 /**
444  * amdgpu_atif_handler - handle ATIF notify requests
445  *
446  * @adev: amdgpu_device pointer
447  * @event: atif sbios request struct
448  *
449  * Checks the acpi event and if it matches an atif event,
450  * handles it.
451  *
452  * Returns:
453  * NOTIFY_BAD or NOTIFY_DONE, depending on the event.
454  */
amdgpu_atif_handler(struct amdgpu_device * adev,struct acpi_bus_event * event)455 static int amdgpu_atif_handler(struct amdgpu_device *adev,
456 			       struct acpi_bus_event *event)
457 {
458 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
459 	int count;
460 
461 	DRM_DEBUG_DRIVER("event, device_class = %s, type = %#x\n",
462 			event->device_class, event->type);
463 
464 	if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
465 		return NOTIFY_DONE;
466 
467 	/* Is this actually our event? */
468 	if (!atif->notification_cfg.enabled ||
469 	    event->type != atif->notification_cfg.command_code) {
470 		/* These events will generate keypresses otherwise */
471 		if (event->type == ACPI_VIDEO_NOTIFY_PROBE)
472 			return NOTIFY_BAD;
473 		else
474 			return NOTIFY_DONE;
475 	}
476 
477 	if (atif->functions.sbios_requests) {
478 		struct atif_sbios_requests req;
479 
480 		/* Check pending SBIOS requests */
481 		count = amdgpu_atif_get_sbios_requests(atif, &req);
482 
483 		if (count <= 0)
484 			return NOTIFY_BAD;
485 
486 		DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count);
487 
488 		if (req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) {
489 			if (atif->bd) {
490 				DRM_DEBUG_DRIVER("Changing brightness to %d\n",
491 						 req.backlight_level);
492 				/*
493 				 * XXX backlight_device_set_brightness() is
494 				 * hardwired to post BACKLIGHT_UPDATE_SYSFS.
495 				 * It probably should accept 'reason' parameter.
496 				 */
497 				backlight_device_set_brightness(atif->bd, req.backlight_level);
498 			}
499 		}
500 
501 		if (req.pending & ATIF_DGPU_DISPLAY_EVENT) {
502 			if (adev->flags & AMD_IS_PX) {
503 				pm_runtime_get_sync(adev_to_drm(adev)->dev);
504 				/* Just fire off a uevent and let userspace tell us what to do */
505 				drm_helper_hpd_irq_event(adev_to_drm(adev));
506 				pm_runtime_mark_last_busy(adev_to_drm(adev)->dev);
507 				pm_runtime_put_autosuspend(adev_to_drm(adev)->dev);
508 			}
509 		}
510 		/* TODO: check other events */
511 	}
512 
513 	/* We've handled the event, stop the notifier chain. The ACPI interface
514 	 * overloads ACPI_VIDEO_NOTIFY_PROBE, we don't want to send that to
515 	 * userspace if the event was generated only to signal a SBIOS
516 	 * request.
517 	 */
518 	return NOTIFY_BAD;
519 }
520 
521 /* Call the ATCS method
522  */
523 /**
524  * amdgpu_atcs_call - call an ATCS method
525  *
526  * @atcs: atcs structure
527  * @function: the ATCS function to execute
528  * @params: ATCS function params
529  *
530  * Executes the requested ATCS function (all asics).
531  * Returns a pointer to the acpi output buffer.
532  */
amdgpu_atcs_call(struct amdgpu_atcs * atcs,int function,struct acpi_buffer * params)533 static union acpi_object *amdgpu_atcs_call(struct amdgpu_atcs *atcs,
534 					   int function,
535 					   struct acpi_buffer *params)
536 {
537 	acpi_status status;
538 	union acpi_object atcs_arg_elements[2];
539 	struct acpi_object_list atcs_arg;
540 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
541 
542 	atcs_arg.count = 2;
543 	atcs_arg.pointer = &atcs_arg_elements[0];
544 
545 	atcs_arg_elements[0].type = ACPI_TYPE_INTEGER;
546 	atcs_arg_elements[0].integer.value = function;
547 
548 	if (params) {
549 		atcs_arg_elements[1].type = ACPI_TYPE_BUFFER;
550 		atcs_arg_elements[1].buffer.length = params->length;
551 		atcs_arg_elements[1].buffer.pointer = params->pointer;
552 	} else {
553 		/* We need a second fake parameter */
554 		atcs_arg_elements[1].type = ACPI_TYPE_INTEGER;
555 		atcs_arg_elements[1].integer.value = 0;
556 	}
557 
558 	status = acpi_evaluate_object(atcs->handle, NULL, &atcs_arg, &buffer);
559 
560 	/* Fail only if calling the method fails and ATIF is supported */
561 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
562 		DRM_DEBUG_DRIVER("failed to evaluate ATCS got %s\n",
563 				 acpi_format_exception(status));
564 		kfree(buffer.pointer);
565 		return NULL;
566 	}
567 
568 	return buffer.pointer;
569 }
570 
571 /**
572  * amdgpu_atcs_parse_functions - parse supported functions
573  *
574  * @f: supported functions struct
575  * @mask: supported functions mask from ATCS
576  *
577  * Use the supported functions mask from ATCS function
578  * ATCS_FUNCTION_VERIFY_INTERFACE to determine what functions
579  * are supported (all asics).
580  */
amdgpu_atcs_parse_functions(struct amdgpu_atcs_functions * f,u32 mask)581 static void amdgpu_atcs_parse_functions(struct amdgpu_atcs_functions *f, u32 mask)
582 {
583 	f->get_ext_state = mask & ATCS_GET_EXTERNAL_STATE_SUPPORTED;
584 	f->pcie_perf_req = mask & ATCS_PCIE_PERFORMANCE_REQUEST_SUPPORTED;
585 	f->pcie_dev_rdy = mask & ATCS_PCIE_DEVICE_READY_NOTIFICATION_SUPPORTED;
586 	f->pcie_bus_width = mask & ATCS_SET_PCIE_BUS_WIDTH_SUPPORTED;
587 	f->power_shift_control = mask & ATCS_SET_POWER_SHIFT_CONTROL_SUPPORTED;
588 }
589 
590 /**
591  * amdgpu_atcs_verify_interface - verify ATCS
592  *
593  * @atcs: amdgpu atcs struct
594  *
595  * Execute the ATCS_FUNCTION_VERIFY_INTERFACE ATCS function
596  * to initialize ATCS and determine what features are supported
597  * (all asics).
598  * returns 0 on success, error on failure.
599  */
amdgpu_atcs_verify_interface(struct amdgpu_atcs * atcs)600 static int amdgpu_atcs_verify_interface(struct amdgpu_atcs *atcs)
601 {
602 	union acpi_object *info;
603 	struct atcs_verify_interface output;
604 	size_t size;
605 	int err = 0;
606 
607 	info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_VERIFY_INTERFACE, NULL);
608 	if (!info)
609 		return -EIO;
610 
611 	memset(&output, 0, sizeof(output));
612 
613 	size = *(u16 *) info->buffer.pointer;
614 	if (size < 8) {
615 		DRM_INFO("ATCS buffer is too small: %zu\n", size);
616 		err = -EINVAL;
617 		goto out;
618 	}
619 	size = min(sizeof(output), size);
620 
621 	memcpy(&output, info->buffer.pointer, size);
622 
623 	/* TODO: check version? */
624 	DRM_DEBUG_DRIVER("ATCS version %u\n", output.version);
625 
626 	amdgpu_atcs_parse_functions(&atcs->functions, output.function_bits);
627 
628 out:
629 	kfree(info);
630 	return err;
631 }
632 
633 /**
634  * amdgpu_acpi_is_pcie_performance_request_supported
635  *
636  * @adev: amdgpu_device pointer
637  *
638  * Check if the ATCS pcie_perf_req and pcie_dev_rdy methods
639  * are supported (all asics).
640  * returns true if supported, false if not.
641  */
amdgpu_acpi_is_pcie_performance_request_supported(struct amdgpu_device * adev)642 bool amdgpu_acpi_is_pcie_performance_request_supported(struct amdgpu_device *adev)
643 {
644 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
645 
646 	if (atcs->functions.pcie_perf_req && atcs->functions.pcie_dev_rdy)
647 		return true;
648 
649 	return false;
650 }
651 
652 /**
653  * amdgpu_acpi_is_power_shift_control_supported
654  *
655  * Check if the ATCS power shift control method
656  * is supported.
657  * returns true if supported, false if not.
658  */
amdgpu_acpi_is_power_shift_control_supported(void)659 bool amdgpu_acpi_is_power_shift_control_supported(void)
660 {
661 	return amdgpu_acpi_priv.atcs.functions.power_shift_control;
662 }
663 
664 /**
665  * amdgpu_acpi_pcie_notify_device_ready
666  *
667  * @adev: amdgpu_device pointer
668  *
669  * Executes the PCIE_DEVICE_READY_NOTIFICATION method
670  * (all asics).
671  * returns 0 on success, error on failure.
672  */
amdgpu_acpi_pcie_notify_device_ready(struct amdgpu_device * adev)673 int amdgpu_acpi_pcie_notify_device_ready(struct amdgpu_device *adev)
674 {
675 	union acpi_object *info;
676 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
677 
678 	if (!atcs->functions.pcie_dev_rdy)
679 		return -EINVAL;
680 
681 	info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION, NULL);
682 	if (!info)
683 		return -EIO;
684 
685 	kfree(info);
686 
687 	return 0;
688 }
689 
690 /**
691  * amdgpu_acpi_pcie_performance_request
692  *
693  * @adev: amdgpu_device pointer
694  * @perf_req: requested perf level (pcie gen speed)
695  * @advertise: set advertise caps flag if set
696  *
697  * Executes the PCIE_PERFORMANCE_REQUEST method to
698  * change the pcie gen speed (all asics).
699  * returns 0 on success, error on failure.
700  */
amdgpu_acpi_pcie_performance_request(struct amdgpu_device * adev,u8 perf_req,bool advertise)701 int amdgpu_acpi_pcie_performance_request(struct amdgpu_device *adev,
702 					 u8 perf_req, bool advertise)
703 {
704 	union acpi_object *info;
705 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
706 	struct atcs_pref_req_input atcs_input;
707 	struct atcs_pref_req_output atcs_output;
708 	struct acpi_buffer params;
709 	size_t size;
710 	u32 retry = 3;
711 
712 	if (amdgpu_acpi_pcie_notify_device_ready(adev))
713 		return -EINVAL;
714 
715 	if (!atcs->functions.pcie_perf_req)
716 		return -EINVAL;
717 
718 	atcs_input.size = sizeof(struct atcs_pref_req_input);
719 	/* client id (bit 2-0: func num, 7-3: dev num, 15-8: bus num) */
720 	atcs_input.client_id = pci_dev_id(adev->pdev);
721 	atcs_input.valid_flags_mask = ATCS_VALID_FLAGS_MASK;
722 	atcs_input.flags = ATCS_WAIT_FOR_COMPLETION;
723 	if (advertise)
724 		atcs_input.flags |= ATCS_ADVERTISE_CAPS;
725 	atcs_input.req_type = ATCS_PCIE_LINK_SPEED;
726 	atcs_input.perf_req = perf_req;
727 
728 	params.length = sizeof(struct atcs_pref_req_input);
729 	params.pointer = &atcs_input;
730 
731 	while (retry--) {
732 		info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST, &params);
733 		if (!info)
734 			return -EIO;
735 
736 		memset(&atcs_output, 0, sizeof(atcs_output));
737 
738 		size = *(u16 *) info->buffer.pointer;
739 		if (size < 3) {
740 			DRM_INFO("ATCS buffer is too small: %zu\n", size);
741 			kfree(info);
742 			return -EINVAL;
743 		}
744 		size = min(sizeof(atcs_output), size);
745 
746 		memcpy(&atcs_output, info->buffer.pointer, size);
747 
748 		kfree(info);
749 
750 		switch (atcs_output.ret_val) {
751 		case ATCS_REQUEST_REFUSED:
752 		default:
753 			return -EINVAL;
754 		case ATCS_REQUEST_COMPLETE:
755 			return 0;
756 		case ATCS_REQUEST_IN_PROGRESS:
757 			udelay(10);
758 			break;
759 		}
760 	}
761 
762 	return 0;
763 }
764 
765 /**
766  * amdgpu_acpi_power_shift_control
767  *
768  * @adev: amdgpu_device pointer
769  * @dev_state: device acpi state
770  * @drv_state: driver state
771  *
772  * Executes the POWER_SHIFT_CONTROL method to
773  * communicate current dGPU device state and
774  * driver state to APU/SBIOS.
775  * returns 0 on success, error on failure.
776  */
amdgpu_acpi_power_shift_control(struct amdgpu_device * adev,u8 dev_state,bool drv_state)777 int amdgpu_acpi_power_shift_control(struct amdgpu_device *adev,
778 				    u8 dev_state, bool drv_state)
779 {
780 	union acpi_object *info;
781 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
782 	struct atcs_pwr_shift_input atcs_input;
783 	struct acpi_buffer params;
784 
785 	if (!amdgpu_acpi_is_power_shift_control_supported())
786 		return -EINVAL;
787 
788 	atcs_input.size = sizeof(struct atcs_pwr_shift_input);
789 	/* dGPU id (bit 2-0: func num, 7-3: dev num, 15-8: bus num) */
790 	atcs_input.dgpu_id = pci_dev_id(adev->pdev);
791 	atcs_input.dev_acpi_state = dev_state;
792 	atcs_input.drv_state = drv_state;
793 
794 	params.length = sizeof(struct atcs_pwr_shift_input);
795 	params.pointer = &atcs_input;
796 
797 	info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_POWER_SHIFT_CONTROL, &params);
798 	if (!info) {
799 		DRM_ERROR("ATCS PSC update failed\n");
800 		return -EIO;
801 	}
802 
803 	return 0;
804 }
805 
806 /**
807  * amdgpu_acpi_smart_shift_update - update dGPU device state to SBIOS
808  *
809  * @dev: drm_device pointer
810  * @ss_state: current smart shift event
811  *
812  * returns 0 on success,
813  * otherwise return error number.
814  */
amdgpu_acpi_smart_shift_update(struct drm_device * dev,enum amdgpu_ss ss_state)815 int amdgpu_acpi_smart_shift_update(struct drm_device *dev, enum amdgpu_ss ss_state)
816 {
817 	struct amdgpu_device *adev = drm_to_adev(dev);
818 	int r;
819 
820 	if (!amdgpu_device_supports_smart_shift(dev))
821 		return 0;
822 
823 	switch (ss_state) {
824 	/* SBIOS trigger “stop”, “enable” and “start” at D0, Driver Operational.
825 	 * SBIOS trigger “stop” at D3, Driver Not Operational.
826 	 * SBIOS trigger “stop” and “disable” at D0, Driver NOT operational.
827 	 */
828 	case AMDGPU_SS_DRV_LOAD:
829 		r = amdgpu_acpi_power_shift_control(adev,
830 						    AMDGPU_ATCS_PSC_DEV_STATE_D0,
831 						    AMDGPU_ATCS_PSC_DRV_STATE_OPR);
832 		break;
833 	case AMDGPU_SS_DEV_D0:
834 		r = amdgpu_acpi_power_shift_control(adev,
835 						    AMDGPU_ATCS_PSC_DEV_STATE_D0,
836 						    AMDGPU_ATCS_PSC_DRV_STATE_OPR);
837 		break;
838 	case AMDGPU_SS_DEV_D3:
839 		r = amdgpu_acpi_power_shift_control(adev,
840 						    AMDGPU_ATCS_PSC_DEV_STATE_D3_HOT,
841 						    AMDGPU_ATCS_PSC_DRV_STATE_NOT_OPR);
842 		break;
843 	case AMDGPU_SS_DRV_UNLOAD:
844 		r = amdgpu_acpi_power_shift_control(adev,
845 						    AMDGPU_ATCS_PSC_DEV_STATE_D0,
846 						    AMDGPU_ATCS_PSC_DRV_STATE_NOT_OPR);
847 		break;
848 	default:
849 		return -EINVAL;
850 	}
851 
852 	return r;
853 }
854 
855 #ifdef CONFIG_ACPI_NUMA
amdgpu_acpi_get_numa_size(int nid)856 static inline uint64_t amdgpu_acpi_get_numa_size(int nid)
857 {
858 	/* This is directly using si_meminfo_node implementation as the
859 	 * function is not exported.
860 	 */
861 	int zone_type;
862 	uint64_t managed_pages = 0;
863 
864 	pg_data_t *pgdat = NODE_DATA(nid);
865 
866 	for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++)
867 		managed_pages +=
868 			zone_managed_pages(&pgdat->node_zones[zone_type]);
869 	return managed_pages * PAGE_SIZE;
870 }
871 
amdgpu_acpi_get_numa_info(uint32_t pxm)872 static struct amdgpu_numa_info *amdgpu_acpi_get_numa_info(uint32_t pxm)
873 {
874 	struct amdgpu_numa_info *numa_info;
875 	int nid;
876 
877 	numa_info = xa_load(&numa_info_xa, pxm);
878 
879 	if (!numa_info) {
880 		struct sysinfo info;
881 
882 		numa_info = kzalloc(sizeof(*numa_info), GFP_KERNEL);
883 		if (!numa_info)
884 			return NULL;
885 
886 		nid = pxm_to_node(pxm);
887 		numa_info->pxm = pxm;
888 		numa_info->nid = nid;
889 
890 		if (numa_info->nid == NUMA_NO_NODE) {
891 			si_meminfo(&info);
892 			numa_info->size = info.totalram * info.mem_unit;
893 		} else {
894 			numa_info->size = amdgpu_acpi_get_numa_size(nid);
895 		}
896 		xa_store(&numa_info_xa, numa_info->pxm, numa_info, GFP_KERNEL);
897 	}
898 
899 	return numa_info;
900 }
901 #endif
902 
903 /**
904  * amdgpu_acpi_get_node_id - obtain the NUMA node id for corresponding amdgpu
905  * acpi device handle
906  *
907  * @handle: acpi handle
908  * @numa_info: amdgpu_numa_info structure holding numa information
909  *
910  * Queries the ACPI interface to fetch the corresponding NUMA Node ID for a
911  * given amdgpu acpi device.
912  *
913  * Returns ACPI STATUS OK with Node ID on success or the corresponding failure reason
914  */
amdgpu_acpi_get_node_id(acpi_handle handle,struct amdgpu_numa_info ** numa_info)915 static acpi_status amdgpu_acpi_get_node_id(acpi_handle handle,
916 				    struct amdgpu_numa_info **numa_info)
917 {
918 #ifdef CONFIG_ACPI_NUMA
919 	u64 pxm;
920 	acpi_status status;
921 
922 	if (!numa_info)
923 		return_ACPI_STATUS(AE_ERROR);
924 
925 	status = acpi_evaluate_integer(handle, "_PXM", NULL, &pxm);
926 
927 	if (ACPI_FAILURE(status))
928 		return status;
929 
930 	*numa_info = amdgpu_acpi_get_numa_info(pxm);
931 
932 	if (!*numa_info)
933 		return_ACPI_STATUS(AE_ERROR);
934 
935 	return_ACPI_STATUS(AE_OK);
936 #else
937 	return_ACPI_STATUS(AE_NOT_EXIST);
938 #endif
939 }
940 
amdgpu_acpi_get_dev(u32 sbdf)941 static struct amdgpu_acpi_dev_info *amdgpu_acpi_get_dev(u32 sbdf)
942 {
943 	struct amdgpu_acpi_dev_info *acpi_dev;
944 
945 	if (list_empty(&amdgpu_acpi_dev_list))
946 		return NULL;
947 
948 	list_for_each_entry(acpi_dev, &amdgpu_acpi_dev_list, list)
949 		if (acpi_dev->sbdf == sbdf)
950 			return acpi_dev;
951 
952 	return NULL;
953 }
954 
amdgpu_acpi_dev_init(struct amdgpu_acpi_dev_info ** dev_info,struct amdgpu_acpi_xcc_info * xcc_info,u32 sbdf)955 static int amdgpu_acpi_dev_init(struct amdgpu_acpi_dev_info **dev_info,
956 				struct amdgpu_acpi_xcc_info *xcc_info, u32 sbdf)
957 {
958 	struct amdgpu_acpi_dev_info *tmp;
959 	union acpi_object *obj;
960 	int ret = -ENOENT;
961 
962 	*dev_info = NULL;
963 	tmp = kzalloc(sizeof(struct amdgpu_acpi_dev_info), GFP_KERNEL);
964 	if (!tmp)
965 		return -ENOMEM;
966 
967 	INIT_LIST_HEAD(&tmp->xcc_list);
968 	INIT_LIST_HEAD(&tmp->list);
969 	tmp->sbdf = sbdf;
970 
971 	obj = acpi_evaluate_dsm_typed(xcc_info->handle, &amd_xcc_dsm_guid, 0,
972 				      AMD_XCC_DSM_GET_SUPP_MODE, NULL,
973 				      ACPI_TYPE_INTEGER);
974 
975 	if (!obj) {
976 		acpi_handle_debug(xcc_info->handle,
977 				  "_DSM function %d evaluation failed",
978 				  AMD_XCC_DSM_GET_SUPP_MODE);
979 		ret = -ENOENT;
980 		goto out;
981 	}
982 
983 	tmp->supp_xcp_mode = obj->integer.value & 0xFFFF;
984 	ACPI_FREE(obj);
985 
986 	obj = acpi_evaluate_dsm_typed(xcc_info->handle, &amd_xcc_dsm_guid, 0,
987 				      AMD_XCC_DSM_GET_XCP_MODE, NULL,
988 				      ACPI_TYPE_INTEGER);
989 
990 	if (!obj) {
991 		acpi_handle_debug(xcc_info->handle,
992 				  "_DSM function %d evaluation failed",
993 				  AMD_XCC_DSM_GET_XCP_MODE);
994 		ret = -ENOENT;
995 		goto out;
996 	}
997 
998 	tmp->xcp_mode = obj->integer.value & 0xFFFF;
999 	tmp->mem_mode = (obj->integer.value >> 32) & 0xFFFF;
1000 	ACPI_FREE(obj);
1001 
1002 	/* Evaluate DSMs and fill XCC information */
1003 	obj = acpi_evaluate_dsm_typed(xcc_info->handle, &amd_xcc_dsm_guid, 0,
1004 				      AMD_XCC_DSM_GET_TMR_INFO, NULL,
1005 				      ACPI_TYPE_PACKAGE);
1006 
1007 	if (!obj || obj->package.count < 2) {
1008 		acpi_handle_debug(xcc_info->handle,
1009 				  "_DSM function %d evaluation failed",
1010 				  AMD_XCC_DSM_GET_TMR_INFO);
1011 		ret = -ENOENT;
1012 		goto out;
1013 	}
1014 
1015 	tmp->tmr_base = obj->package.elements[0].integer.value;
1016 	tmp->tmr_size = obj->package.elements[1].integer.value;
1017 	ACPI_FREE(obj);
1018 
1019 	DRM_DEBUG_DRIVER(
1020 		"New dev(%x): Supported xcp mode: %x curr xcp_mode : %x mem mode : %x, tmr base: %llx tmr size: %llx  ",
1021 		tmp->sbdf, tmp->supp_xcp_mode, tmp->xcp_mode, tmp->mem_mode,
1022 		tmp->tmr_base, tmp->tmr_size);
1023 	list_add_tail(&tmp->list, &amdgpu_acpi_dev_list);
1024 	*dev_info = tmp;
1025 
1026 	return 0;
1027 
1028 out:
1029 	if (obj)
1030 		ACPI_FREE(obj);
1031 	kfree(tmp);
1032 
1033 	return ret;
1034 }
1035 
amdgpu_acpi_get_xcc_info(struct amdgpu_acpi_xcc_info * xcc_info,u32 * sbdf)1036 static int amdgpu_acpi_get_xcc_info(struct amdgpu_acpi_xcc_info *xcc_info,
1037 				    u32 *sbdf)
1038 {
1039 	union acpi_object *obj;
1040 	acpi_status status;
1041 	int ret = -ENOENT;
1042 
1043 	obj = acpi_evaluate_dsm_typed(xcc_info->handle, &amd_xcc_dsm_guid, 0,
1044 				      AMD_XCC_DSM_GET_NUM_FUNCS, NULL,
1045 				      ACPI_TYPE_INTEGER);
1046 
1047 	if (!obj || obj->integer.value != AMD_XCC_DSM_NUM_FUNCS)
1048 		goto out;
1049 	ACPI_FREE(obj);
1050 
1051 	/* Evaluate DSMs and fill XCC information */
1052 	obj = acpi_evaluate_dsm_typed(xcc_info->handle, &amd_xcc_dsm_guid, 0,
1053 				      AMD_XCC_DSM_GET_VF_XCC_MAPPING, NULL,
1054 				      ACPI_TYPE_INTEGER);
1055 
1056 	if (!obj) {
1057 		acpi_handle_debug(xcc_info->handle,
1058 				  "_DSM function %d evaluation failed",
1059 				  AMD_XCC_DSM_GET_VF_XCC_MAPPING);
1060 		ret = -EINVAL;
1061 		goto out;
1062 	}
1063 
1064 	/* PF xcc id [39:32] */
1065 	xcc_info->phy_id = (obj->integer.value >> 32) & 0xFF;
1066 	/* xcp node of this xcc [47:40] */
1067 	xcc_info->xcp_node = (obj->integer.value >> 40) & 0xFF;
1068 	/* PF domain of this xcc [31:16] */
1069 	*sbdf = (obj->integer.value) & 0xFFFF0000;
1070 	/* PF bus/dev/fn of this xcc [63:48] */
1071 	*sbdf |= (obj->integer.value >> 48) & 0xFFFF;
1072 	ACPI_FREE(obj);
1073 	obj = NULL;
1074 
1075 	status =
1076 		amdgpu_acpi_get_node_id(xcc_info->handle, &xcc_info->numa_info);
1077 
1078 	/* TODO: check if this check is required */
1079 	if (ACPI_SUCCESS(status))
1080 		ret = 0;
1081 out:
1082 	if (obj)
1083 		ACPI_FREE(obj);
1084 
1085 	return ret;
1086 }
1087 
amdgpu_acpi_enumerate_xcc(void)1088 static int amdgpu_acpi_enumerate_xcc(void)
1089 {
1090 	struct amdgpu_acpi_dev_info *dev_info = NULL;
1091 	struct amdgpu_acpi_xcc_info *xcc_info;
1092 	struct acpi_device *acpi_dev;
1093 	char hid[ACPI_ID_LEN];
1094 	int ret, id;
1095 	u32 sbdf;
1096 
1097 	INIT_LIST_HEAD(&amdgpu_acpi_dev_list);
1098 	xa_init(&numa_info_xa);
1099 
1100 	for (id = 0; id < AMD_XCC_MAX_HID; id++) {
1101 		sprintf(hid, "%s%d", "AMD", AMD_XCC_HID_START + id);
1102 		acpi_dev = acpi_dev_get_first_match_dev(hid, NULL, -1);
1103 		/* These ACPI objects are expected to be in sequential order. If
1104 		 * one is not found, no need to check the rest.
1105 		 */
1106 		if (!acpi_dev) {
1107 			DRM_DEBUG_DRIVER("No matching acpi device found for %s",
1108 					 hid);
1109 			break;
1110 		}
1111 
1112 		xcc_info = kzalloc(sizeof(struct amdgpu_acpi_xcc_info),
1113 				   GFP_KERNEL);
1114 		if (!xcc_info) {
1115 			DRM_ERROR("Failed to allocate memory for xcc info\n");
1116 			return -ENOMEM;
1117 		}
1118 
1119 		INIT_LIST_HEAD(&xcc_info->list);
1120 		xcc_info->handle = acpi_device_handle(acpi_dev);
1121 		acpi_dev_put(acpi_dev);
1122 
1123 		ret = amdgpu_acpi_get_xcc_info(xcc_info, &sbdf);
1124 		if (ret) {
1125 			kfree(xcc_info);
1126 			continue;
1127 		}
1128 
1129 		dev_info = amdgpu_acpi_get_dev(sbdf);
1130 
1131 		if (!dev_info)
1132 			ret = amdgpu_acpi_dev_init(&dev_info, xcc_info, sbdf);
1133 
1134 		if (ret == -ENOMEM)
1135 			return ret;
1136 
1137 		if (!dev_info) {
1138 			kfree(xcc_info);
1139 			continue;
1140 		}
1141 
1142 		list_add_tail(&xcc_info->list, &dev_info->xcc_list);
1143 	}
1144 
1145 	return 0;
1146 }
1147 
amdgpu_acpi_get_tmr_info(struct amdgpu_device * adev,u64 * tmr_offset,u64 * tmr_size)1148 int amdgpu_acpi_get_tmr_info(struct amdgpu_device *adev, u64 *tmr_offset,
1149 			     u64 *tmr_size)
1150 {
1151 	struct amdgpu_acpi_dev_info *dev_info;
1152 	u32 sbdf;
1153 
1154 	if (!tmr_offset || !tmr_size)
1155 		return -EINVAL;
1156 
1157 	sbdf = (pci_domain_nr(adev->pdev->bus) << 16);
1158 	sbdf |= pci_dev_id(adev->pdev);
1159 	dev_info = amdgpu_acpi_get_dev(sbdf);
1160 	if (!dev_info)
1161 		return -ENOENT;
1162 
1163 	*tmr_offset = dev_info->tmr_base;
1164 	*tmr_size = dev_info->tmr_size;
1165 
1166 	return 0;
1167 }
1168 
amdgpu_acpi_get_mem_info(struct amdgpu_device * adev,int xcc_id,struct amdgpu_numa_info * numa_info)1169 int amdgpu_acpi_get_mem_info(struct amdgpu_device *adev, int xcc_id,
1170 			     struct amdgpu_numa_info *numa_info)
1171 {
1172 	struct amdgpu_acpi_dev_info *dev_info;
1173 	struct amdgpu_acpi_xcc_info *xcc_info;
1174 	u32 sbdf;
1175 
1176 	if (!numa_info)
1177 		return -EINVAL;
1178 
1179 	sbdf = (pci_domain_nr(adev->pdev->bus) << 16);
1180 	sbdf |= pci_dev_id(adev->pdev);
1181 	dev_info = amdgpu_acpi_get_dev(sbdf);
1182 	if (!dev_info)
1183 		return -ENOENT;
1184 
1185 	list_for_each_entry(xcc_info, &dev_info->xcc_list, list) {
1186 		if (xcc_info->phy_id == xcc_id) {
1187 			memcpy(numa_info, xcc_info->numa_info,
1188 			       sizeof(*numa_info));
1189 			return 0;
1190 		}
1191 	}
1192 
1193 	return -ENOENT;
1194 }
1195 
1196 /**
1197  * amdgpu_acpi_event - handle notify events
1198  *
1199  * @nb: notifier block
1200  * @val: val
1201  * @data: acpi event
1202  *
1203  * Calls relevant amdgpu functions in response to various
1204  * acpi events.
1205  * Returns NOTIFY code
1206  */
amdgpu_acpi_event(struct notifier_block * nb,unsigned long val,void * data)1207 static int amdgpu_acpi_event(struct notifier_block *nb,
1208 			     unsigned long val,
1209 			     void *data)
1210 {
1211 	struct amdgpu_device *adev = container_of(nb, struct amdgpu_device, acpi_nb);
1212 	struct acpi_bus_event *entry = (struct acpi_bus_event *)data;
1213 
1214 	if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) {
1215 		if (power_supply_is_system_supplied() > 0)
1216 			DRM_DEBUG_DRIVER("pm: AC\n");
1217 		else
1218 			DRM_DEBUG_DRIVER("pm: DC\n");
1219 
1220 		amdgpu_pm_acpi_event_handler(adev);
1221 	}
1222 
1223 	/* Check for pending SBIOS requests */
1224 	return amdgpu_atif_handler(adev, entry);
1225 }
1226 
1227 /* Call all ACPI methods here */
1228 /**
1229  * amdgpu_acpi_init - init driver acpi support
1230  *
1231  * @adev: amdgpu_device pointer
1232  *
1233  * Verifies the AMD ACPI interfaces and registers with the acpi
1234  * notifier chain (all asics).
1235  * Returns 0 on success, error on failure.
1236  */
amdgpu_acpi_init(struct amdgpu_device * adev)1237 int amdgpu_acpi_init(struct amdgpu_device *adev)
1238 {
1239 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
1240 
1241 	if (atif->notifications.brightness_change) {
1242 		if (adev->dc_enabled) {
1243 #if defined(CONFIG_DRM_AMD_DC)
1244 			struct amdgpu_display_manager *dm = &adev->dm;
1245 
1246 			if (dm->backlight_dev[0])
1247 				atif->bd = dm->backlight_dev[0];
1248 #endif
1249 		} else {
1250 			struct drm_encoder *tmp;
1251 
1252 			/* Find the encoder controlling the brightness */
1253 			list_for_each_entry(tmp, &adev_to_drm(adev)->mode_config.encoder_list,
1254 					    head) {
1255 				struct amdgpu_encoder *enc = to_amdgpu_encoder(tmp);
1256 
1257 				if ((enc->devices & (ATOM_DEVICE_LCD_SUPPORT)) &&
1258 				    enc->enc_priv) {
1259 					struct amdgpu_encoder_atom_dig *dig = enc->enc_priv;
1260 
1261 					if (dig->bl_dev) {
1262 						atif->bd = dig->bl_dev;
1263 						break;
1264 					}
1265 				}
1266 			}
1267 		}
1268 	}
1269 	adev->acpi_nb.notifier_call = amdgpu_acpi_event;
1270 	register_acpi_notifier(&adev->acpi_nb);
1271 
1272 	return 0;
1273 }
1274 
amdgpu_acpi_get_backlight_caps(struct amdgpu_dm_backlight_caps * caps)1275 void amdgpu_acpi_get_backlight_caps(struct amdgpu_dm_backlight_caps *caps)
1276 {
1277 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
1278 
1279 	caps->caps_valid = atif->backlight_caps.caps_valid;
1280 	caps->min_input_signal = atif->backlight_caps.min_input_signal;
1281 	caps->max_input_signal = atif->backlight_caps.max_input_signal;
1282 	caps->ac_level = atif->backlight_caps.ac_level;
1283 	caps->dc_level = atif->backlight_caps.dc_level;
1284 }
1285 
1286 /**
1287  * amdgpu_acpi_fini - tear down driver acpi support
1288  *
1289  * @adev: amdgpu_device pointer
1290  *
1291  * Unregisters with the acpi notifier chain (all asics).
1292  */
amdgpu_acpi_fini(struct amdgpu_device * adev)1293 void amdgpu_acpi_fini(struct amdgpu_device *adev)
1294 {
1295 	unregister_acpi_notifier(&adev->acpi_nb);
1296 }
1297 
1298 /**
1299  * amdgpu_atif_pci_probe_handle - look up the ATIF handle
1300  *
1301  * @pdev: pci device
1302  *
1303  * Look up the ATIF handles (all asics).
1304  * Returns true if the handle is found, false if not.
1305  */
amdgpu_atif_pci_probe_handle(struct pci_dev * pdev)1306 static bool amdgpu_atif_pci_probe_handle(struct pci_dev *pdev)
1307 {
1308 	char acpi_method_name[255] = { 0 };
1309 	struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
1310 	acpi_handle dhandle, atif_handle;
1311 	acpi_status status;
1312 	int ret;
1313 
1314 	dhandle = ACPI_HANDLE(&pdev->dev);
1315 	if (!dhandle)
1316 		return false;
1317 
1318 	status = acpi_get_handle(dhandle, "ATIF", &atif_handle);
1319 	if (ACPI_FAILURE(status))
1320 		return false;
1321 
1322 	amdgpu_acpi_priv.atif.handle = atif_handle;
1323 	acpi_get_name(amdgpu_acpi_priv.atif.handle, ACPI_FULL_PATHNAME, &buffer);
1324 	DRM_DEBUG_DRIVER("Found ATIF handle %s\n", acpi_method_name);
1325 	ret = amdgpu_atif_verify_interface(&amdgpu_acpi_priv.atif);
1326 	if (ret) {
1327 		amdgpu_acpi_priv.atif.handle = 0;
1328 		return false;
1329 	}
1330 	return true;
1331 }
1332 
1333 /**
1334  * amdgpu_atcs_pci_probe_handle - look up the ATCS handle
1335  *
1336  * @pdev: pci device
1337  *
1338  * Look up the ATCS handles (all asics).
1339  * Returns true if the handle is found, false if not.
1340  */
amdgpu_atcs_pci_probe_handle(struct pci_dev * pdev)1341 static bool amdgpu_atcs_pci_probe_handle(struct pci_dev *pdev)
1342 {
1343 	char acpi_method_name[255] = { 0 };
1344 	struct acpi_buffer buffer = { sizeof(acpi_method_name), acpi_method_name };
1345 	acpi_handle dhandle, atcs_handle;
1346 	acpi_status status;
1347 	int ret;
1348 
1349 	dhandle = ACPI_HANDLE(&pdev->dev);
1350 	if (!dhandle)
1351 		return false;
1352 
1353 	status = acpi_get_handle(dhandle, "ATCS", &atcs_handle);
1354 	if (ACPI_FAILURE(status))
1355 		return false;
1356 
1357 	amdgpu_acpi_priv.atcs.handle = atcs_handle;
1358 	acpi_get_name(amdgpu_acpi_priv.atcs.handle, ACPI_FULL_PATHNAME, &buffer);
1359 	DRM_DEBUG_DRIVER("Found ATCS handle %s\n", acpi_method_name);
1360 	ret = amdgpu_atcs_verify_interface(&amdgpu_acpi_priv.atcs);
1361 	if (ret) {
1362 		amdgpu_acpi_priv.atcs.handle = 0;
1363 		return false;
1364 	}
1365 	return true;
1366 }
1367 
1368 
1369 /**
1370  * amdgpu_acpi_should_gpu_reset
1371  *
1372  * @adev: amdgpu_device_pointer
1373  *
1374  * returns true if should reset GPU, false if not
1375  */
amdgpu_acpi_should_gpu_reset(struct amdgpu_device * adev)1376 bool amdgpu_acpi_should_gpu_reset(struct amdgpu_device *adev)
1377 {
1378 	if ((adev->flags & AMD_IS_APU) &&
1379 	    adev->gfx.imu.funcs) /* Not need to do mode2 reset for IMU enabled APUs */
1380 		return false;
1381 
1382 	if ((adev->flags & AMD_IS_APU) &&
1383 	    amdgpu_acpi_is_s3_active(adev))
1384 		return false;
1385 
1386 	if (amdgpu_sriov_vf(adev))
1387 		return false;
1388 
1389 #if IS_ENABLED(CONFIG_SUSPEND)
1390 	return pm_suspend_target_state != PM_SUSPEND_TO_IDLE;
1391 #else
1392 	return true;
1393 #endif
1394 }
1395 
1396 /*
1397  * amdgpu_acpi_detect - detect ACPI ATIF/ATCS methods
1398  *
1399  * Check if we have the ATIF/ATCS methods and populate
1400  * the structures in the driver.
1401  */
amdgpu_acpi_detect(void)1402 void amdgpu_acpi_detect(void)
1403 {
1404 	struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif;
1405 	struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs;
1406 	struct pci_dev *pdev = NULL;
1407 	int ret;
1408 
1409 	while ((pdev = pci_get_base_class(PCI_BASE_CLASS_DISPLAY, pdev))) {
1410 		if ((pdev->class != PCI_CLASS_DISPLAY_VGA << 8) &&
1411 		    (pdev->class != PCI_CLASS_DISPLAY_OTHER << 8))
1412 			continue;
1413 
1414 		if (!atif->handle)
1415 			amdgpu_atif_pci_probe_handle(pdev);
1416 		if (!atcs->handle)
1417 			amdgpu_atcs_pci_probe_handle(pdev);
1418 	}
1419 
1420 	if (atif->functions.sbios_requests && !atif->functions.system_params) {
1421 		/* XXX check this workraround, if sbios request function is
1422 		 * present we have to see how it's configured in the system
1423 		 * params
1424 		 */
1425 		atif->functions.system_params = true;
1426 	}
1427 
1428 	if (atif->functions.system_params) {
1429 		ret = amdgpu_atif_get_notification_params(atif);
1430 		if (ret) {
1431 			DRM_DEBUG_DRIVER("Call to GET_SYSTEM_PARAMS failed: %d\n",
1432 					ret);
1433 			/* Disable notification */
1434 			atif->notification_cfg.enabled = false;
1435 		}
1436 	}
1437 
1438 	if (atif->functions.query_backlight_transfer_characteristics) {
1439 		ret = amdgpu_atif_query_backlight_caps(atif);
1440 		if (ret) {
1441 			DRM_DEBUG_DRIVER("Call to QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS failed: %d\n",
1442 					ret);
1443 			atif->backlight_caps.caps_valid = false;
1444 		}
1445 	} else {
1446 		atif->backlight_caps.caps_valid = false;
1447 	}
1448 
1449 	amdgpu_acpi_enumerate_xcc();
1450 }
1451 
amdgpu_acpi_release(void)1452 void amdgpu_acpi_release(void)
1453 {
1454 	struct amdgpu_acpi_dev_info *dev_info, *dev_tmp;
1455 	struct amdgpu_acpi_xcc_info *xcc_info, *xcc_tmp;
1456 	struct amdgpu_numa_info *numa_info;
1457 	unsigned long index;
1458 
1459 	xa_for_each(&numa_info_xa, index, numa_info) {
1460 		kfree(numa_info);
1461 		xa_erase(&numa_info_xa, index);
1462 	}
1463 
1464 	if (list_empty(&amdgpu_acpi_dev_list))
1465 		return;
1466 
1467 	list_for_each_entry_safe(dev_info, dev_tmp, &amdgpu_acpi_dev_list,
1468 				 list) {
1469 		list_for_each_entry_safe(xcc_info, xcc_tmp, &dev_info->xcc_list,
1470 					 list) {
1471 			list_del(&xcc_info->list);
1472 			kfree(xcc_info);
1473 		}
1474 
1475 		list_del(&dev_info->list);
1476 		kfree(dev_info);
1477 	}
1478 }
1479 
1480 #if IS_ENABLED(CONFIG_SUSPEND)
1481 /**
1482  * amdgpu_acpi_is_s3_active
1483  *
1484  * @adev: amdgpu_device_pointer
1485  *
1486  * returns true if supported, false if not.
1487  */
amdgpu_acpi_is_s3_active(struct amdgpu_device * adev)1488 bool amdgpu_acpi_is_s3_active(struct amdgpu_device *adev)
1489 {
1490 	return !(adev->flags & AMD_IS_APU) ||
1491 		(pm_suspend_target_state == PM_SUSPEND_MEM);
1492 }
1493 
1494 /**
1495  * amdgpu_acpi_is_s0ix_active
1496  *
1497  * @adev: amdgpu_device_pointer
1498  *
1499  * returns true if supported, false if not.
1500  */
amdgpu_acpi_is_s0ix_active(struct amdgpu_device * adev)1501 bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev)
1502 {
1503 	if (!(adev->flags & AMD_IS_APU) ||
1504 	    (pm_suspend_target_state != PM_SUSPEND_TO_IDLE))
1505 		return false;
1506 
1507 	if (adev->asic_type < CHIP_RAVEN)
1508 		return false;
1509 
1510 	if (!(adev->pm.pp_feature & PP_GFXOFF_MASK))
1511 		return false;
1512 
1513 	/*
1514 	 * If ACPI_FADT_LOW_POWER_S0 is not set in the FADT, it is generally
1515 	 * risky to do any special firmware-related preparations for entering
1516 	 * S0ix even though the system is suspending to idle, so return false
1517 	 * in that case.
1518 	 */
1519 	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)) {
1520 		dev_err_once(adev->dev,
1521 			      "Power consumption will be higher as BIOS has not been configured for suspend-to-idle.\n"
1522 			      "To use suspend-to-idle change the sleep mode in BIOS setup.\n");
1523 		return false;
1524 	}
1525 
1526 #if !IS_ENABLED(CONFIG_AMD_PMC)
1527 	dev_err_once(adev->dev,
1528 		      "Power consumption will be higher as the kernel has not been compiled with CONFIG_AMD_PMC.\n");
1529 	return false;
1530 #else
1531 	return true;
1532 #endif /* CONFIG_AMD_PMC */
1533 }
1534 
1535 /**
1536  * amdgpu_choose_low_power_state
1537  *
1538  * @adev: amdgpu_device_pointer
1539  *
1540  * Choose the target low power state for the GPU
1541  */
amdgpu_choose_low_power_state(struct amdgpu_device * adev)1542 void amdgpu_choose_low_power_state(struct amdgpu_device *adev)
1543 {
1544 	if (adev->in_runpm)
1545 		return;
1546 
1547 	if (amdgpu_acpi_is_s0ix_active(adev))
1548 		adev->in_s0ix = true;
1549 	else if (amdgpu_acpi_is_s3_active(adev))
1550 		adev->in_s3 = true;
1551 }
1552 
1553 #endif /* CONFIG_SUSPEND */
1554