1 /* 2 * Copyright 2012 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 */ 23 24 #include <linux/pci.h> 25 #include <linux/acpi.h> 26 #include <linux/slab.h> 27 #include <linux/power_supply.h> 28 #include <linux/pm_runtime.h> 29 #include <acpi/video.h> 30 #include <drm/drmP.h> 31 #include <drm/drm_crtc_helper.h> 32 #include "amdgpu.h" 33 #include "amdgpu_pm.h" 34 #include "amdgpu_display.h" 35 #include "amd_acpi.h" 36 #include "atom.h" 37 38 struct amdgpu_atif_notification_cfg { 39 bool enabled; 40 int command_code; 41 }; 42 43 struct amdgpu_atif_notifications { 44 bool thermal_state; 45 bool forced_power_state; 46 bool system_power_state; 47 bool brightness_change; 48 bool dgpu_display_event; 49 bool gpu_package_power_limit; 50 }; 51 52 struct amdgpu_atif_functions { 53 bool system_params; 54 bool sbios_requests; 55 bool temperature_change; 56 bool query_backlight_transfer_characteristics; 57 bool ready_to_undock; 58 bool external_gpu_information; 59 }; 60 61 struct amdgpu_atif { 62 acpi_handle handle; 63 64 struct amdgpu_atif_notifications notifications; 65 struct amdgpu_atif_functions functions; 66 struct amdgpu_atif_notification_cfg notification_cfg; 67 struct amdgpu_encoder *encoder_for_bl; 68 struct amdgpu_dm_backlight_caps backlight_caps; 69 }; 70 71 /* Call the ATIF method 72 */ 73 /** 74 * amdgpu_atif_call - call an ATIF method 75 * 76 * @handle: acpi handle 77 * @function: the ATIF function to execute 78 * @params: ATIF function params 79 * 80 * Executes the requested ATIF function (all asics). 81 * Returns a pointer to the acpi output buffer. 82 */ 83 static union acpi_object *amdgpu_atif_call(struct amdgpu_atif *atif, 84 int function, 85 struct acpi_buffer *params) 86 { 87 acpi_status status; 88 union acpi_object atif_arg_elements[2]; 89 struct acpi_object_list atif_arg; 90 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 91 92 atif_arg.count = 2; 93 atif_arg.pointer = &atif_arg_elements[0]; 94 95 atif_arg_elements[0].type = ACPI_TYPE_INTEGER; 96 atif_arg_elements[0].integer.value = function; 97 98 if (params) { 99 atif_arg_elements[1].type = ACPI_TYPE_BUFFER; 100 atif_arg_elements[1].buffer.length = params->length; 101 atif_arg_elements[1].buffer.pointer = params->pointer; 102 } else { 103 /* We need a second fake parameter */ 104 atif_arg_elements[1].type = ACPI_TYPE_INTEGER; 105 atif_arg_elements[1].integer.value = 0; 106 } 107 108 status = acpi_evaluate_object(atif->handle, NULL, &atif_arg, 109 &buffer); 110 111 /* Fail only if calling the method fails and ATIF is supported */ 112 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 113 DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n", 114 acpi_format_exception(status)); 115 kfree(buffer.pointer); 116 return NULL; 117 } 118 119 return buffer.pointer; 120 } 121 122 /** 123 * amdgpu_atif_parse_notification - parse supported notifications 124 * 125 * @n: supported notifications struct 126 * @mask: supported notifications mask from ATIF 127 * 128 * Use the supported notifications mask from ATIF function 129 * ATIF_FUNCTION_VERIFY_INTERFACE to determine what notifications 130 * are supported (all asics). 131 */ 132 static void amdgpu_atif_parse_notification(struct amdgpu_atif_notifications *n, u32 mask) 133 { 134 n->thermal_state = mask & ATIF_THERMAL_STATE_CHANGE_REQUEST_SUPPORTED; 135 n->forced_power_state = mask & ATIF_FORCED_POWER_STATE_CHANGE_REQUEST_SUPPORTED; 136 n->system_power_state = mask & ATIF_SYSTEM_POWER_SOURCE_CHANGE_REQUEST_SUPPORTED; 137 n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED; 138 n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED; 139 n->gpu_package_power_limit = mask & ATIF_GPU_PACKAGE_POWER_LIMIT_REQUEST_SUPPORTED; 140 } 141 142 /** 143 * amdgpu_atif_parse_functions - parse supported functions 144 * 145 * @f: supported functions struct 146 * @mask: supported functions mask from ATIF 147 * 148 * Use the supported functions mask from ATIF function 149 * ATIF_FUNCTION_VERIFY_INTERFACE to determine what functions 150 * are supported (all asics). 151 */ 152 static void amdgpu_atif_parse_functions(struct amdgpu_atif_functions *f, u32 mask) 153 { 154 f->system_params = mask & ATIF_GET_SYSTEM_PARAMETERS_SUPPORTED; 155 f->sbios_requests = mask & ATIF_GET_SYSTEM_BIOS_REQUESTS_SUPPORTED; 156 f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED; 157 f->query_backlight_transfer_characteristics = 158 mask & ATIF_QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS_SUPPORTED; 159 f->ready_to_undock = mask & ATIF_READY_TO_UNDOCK_NOTIFICATION_SUPPORTED; 160 f->external_gpu_information = mask & ATIF_GET_EXTERNAL_GPU_INFORMATION_SUPPORTED; 161 } 162 163 /** 164 * amdgpu_atif_verify_interface - verify ATIF 165 * 166 * @handle: acpi handle 167 * @atif: amdgpu atif struct 168 * 169 * Execute the ATIF_FUNCTION_VERIFY_INTERFACE ATIF function 170 * to initialize ATIF and determine what features are supported 171 * (all asics). 172 * returns 0 on success, error on failure. 173 */ 174 static int amdgpu_atif_verify_interface(struct amdgpu_atif *atif) 175 { 176 union acpi_object *info; 177 struct atif_verify_interface output; 178 size_t size; 179 int err = 0; 180 181 info = amdgpu_atif_call(atif, ATIF_FUNCTION_VERIFY_INTERFACE, NULL); 182 if (!info) 183 return -EIO; 184 185 memset(&output, 0, sizeof(output)); 186 187 size = *(u16 *) info->buffer.pointer; 188 if (size < 12) { 189 DRM_INFO("ATIF buffer is too small: %zu\n", size); 190 err = -EINVAL; 191 goto out; 192 } 193 size = min(sizeof(output), size); 194 195 memcpy(&output, info->buffer.pointer, size); 196 197 /* TODO: check version? */ 198 DRM_DEBUG_DRIVER("ATIF version %u\n", output.version); 199 200 amdgpu_atif_parse_notification(&atif->notifications, output.notification_mask); 201 amdgpu_atif_parse_functions(&atif->functions, output.function_bits); 202 203 out: 204 kfree(info); 205 return err; 206 } 207 208 static acpi_handle amdgpu_atif_probe_handle(acpi_handle dhandle) 209 { 210 acpi_handle handle = NULL; 211 char acpi_method_name[255] = { 0 }; 212 struct acpi_buffer buffer = { sizeof(acpi_method_name), acpi_method_name }; 213 acpi_status status; 214 215 /* For PX/HG systems, ATIF and ATPX are in the iGPU's namespace, on dGPU only 216 * systems, ATIF is in the dGPU's namespace. 217 */ 218 status = acpi_get_handle(dhandle, "ATIF", &handle); 219 if (ACPI_SUCCESS(status)) 220 goto out; 221 222 if (amdgpu_has_atpx()) { 223 status = acpi_get_handle(amdgpu_atpx_get_dhandle(), "ATIF", 224 &handle); 225 if (ACPI_SUCCESS(status)) 226 goto out; 227 } 228 229 DRM_DEBUG_DRIVER("No ATIF handle found\n"); 230 return NULL; 231 out: 232 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 233 DRM_DEBUG_DRIVER("Found ATIF handle %s\n", acpi_method_name); 234 return handle; 235 } 236 237 /** 238 * amdgpu_atif_get_notification_params - determine notify configuration 239 * 240 * @handle: acpi handle 241 * @n: atif notification configuration struct 242 * 243 * Execute the ATIF_FUNCTION_GET_SYSTEM_PARAMETERS ATIF function 244 * to determine if a notifier is used and if so which one 245 * (all asics). This is either Notify(VGA, 0x81) or Notify(VGA, n) 246 * where n is specified in the result if a notifier is used. 247 * Returns 0 on success, error on failure. 248 */ 249 static int amdgpu_atif_get_notification_params(struct amdgpu_atif *atif) 250 { 251 union acpi_object *info; 252 struct amdgpu_atif_notification_cfg *n = &atif->notification_cfg; 253 struct atif_system_params params; 254 size_t size; 255 int err = 0; 256 257 info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS, 258 NULL); 259 if (!info) { 260 err = -EIO; 261 goto out; 262 } 263 264 size = *(u16 *) info->buffer.pointer; 265 if (size < 10) { 266 err = -EINVAL; 267 goto out; 268 } 269 270 memset(¶ms, 0, sizeof(params)); 271 size = min(sizeof(params), size); 272 memcpy(¶ms, info->buffer.pointer, size); 273 274 DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n", 275 params.flags, params.valid_mask); 276 params.flags = params.flags & params.valid_mask; 277 278 if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_NONE) { 279 n->enabled = false; 280 n->command_code = 0; 281 } else if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_81) { 282 n->enabled = true; 283 n->command_code = 0x81; 284 } else { 285 if (size < 11) { 286 err = -EINVAL; 287 goto out; 288 } 289 n->enabled = true; 290 n->command_code = params.command_code; 291 } 292 293 out: 294 DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n", 295 (n->enabled ? "enabled" : "disabled"), 296 n->command_code); 297 kfree(info); 298 return err; 299 } 300 301 /** 302 * amdgpu_atif_query_backlight_caps - get min and max backlight input signal 303 * 304 * @handle: acpi handle 305 * 306 * Execute the QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS ATIF function 307 * to determine the acceptable range of backlight values 308 * 309 * Backlight_caps.caps_valid will be set to true if the query is successful 310 * 311 * The input signals are in range 0-255 312 * 313 * This function assumes the display with backlight is the first LCD 314 * 315 * Returns 0 on success, error on failure. 316 */ 317 static int amdgpu_atif_query_backlight_caps(struct amdgpu_atif *atif) 318 { 319 union acpi_object *info; 320 struct atif_qbtc_output characteristics; 321 struct atif_qbtc_arguments arguments; 322 struct acpi_buffer params; 323 size_t size; 324 int err = 0; 325 326 arguments.size = sizeof(arguments); 327 arguments.requested_display = ATIF_QBTC_REQUEST_LCD1; 328 329 params.length = sizeof(arguments); 330 params.pointer = (void *)&arguments; 331 332 info = amdgpu_atif_call(atif, 333 ATIF_FUNCTION_QUERY_BRIGHTNESS_TRANSFER_CHARACTERISTICS, 334 ¶ms); 335 if (!info) { 336 err = -EIO; 337 goto out; 338 } 339 340 size = *(u16 *) info->buffer.pointer; 341 if (size < 10) { 342 err = -EINVAL; 343 goto out; 344 } 345 346 memset(&characteristics, 0, sizeof(characteristics)); 347 size = min(sizeof(characteristics), size); 348 memcpy(&characteristics, info->buffer.pointer, size); 349 350 atif->backlight_caps.caps_valid = true; 351 atif->backlight_caps.min_input_signal = 352 characteristics.min_input_signal; 353 atif->backlight_caps.max_input_signal = 354 characteristics.max_input_signal; 355 out: 356 kfree(info); 357 return err; 358 } 359 360 /** 361 * amdgpu_atif_get_sbios_requests - get requested sbios event 362 * 363 * @handle: acpi handle 364 * @req: atif sbios request struct 365 * 366 * Execute the ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS ATIF function 367 * to determine what requests the sbios is making to the driver 368 * (all asics). 369 * Returns 0 on success, error on failure. 370 */ 371 static int amdgpu_atif_get_sbios_requests(struct amdgpu_atif *atif, 372 struct atif_sbios_requests *req) 373 { 374 union acpi_object *info; 375 size_t size; 376 int count = 0; 377 378 info = amdgpu_atif_call(atif, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS, 379 NULL); 380 if (!info) 381 return -EIO; 382 383 size = *(u16 *)info->buffer.pointer; 384 if (size < 0xd) { 385 count = -EINVAL; 386 goto out; 387 } 388 memset(req, 0, sizeof(*req)); 389 390 size = min(sizeof(*req), size); 391 memcpy(req, info->buffer.pointer, size); 392 DRM_DEBUG_DRIVER("SBIOS pending requests: %#x\n", req->pending); 393 394 count = hweight32(req->pending); 395 396 out: 397 kfree(info); 398 return count; 399 } 400 401 /** 402 * amdgpu_atif_handler - handle ATIF notify requests 403 * 404 * @adev: amdgpu_device pointer 405 * @event: atif sbios request struct 406 * 407 * Checks the acpi event and if it matches an atif event, 408 * handles it. 409 * 410 * Returns: 411 * NOTIFY_BAD or NOTIFY_DONE, depending on the event. 412 */ 413 static int amdgpu_atif_handler(struct amdgpu_device *adev, 414 struct acpi_bus_event *event) 415 { 416 struct amdgpu_atif *atif = adev->atif; 417 int count; 418 419 DRM_DEBUG_DRIVER("event, device_class = %s, type = %#x\n", 420 event->device_class, event->type); 421 422 if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0) 423 return NOTIFY_DONE; 424 425 /* Is this actually our event? */ 426 if (!atif || 427 !atif->notification_cfg.enabled || 428 event->type != atif->notification_cfg.command_code) { 429 /* These events will generate keypresses otherwise */ 430 if (event->type == ACPI_VIDEO_NOTIFY_PROBE) 431 return NOTIFY_BAD; 432 else 433 return NOTIFY_DONE; 434 } 435 436 if (atif->functions.sbios_requests) { 437 struct atif_sbios_requests req; 438 439 /* Check pending SBIOS requests */ 440 count = amdgpu_atif_get_sbios_requests(atif, &req); 441 442 if (count <= 0) 443 return NOTIFY_BAD; 444 445 DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count); 446 447 /* todo: add DC handling */ 448 if ((req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) && 449 !amdgpu_device_has_dc_support(adev)) { 450 struct amdgpu_encoder *enc = atif->encoder_for_bl; 451 452 if (enc) { 453 struct amdgpu_encoder_atom_dig *dig = enc->enc_priv; 454 455 DRM_DEBUG_DRIVER("Changing brightness to %d\n", 456 req.backlight_level); 457 458 amdgpu_display_backlight_set_level(adev, enc, req.backlight_level); 459 460 #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE) 461 backlight_force_update(dig->bl_dev, 462 BACKLIGHT_UPDATE_HOTKEY); 463 #endif 464 } 465 } 466 if (req.pending & ATIF_DGPU_DISPLAY_EVENT) { 467 if ((adev->flags & AMD_IS_PX) && 468 amdgpu_atpx_dgpu_req_power_for_displays()) { 469 pm_runtime_get_sync(adev->ddev->dev); 470 /* Just fire off a uevent and let userspace tell us what to do */ 471 drm_helper_hpd_irq_event(adev->ddev); 472 pm_runtime_mark_last_busy(adev->ddev->dev); 473 pm_runtime_put_autosuspend(adev->ddev->dev); 474 } 475 } 476 /* TODO: check other events */ 477 } 478 479 /* We've handled the event, stop the notifier chain. The ACPI interface 480 * overloads ACPI_VIDEO_NOTIFY_PROBE, we don't want to send that to 481 * userspace if the event was generated only to signal a SBIOS 482 * request. 483 */ 484 return NOTIFY_BAD; 485 } 486 487 /* Call the ATCS method 488 */ 489 /** 490 * amdgpu_atcs_call - call an ATCS method 491 * 492 * @handle: acpi handle 493 * @function: the ATCS function to execute 494 * @params: ATCS function params 495 * 496 * Executes the requested ATCS function (all asics). 497 * Returns a pointer to the acpi output buffer. 498 */ 499 static union acpi_object *amdgpu_atcs_call(acpi_handle handle, int function, 500 struct acpi_buffer *params) 501 { 502 acpi_status status; 503 union acpi_object atcs_arg_elements[2]; 504 struct acpi_object_list atcs_arg; 505 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 506 507 atcs_arg.count = 2; 508 atcs_arg.pointer = &atcs_arg_elements[0]; 509 510 atcs_arg_elements[0].type = ACPI_TYPE_INTEGER; 511 atcs_arg_elements[0].integer.value = function; 512 513 if (params) { 514 atcs_arg_elements[1].type = ACPI_TYPE_BUFFER; 515 atcs_arg_elements[1].buffer.length = params->length; 516 atcs_arg_elements[1].buffer.pointer = params->pointer; 517 } else { 518 /* We need a second fake parameter */ 519 atcs_arg_elements[1].type = ACPI_TYPE_INTEGER; 520 atcs_arg_elements[1].integer.value = 0; 521 } 522 523 status = acpi_evaluate_object(handle, "ATCS", &atcs_arg, &buffer); 524 525 /* Fail only if calling the method fails and ATIF is supported */ 526 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 527 DRM_DEBUG_DRIVER("failed to evaluate ATCS got %s\n", 528 acpi_format_exception(status)); 529 kfree(buffer.pointer); 530 return NULL; 531 } 532 533 return buffer.pointer; 534 } 535 536 /** 537 * amdgpu_atcs_parse_functions - parse supported functions 538 * 539 * @f: supported functions struct 540 * @mask: supported functions mask from ATCS 541 * 542 * Use the supported functions mask from ATCS function 543 * ATCS_FUNCTION_VERIFY_INTERFACE to determine what functions 544 * are supported (all asics). 545 */ 546 static void amdgpu_atcs_parse_functions(struct amdgpu_atcs_functions *f, u32 mask) 547 { 548 f->get_ext_state = mask & ATCS_GET_EXTERNAL_STATE_SUPPORTED; 549 f->pcie_perf_req = mask & ATCS_PCIE_PERFORMANCE_REQUEST_SUPPORTED; 550 f->pcie_dev_rdy = mask & ATCS_PCIE_DEVICE_READY_NOTIFICATION_SUPPORTED; 551 f->pcie_bus_width = mask & ATCS_SET_PCIE_BUS_WIDTH_SUPPORTED; 552 } 553 554 /** 555 * amdgpu_atcs_verify_interface - verify ATCS 556 * 557 * @handle: acpi handle 558 * @atcs: amdgpu atcs struct 559 * 560 * Execute the ATCS_FUNCTION_VERIFY_INTERFACE ATCS function 561 * to initialize ATCS and determine what features are supported 562 * (all asics). 563 * returns 0 on success, error on failure. 564 */ 565 static int amdgpu_atcs_verify_interface(acpi_handle handle, 566 struct amdgpu_atcs *atcs) 567 { 568 union acpi_object *info; 569 struct atcs_verify_interface output; 570 size_t size; 571 int err = 0; 572 573 info = amdgpu_atcs_call(handle, ATCS_FUNCTION_VERIFY_INTERFACE, NULL); 574 if (!info) 575 return -EIO; 576 577 memset(&output, 0, sizeof(output)); 578 579 size = *(u16 *) info->buffer.pointer; 580 if (size < 8) { 581 DRM_INFO("ATCS buffer is too small: %zu\n", size); 582 err = -EINVAL; 583 goto out; 584 } 585 size = min(sizeof(output), size); 586 587 memcpy(&output, info->buffer.pointer, size); 588 589 /* TODO: check version? */ 590 DRM_DEBUG_DRIVER("ATCS version %u\n", output.version); 591 592 amdgpu_atcs_parse_functions(&atcs->functions, output.function_bits); 593 594 out: 595 kfree(info); 596 return err; 597 } 598 599 /** 600 * amdgpu_acpi_is_pcie_performance_request_supported 601 * 602 * @adev: amdgpu_device pointer 603 * 604 * Check if the ATCS pcie_perf_req and pcie_dev_rdy methods 605 * are supported (all asics). 606 * returns true if supported, false if not. 607 */ 608 bool amdgpu_acpi_is_pcie_performance_request_supported(struct amdgpu_device *adev) 609 { 610 struct amdgpu_atcs *atcs = &adev->atcs; 611 612 if (atcs->functions.pcie_perf_req && atcs->functions.pcie_dev_rdy) 613 return true; 614 615 return false; 616 } 617 618 /** 619 * amdgpu_acpi_pcie_notify_device_ready 620 * 621 * @adev: amdgpu_device pointer 622 * 623 * Executes the PCIE_DEVICE_READY_NOTIFICATION method 624 * (all asics). 625 * returns 0 on success, error on failure. 626 */ 627 int amdgpu_acpi_pcie_notify_device_ready(struct amdgpu_device *adev) 628 { 629 acpi_handle handle; 630 union acpi_object *info; 631 struct amdgpu_atcs *atcs = &adev->atcs; 632 633 /* Get the device handle */ 634 handle = ACPI_HANDLE(&adev->pdev->dev); 635 if (!handle) 636 return -EINVAL; 637 638 if (!atcs->functions.pcie_dev_rdy) 639 return -EINVAL; 640 641 info = amdgpu_atcs_call(handle, ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION, NULL); 642 if (!info) 643 return -EIO; 644 645 kfree(info); 646 647 return 0; 648 } 649 650 /** 651 * amdgpu_acpi_pcie_performance_request 652 * 653 * @adev: amdgpu_device pointer 654 * @perf_req: requested perf level (pcie gen speed) 655 * @advertise: set advertise caps flag if set 656 * 657 * Executes the PCIE_PERFORMANCE_REQUEST method to 658 * change the pcie gen speed (all asics). 659 * returns 0 on success, error on failure. 660 */ 661 int amdgpu_acpi_pcie_performance_request(struct amdgpu_device *adev, 662 u8 perf_req, bool advertise) 663 { 664 acpi_handle handle; 665 union acpi_object *info; 666 struct amdgpu_atcs *atcs = &adev->atcs; 667 struct atcs_pref_req_input atcs_input; 668 struct atcs_pref_req_output atcs_output; 669 struct acpi_buffer params; 670 size_t size; 671 u32 retry = 3; 672 673 if (amdgpu_acpi_pcie_notify_device_ready(adev)) 674 return -EINVAL; 675 676 /* Get the device handle */ 677 handle = ACPI_HANDLE(&adev->pdev->dev); 678 if (!handle) 679 return -EINVAL; 680 681 if (!atcs->functions.pcie_perf_req) 682 return -EINVAL; 683 684 atcs_input.size = sizeof(struct atcs_pref_req_input); 685 /* client id (bit 2-0: func num, 7-3: dev num, 15-8: bus num) */ 686 atcs_input.client_id = adev->pdev->devfn | (adev->pdev->bus->number << 8); 687 atcs_input.valid_flags_mask = ATCS_VALID_FLAGS_MASK; 688 atcs_input.flags = ATCS_WAIT_FOR_COMPLETION; 689 if (advertise) 690 atcs_input.flags |= ATCS_ADVERTISE_CAPS; 691 atcs_input.req_type = ATCS_PCIE_LINK_SPEED; 692 atcs_input.perf_req = perf_req; 693 694 params.length = sizeof(struct atcs_pref_req_input); 695 params.pointer = &atcs_input; 696 697 while (retry--) { 698 info = amdgpu_atcs_call(handle, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST, ¶ms); 699 if (!info) 700 return -EIO; 701 702 memset(&atcs_output, 0, sizeof(atcs_output)); 703 704 size = *(u16 *) info->buffer.pointer; 705 if (size < 3) { 706 DRM_INFO("ATCS buffer is too small: %zu\n", size); 707 kfree(info); 708 return -EINVAL; 709 } 710 size = min(sizeof(atcs_output), size); 711 712 memcpy(&atcs_output, info->buffer.pointer, size); 713 714 kfree(info); 715 716 switch (atcs_output.ret_val) { 717 case ATCS_REQUEST_REFUSED: 718 default: 719 return -EINVAL; 720 case ATCS_REQUEST_COMPLETE: 721 return 0; 722 case ATCS_REQUEST_IN_PROGRESS: 723 udelay(10); 724 break; 725 } 726 } 727 728 return 0; 729 } 730 731 /** 732 * amdgpu_acpi_event - handle notify events 733 * 734 * @nb: notifier block 735 * @val: val 736 * @data: acpi event 737 * 738 * Calls relevant amdgpu functions in response to various 739 * acpi events. 740 * Returns NOTIFY code 741 */ 742 static int amdgpu_acpi_event(struct notifier_block *nb, 743 unsigned long val, 744 void *data) 745 { 746 struct amdgpu_device *adev = container_of(nb, struct amdgpu_device, acpi_nb); 747 struct acpi_bus_event *entry = (struct acpi_bus_event *)data; 748 749 if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) { 750 if (power_supply_is_system_supplied() > 0) 751 DRM_DEBUG_DRIVER("pm: AC\n"); 752 else 753 DRM_DEBUG_DRIVER("pm: DC\n"); 754 755 amdgpu_pm_acpi_event_handler(adev); 756 } 757 758 /* Check for pending SBIOS requests */ 759 return amdgpu_atif_handler(adev, entry); 760 } 761 762 /* Call all ACPI methods here */ 763 /** 764 * amdgpu_acpi_init - init driver acpi support 765 * 766 * @adev: amdgpu_device pointer 767 * 768 * Verifies the AMD ACPI interfaces and registers with the acpi 769 * notifier chain (all asics). 770 * Returns 0 on success, error on failure. 771 */ 772 int amdgpu_acpi_init(struct amdgpu_device *adev) 773 { 774 acpi_handle handle, atif_handle; 775 struct amdgpu_atif *atif; 776 struct amdgpu_atcs *atcs = &adev->atcs; 777 int ret; 778 779 /* Get the device handle */ 780 handle = ACPI_HANDLE(&adev->pdev->dev); 781 782 if (!adev->bios || !handle) 783 return 0; 784 785 /* Call the ATCS method */ 786 ret = amdgpu_atcs_verify_interface(handle, atcs); 787 if (ret) { 788 DRM_DEBUG_DRIVER("Call to ATCS verify_interface failed: %d\n", ret); 789 } 790 791 /* Probe for ATIF, and initialize it if found */ 792 atif_handle = amdgpu_atif_probe_handle(handle); 793 if (!atif_handle) 794 goto out; 795 796 atif = kzalloc(sizeof(*atif), GFP_KERNEL); 797 if (!atif) { 798 DRM_WARN("Not enough memory to initialize ATIF\n"); 799 goto out; 800 } 801 atif->handle = atif_handle; 802 803 /* Call the ATIF method */ 804 ret = amdgpu_atif_verify_interface(atif); 805 if (ret) { 806 DRM_DEBUG_DRIVER("Call to ATIF verify_interface failed: %d\n", ret); 807 kfree(atif); 808 goto out; 809 } 810 adev->atif = atif; 811 812 if (atif->notifications.brightness_change) { 813 struct drm_encoder *tmp; 814 815 /* Find the encoder controlling the brightness */ 816 list_for_each_entry(tmp, &adev->ddev->mode_config.encoder_list, 817 head) { 818 struct amdgpu_encoder *enc = to_amdgpu_encoder(tmp); 819 820 if ((enc->devices & (ATOM_DEVICE_LCD_SUPPORT)) && 821 enc->enc_priv) { 822 struct amdgpu_encoder_atom_dig *dig = enc->enc_priv; 823 if (dig->bl_dev) { 824 atif->encoder_for_bl = enc; 825 break; 826 } 827 } 828 } 829 } 830 831 if (atif->functions.sbios_requests && !atif->functions.system_params) { 832 /* XXX check this workraround, if sbios request function is 833 * present we have to see how it's configured in the system 834 * params 835 */ 836 atif->functions.system_params = true; 837 } 838 839 if (atif->functions.system_params) { 840 ret = amdgpu_atif_get_notification_params(atif); 841 if (ret) { 842 DRM_DEBUG_DRIVER("Call to GET_SYSTEM_PARAMS failed: %d\n", 843 ret); 844 /* Disable notification */ 845 atif->notification_cfg.enabled = false; 846 } 847 } 848 849 if (atif->functions.query_backlight_transfer_characteristics) { 850 ret = amdgpu_atif_query_backlight_caps(atif); 851 if (ret) { 852 DRM_DEBUG_DRIVER("Call to QUERY_BACKLIGHT_TRANSFER_CHARACTERISTICS failed: %d\n", 853 ret); 854 atif->backlight_caps.caps_valid = false; 855 } 856 } else { 857 atif->backlight_caps.caps_valid = false; 858 } 859 860 out: 861 adev->acpi_nb.notifier_call = amdgpu_acpi_event; 862 register_acpi_notifier(&adev->acpi_nb); 863 864 return ret; 865 } 866 867 void amdgpu_acpi_get_backlight_caps(struct amdgpu_device *adev, 868 struct amdgpu_dm_backlight_caps *caps) 869 { 870 if (!adev->atif) { 871 caps->caps_valid = false; 872 return; 873 } 874 caps->caps_valid = adev->atif->backlight_caps.caps_valid; 875 caps->min_input_signal = adev->atif->backlight_caps.min_input_signal; 876 caps->max_input_signal = adev->atif->backlight_caps.max_input_signal; 877 } 878 879 /** 880 * amdgpu_acpi_fini - tear down driver acpi support 881 * 882 * @adev: amdgpu_device pointer 883 * 884 * Unregisters with the acpi notifier chain (all asics). 885 */ 886 void amdgpu_acpi_fini(struct amdgpu_device *adev) 887 { 888 unregister_acpi_notifier(&adev->acpi_nb); 889 kfree(adev->atif); 890 } 891