Commit | Line | Data |
---|---|---|
556bdae3 | 1 | // SPDX-License-Identifier: MIT |
d38ceaf9 AD |
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> | |
a6276e92 | 27 | #include <linux/backlight.h> |
d38ceaf9 AD |
28 | #include <linux/slab.h> |
29 | #include <linux/power_supply.h> | |
1b0f568d | 30 | #include <linux/pm_runtime.h> |
91b03fc6 | 31 | #include <linux/suspend.h> |
d38ceaf9 | 32 | #include <acpi/video.h> |
4cd078dc | 33 | #include <acpi/actbl.h> |
fdf2f6c5 | 34 | |
d38ceaf9 | 35 | #include "amdgpu.h" |
98c65108 | 36 | #include "amdgpu_pm.h" |
5df58525 | 37 | #include "amdgpu_display.h" |
66dc0ddd | 38 | #include "amd_acpi.h" |
d38ceaf9 AD |
39 | #include "atom.h" |
40 | ||
102c16a0 LP |
41 | struct amdgpu_atif_notification_cfg { |
42 | bool enabled; | |
43 | int command_code; | |
44 | }; | |
45 | ||
46 | struct amdgpu_atif_notifications { | |
102c16a0 LP |
47 | bool thermal_state; |
48 | bool forced_power_state; | |
49 | bool system_power_state; | |
102c16a0 LP |
50 | bool brightness_change; |
51 | bool dgpu_display_event; | |
7349a3af | 52 | bool gpu_package_power_limit; |
102c16a0 LP |
53 | }; |
54 | ||
55 | struct amdgpu_atif_functions { | |
56 | bool system_params; | |
57 | bool sbios_requests; | |
102c16a0 | 58 | bool temperature_change; |
7349a3af DF |
59 | bool query_backlight_transfer_characteristics; |
60 | bool ready_to_undock; | |
61 | bool external_gpu_information; | |
102c16a0 LP |
62 | }; |
63 | ||
64 | struct amdgpu_atif { | |
280cf1a9 LP |
65 | acpi_handle handle; |
66 | ||
102c16a0 LP |
67 | struct amdgpu_atif_notifications notifications; |
68 | struct amdgpu_atif_functions functions; | |
69 | struct amdgpu_atif_notification_cfg notification_cfg; | |
97d798b2 | 70 | struct backlight_device *bd; |
206bbafe | 71 | struct amdgpu_dm_backlight_caps backlight_caps; |
102c16a0 LP |
72 | }; |
73 | ||
77bf762f AD |
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; | |
16eb48c6 | 79 | bool power_shift_control; |
77bf762f AD |
80 | }; |
81 | ||
82 | struct amdgpu_atcs { | |
83 | acpi_handle handle; | |
84 | ||
85 | struct amdgpu_atcs_functions functions; | |
86 | }; | |
87 | ||
f9b7f370 AD |
88 | static struct amdgpu_acpi_priv { |
89 | struct amdgpu_atif atif; | |
90 | struct amdgpu_atcs atcs; | |
91 | } amdgpu_acpi_priv; | |
92 | ||
d38ceaf9 AD |
93 | /* Call the ATIF method |
94 | */ | |
95 | /** | |
96 | * amdgpu_atif_call - call an ATIF method | |
97 | * | |
77bf762f | 98 | * @atif: atif structure |
d38ceaf9 AD |
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 | */ | |
280cf1a9 LP |
105 | static union acpi_object *amdgpu_atif_call(struct amdgpu_atif *atif, |
106 | int function, | |
107 | struct acpi_buffer *params) | |
d38ceaf9 AD |
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 | ||
280cf1a9 LP |
130 | status = acpi_evaluate_object(atif->handle, NULL, &atif_arg, |
131 | &buffer); | |
d38ceaf9 AD |
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 | { | |
d38ceaf9 AD |
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; | |
d38ceaf9 AD |
159 | n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED; |
160 | n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED; | |
7349a3af | 161 | n->gpu_package_power_limit = mask & ATIF_GPU_PACKAGE_POWER_LIMIT_REQUEST_SUPPORTED; |
d38ceaf9 AD |
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; | |
d38ceaf9 | 178 | f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED; |
7349a3af DF |
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; | |
d38ceaf9 AD |
183 | } |
184 | ||
185 | /** | |
186 | * amdgpu_atif_verify_interface - verify ATIF | |
187 | * | |
d38ceaf9 AD |
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 | */ | |
280cf1a9 | 195 | static int amdgpu_atif_verify_interface(struct amdgpu_atif *atif) |
d38ceaf9 AD |
196 | { |
197 | union acpi_object *info; | |
198 | struct atif_verify_interface output; | |
199 | size_t size; | |
200 | int err = 0; | |
201 | ||
280cf1a9 | 202 | info = amdgpu_atif_call(atif, ATIF_FUNCTION_VERIFY_INTERFACE, NULL); |
d38ceaf9 AD |
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 | * | |
1fdbbc12 | 232 | * @atif: acpi handle |
d38ceaf9 AD |
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 | */ | |
280cf1a9 | 240 | static int amdgpu_atif_get_notification_params(struct amdgpu_atif *atif) |
d38ceaf9 AD |
241 | { |
242 | union acpi_object *info; | |
280cf1a9 | 243 | struct amdgpu_atif_notification_cfg *n = &atif->notification_cfg; |
d38ceaf9 AD |
244 | struct atif_system_params params; |
245 | size_t size; | |
246 | int err = 0; | |
247 | ||
280cf1a9 LP |
248 | info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS, |
249 | NULL); | |
d38ceaf9 AD |
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(¶ms, 0, sizeof(params)); | |
262 | size = min(sizeof(params), size); | |
263 | memcpy(¶ms, 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 | ||
206bbafe DF |
292 | /** |
293 | * amdgpu_atif_query_backlight_caps - get min and max backlight input signal | |
294 | * | |
1fdbbc12 | 295 | * @atif: acpi handle |
206bbafe DF |
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 | ¶ms); | |
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 | ||
d38ceaf9 AD |
351 | /** |
352 | * amdgpu_atif_get_sbios_requests - get requested sbios event | |
353 | * | |
1fdbbc12 | 354 | * @atif: acpi handle |
d38ceaf9 AD |
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 | */ | |
280cf1a9 LP |
362 | static int amdgpu_atif_get_sbios_requests(struct amdgpu_atif *atif, |
363 | struct atif_sbios_requests *req) | |
d38ceaf9 AD |
364 | { |
365 | union acpi_object *info; | |
366 | size_t size; | |
367 | int count = 0; | |
368 | ||
280cf1a9 LP |
369 | info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS, |
370 | NULL); | |
d38ceaf9 AD |
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. | |
582f58de LP |
400 | * |
401 | * Returns: | |
402 | * NOTIFY_BAD or NOTIFY_DONE, depending on the event. | |
d38ceaf9 | 403 | */ |
b7cecbe8 | 404 | static int amdgpu_atif_handler(struct amdgpu_device *adev, |
280cf1a9 | 405 | struct acpi_bus_event *event) |
d38ceaf9 | 406 | { |
f9b7f370 | 407 | struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif; |
d38ceaf9 AD |
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 | ||
582f58de | 416 | /* Is this actually our event? */ |
f9b7f370 | 417 | if (!atif->notification_cfg.enabled || |
582f58de LP |
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 | } | |
d38ceaf9 | 425 | |
9e7204be AD |
426 | if (atif->functions.sbios_requests) { |
427 | struct atif_sbios_requests req; | |
d38ceaf9 | 428 | |
9e7204be AD |
429 | /* Check pending SBIOS requests */ |
430 | count = amdgpu_atif_get_sbios_requests(atif, &req); | |
431 | ||
432 | if (count <= 0) | |
582f58de | 433 | return NOTIFY_BAD; |
d38ceaf9 | 434 | |
9e7204be | 435 | DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count); |
d38ceaf9 | 436 | |
97d798b2 | 437 | if (req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) { |
97d798b2 | 438 | if (atif->bd) { |
bcb7b0ef AG |
439 | DRM_DEBUG_DRIVER("Changing brightness to %d\n", |
440 | req.backlight_level); | |
bcb7b0ef AG |
441 | /* |
442 | * XXX backlight_device_set_brightness() is | |
443 | * hardwired to post BACKLIGHT_UPDATE_SYSFS. | |
444 | * It probably should accept 'reason' parameter. | |
445 | */ | |
97d798b2 | 446 | backlight_device_set_brightness(atif->bd, req.backlight_level); |
bcb7b0ef | 447 | } |
97d798b2 AD |
448 | } |
449 | ||
9e7204be | 450 | if (req.pending & ATIF_DGPU_DISPLAY_EVENT) { |
bdb1ccb0 | 451 | if (adev->flags & AMD_IS_PX) { |
4a580877 | 452 | pm_runtime_get_sync(adev_to_drm(adev)->dev); |
9e7204be | 453 | /* Just fire off a uevent and let userspace tell us what to do */ |
4a580877 LT |
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); | |
9e7204be | 457 | } |
1b0f568d | 458 | } |
9e7204be | 459 | /* TODO: check other events */ |
1b0f568d | 460 | } |
d38ceaf9 AD |
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 | * | |
77bf762f | 475 | * @atcs: atcs structure |
d38ceaf9 AD |
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 | */ | |
77bf762f AD |
482 | static union acpi_object *amdgpu_atcs_call(struct amdgpu_atcs *atcs, |
483 | int function, | |
d38ceaf9 AD |
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 | ||
4965257f | 507 | status = acpi_evaluate_object(atcs->handle, NULL, &atcs_arg, &buffer); |
d38ceaf9 AD |
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; | |
16eb48c6 | 536 | f->power_shift_control = mask & ATCS_SET_POWER_SHIFT_CONTROL_SUPPORTED; |
d38ceaf9 AD |
537 | } |
538 | ||
539 | /** | |
540 | * amdgpu_atcs_verify_interface - verify ATCS | |
541 | * | |
d38ceaf9 AD |
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 | */ | |
77bf762f | 549 | static int amdgpu_atcs_verify_interface(struct amdgpu_atcs *atcs) |
d38ceaf9 AD |
550 | { |
551 | union acpi_object *info; | |
552 | struct atcs_verify_interface output; | |
553 | size_t size; | |
554 | int err = 0; | |
555 | ||
77bf762f | 556 | info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_VERIFY_INTERFACE, NULL); |
d38ceaf9 AD |
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 | { | |
f9b7f370 | 593 | struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs; |
d38ceaf9 AD |
594 | |
595 | if (atcs->functions.pcie_perf_req && atcs->functions.pcie_dev_rdy) | |
596 | return true; | |
597 | ||
598 | return false; | |
599 | } | |
600 | ||
16eb48c6 S |
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 | ||
d38ceaf9 AD |
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 | { | |
d38ceaf9 | 624 | union acpi_object *info; |
f9b7f370 | 625 | struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs; |
d38ceaf9 | 626 | |
d38ceaf9 AD |
627 | if (!atcs->functions.pcie_dev_rdy) |
628 | return -EINVAL; | |
629 | ||
77bf762f | 630 | info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION, NULL); |
d38ceaf9 AD |
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 | { | |
d38ceaf9 | 653 | union acpi_object *info; |
f9b7f370 | 654 | struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs; |
d38ceaf9 AD |
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 | ||
77bf762f | 661 | if (amdgpu_acpi_pcie_notify_device_ready(adev)) |
d38ceaf9 AD |
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--) { | |
77bf762f | 681 | info = amdgpu_atcs_call(atcs, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST, ¶ms); |
d38ceaf9 AD |
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 | ||
16eb48c6 S |
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, ¶ms); | |
747 | if (!info) { | |
748 | DRM_ERROR("ATCS PSC update failed\n"); | |
749 | return -EIO; | |
750 | } | |
751 | ||
752 | return 0; | |
753 | } | |
754 | ||
3fa8f89d S |
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 | ||
d38ceaf9 AD |
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 | { | |
f9b7f370 | 847 | struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif; |
d38ceaf9 | 848 | |
9c27bc97 | 849 | if (atif->notifications.brightness_change) { |
d09ef243 | 850 | if (adev->dc_enabled) { |
97d798b2 AD |
851 | #if defined(CONFIG_DRM_AMD_DC) |
852 | struct amdgpu_display_manager *dm = &adev->dm; | |
556bdae3 | 853 | |
7fd13bae AD |
854 | if (dm->backlight_dev[0]) |
855 | atif->bd = dm->backlight_dev[0]; | |
97d798b2 AD |
856 | #endif |
857 | } else { | |
858 | struct drm_encoder *tmp; | |
859 | ||
860 | /* Find the encoder controlling the brightness */ | |
4a580877 | 861 | list_for_each_entry(tmp, &adev_to_drm(adev)->mode_config.encoder_list, |
97d798b2 AD |
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; | |
556bdae3 | 868 | |
97d798b2 AD |
869 | if (dig->bl_dev) { |
870 | atif->bd = dig->bl_dev; | |
871 | break; | |
872 | } | |
d38ceaf9 AD |
873 | } |
874 | } | |
875 | } | |
876 | } | |
f9b7f370 AD |
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); | |
556bdae3 | 925 | if (ACPI_FAILURE(status)) |
f9b7f370 | 926 | return false; |
556bdae3 | 927 | |
f9b7f370 AD |
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); | |
556bdae3 | 960 | if (ACPI_FAILURE(status)) |
f9b7f370 | 961 | return false; |
556bdae3 | 962 | |
f9b7f370 AD |
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 | ||
aaee0ce4 TH |
974 | |
975 | /** | |
976 | * amdgpu_acpi_should_gpu_reset | |
977 | * | |
978 | * @adev: amdgpu_device_pointer | |
979 | * | |
980 | * returns true if should reset GPU, false if not | |
981 | */ | |
982 | bool amdgpu_acpi_should_gpu_reset(struct amdgpu_device *adev) | |
983 | { | |
2fec9dc8 TH |
984 | if ((adev->flags & AMD_IS_APU) && |
985 | adev->gfx.imu.funcs) /* Not need to do mode2 reset for IMU enabled APUs */ | |
986 | return false; | |
987 | ||
988 | if ((adev->flags & AMD_IS_APU) && | |
989 | amdgpu_acpi_is_s3_active(adev)) | |
aaee0ce4 TH |
990 | return false; |
991 | ||
992 | if (amdgpu_sriov_vf(adev)) | |
993 | return false; | |
994 | ||
995 | #if IS_ENABLED(CONFIG_SUSPEND) | |
996 | return pm_suspend_target_state != PM_SUSPEND_TO_IDLE; | |
997 | #else | |
998 | return true; | |
999 | #endif | |
1000 | } | |
1001 | ||
f9b7f370 AD |
1002 | /* |
1003 | * amdgpu_acpi_detect - detect ACPI ATIF/ATCS methods | |
1004 | * | |
1005 | * Check if we have the ATIF/ATCS methods and populate | |
1006 | * the structures in the driver. | |
1007 | */ | |
1008 | void amdgpu_acpi_detect(void) | |
1009 | { | |
1010 | struct amdgpu_atif *atif = &amdgpu_acpi_priv.atif; | |
1011 | struct amdgpu_atcs *atcs = &amdgpu_acpi_priv.atcs; | |
1012 | struct pci_dev *pdev = NULL; | |
1013 | int ret; | |
1014 | ||
1015 | while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) { | |
1016 | if (!atif->handle) | |
1017 | amdgpu_atif_pci_probe_handle(pdev); | |
1018 | if (!atcs->handle) | |
1019 | amdgpu_atcs_pci_probe_handle(pdev); | |
1020 | } | |
1021 | ||
1022 | while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_OTHER << 8, pdev)) != NULL) { | |
1023 | if (!atif->handle) | |
1024 | amdgpu_atif_pci_probe_handle(pdev); | |
1025 | if (!atcs->handle) | |
1026 | amdgpu_atcs_pci_probe_handle(pdev); | |
1027 | } | |
d38ceaf9 AD |
1028 | |
1029 | if (atif->functions.sbios_requests && !atif->functions.system_params) { | |
1030 | /* XXX check this workraround, if sbios request function is | |
1031 | * present we have to see how it's configured in the system | |
1032 | * params | |
1033 | */ | |
1034 | atif->functions.system_params = true; | |
1035 | } | |
1036 | ||
1037 | if (atif->functions.system_params) { | |
280cf1a9 | 1038 | ret = amdgpu_atif_get_notification_params(atif); |
d38ceaf9 AD |
1039 | if (ret) { |
1040 | DRM_DEBUG_DRIVER("Call to GET_SYSTEM_PARAMS failed: %d\n", | |
1041 | ret); | |
1042 | /* Disable notification */ | |
1043 | atif->notification_cfg.enabled = false; | |
1044 | } | |
1045 | } | |
1046 | ||
206bbafe DF |
1047 | if (atif->functions.query_backlight_transfer_characteristics) { |
1048 | ret = amdgpu_atif_query_backlight_caps(atif); | |
1049 | if (ret) { | |
1050 | DRM_DEBUG_DRIVER("Call to QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS failed: %d\n", | |
1051 | ret); | |
1052 | atif->backlight_caps.caps_valid = false; | |
1053 | } | |
1054 | } else { | |
1055 | atif->backlight_caps.caps_valid = false; | |
1056 | } | |
d38ceaf9 | 1057 | } |
4cd078dc | 1058 | |
f588a1bb | 1059 | #if IS_ENABLED(CONFIG_SUSPEND) |
18b66ace ML |
1060 | /** |
1061 | * amdgpu_acpi_is_s3_active | |
1062 | * | |
1063 | * @adev: amdgpu_device_pointer | |
1064 | * | |
1065 | * returns true if supported, false if not. | |
1066 | */ | |
1067 | bool amdgpu_acpi_is_s3_active(struct amdgpu_device *adev) | |
1068 | { | |
1069 | return !(adev->flags & AMD_IS_APU) || | |
1070 | (pm_suspend_target_state == PM_SUSPEND_MEM); | |
1071 | } | |
1072 | ||
4cd078dc | 1073 | /** |
d0260f62 | 1074 | * amdgpu_acpi_is_s0ix_active |
4cd078dc | 1075 | * |
1fdbbc12 FDF |
1076 | * @adev: amdgpu_device_pointer |
1077 | * | |
4cd078dc PL |
1078 | * returns true if supported, false if not. |
1079 | */ | |
d0260f62 | 1080 | bool amdgpu_acpi_is_s0ix_active(struct amdgpu_device *adev) |
4cd078dc | 1081 | { |
f588a1bb ML |
1082 | if (!(adev->flags & AMD_IS_APU) || |
1083 | (pm_suspend_target_state != PM_SUSPEND_TO_IDLE)) | |
1084 | return false; | |
1085 | ||
ca475186 ML |
1086 | if (adev->asic_type < CHIP_RAVEN) |
1087 | return false; | |
1088 | ||
61ebd2fe RW |
1089 | /* |
1090 | * If ACPI_FADT_LOW_POWER_S0 is not set in the FADT, it is generally | |
1091 | * risky to do any special firmware-related preparations for entering | |
1092 | * S0ix even though the system is suspending to idle, so return false | |
1093 | * in that case. | |
1094 | */ | |
cf488dcd | 1095 | if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)) |
f588a1bb ML |
1096 | dev_warn_once(adev->dev, |
1097 | "Power consumption will be higher as BIOS has not been configured for suspend-to-idle.\n" | |
1098 | "To use suspend-to-idle change the sleep mode in BIOS setup.\n"); | |
f588a1bb ML |
1099 | |
1100 | #if !IS_ENABLED(CONFIG_AMD_PMC) | |
1101 | dev_warn_once(adev->dev, | |
1102 | "Power consumption will be higher as the kernel has not been compiled with CONFIG_AMD_PMC.\n"); | |
f588a1bb | 1103 | #endif /* CONFIG_AMD_PMC */ |
cf488dcd | 1104 | return true; |
4cd078dc | 1105 | } |
f588a1bb ML |
1106 | |
1107 | #endif /* CONFIG_SUSPEND */ |