drivers/gpu/drm/amd/amdgpu/amdgpu_acpi.c

   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 <acpi/video.h>
  29 #include <drm/drmP.h>
  30 #include <drm/drm_crtc_helper.h>
  31 #include "amdgpu.h"
  32 #include "amdgpu_acpi.h"
  33 #include "atom.h"
  34
  35 #define ACPI_AC_CLASS           "ac_adapter"
  36
  37 extern void amdgpu_pm_acpi_event_handler(struct amdgpu_device *adev);
  38
  39 struct atif_verify_interface {
  40         u16 size;               /* structure size in bytes (includes size field) */
  41         u16 version;            /* version */
  42         u32 notification_mask;  /* supported notifications mask */
  43         u32 function_bits;      /* supported functions bit vector */
  44 } __packed;
  45
  46 struct atif_system_params {
  47         u16 size;               /* structure size in bytes (includes size field) */
  48         u32 valid_mask;         /* valid flags mask */
  49         u32 flags;              /* flags */
  50         u8 command_code;        /* notify command code */
  51 } __packed;
  52
  53 struct atif_sbios_requests {
  54         u16 size;               /* structure size in bytes (includes size field) */
  55         u32 pending;            /* pending sbios requests */
  56         u8 panel_exp_mode;      /* panel expansion mode */
  57         u8 thermal_gfx;         /* thermal state: target gfx controller */
  58         u8 thermal_state;       /* thermal state: state id (0: exit state, non-0: state) */
  59         u8 forced_power_gfx;    /* forced power state: target gfx controller */
  60         u8 forced_power_state;  /* forced power state: state id */
  61         u8 system_power_src;    /* system power source */
  62         u8 backlight_level;     /* panel backlight level (0-255) */
  63 } __packed;
  64
  65 #define ATIF_NOTIFY_MASK        0x3
  66 #define ATIF_NOTIFY_NONE        0
  67 #define ATIF_NOTIFY_81          1
  68 #define ATIF_NOTIFY_N           2
  69
  70 struct atcs_verify_interface {
  71         u16 size;               /* structure size in bytes (includes size field) */
  72         u16 version;            /* version */
  73         u32 function_bits;      /* supported functions bit vector */
  74 } __packed;
  75
  76 #define ATCS_VALID_FLAGS_MASK   0x3
  77
  78 struct atcs_pref_req_input {
  79         u16 size;               /* structure size in bytes (includes size field) */
  80         u16 client_id;          /* client id (bit 2-0: func num, 7-3: dev num, 15-8: bus num) */
  81         u16 valid_flags_mask;   /* valid flags mask */
  82         u16 flags;              /* flags */
  83         u8 req_type;            /* request type */
  84         u8 perf_req;            /* performance request */
  85 } __packed;
  86
  87 struct atcs_pref_req_output {
  88         u16 size;               /* structure size in bytes (includes size field) */
  89         u8 ret_val;             /* return value */
  90 } __packed;
  91
  92 /* Call the ATIF method
  93  */
  94 /**
  95  * amdgpu_atif_call - call an ATIF method
  96  *
  97  * @handle: acpi handle
  98  * @function: the ATIF function to execute
  99  * @params: ATIF function params
 100  *
 101  * Executes the requested ATIF function (all asics).
 102  * Returns a pointer to the acpi output buffer.
 103  */
 104 static union acpi_object *amdgpu_atif_call(acpi_handle handle, int function,
 105                 struct acpi_buffer *params)
 106 {
 107         acpi_status status;
 108         union acpi_object atif_arg_elements[2];
 109         struct acpi_object_list atif_arg;
 110         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 111
 112         atif_arg.count = 2;
 113         atif_arg.pointer = &atif_arg_elements[0];
 114
 115         atif_arg_elements[0].type = ACPI_TYPE_INTEGER;
 116         atif_arg_elements[0].integer.value = function;
 117
 118         if (params) {
 119                 atif_arg_elements[1].type = ACPI_TYPE_BUFFER;
 120                 atif_arg_elements[1].buffer.length = params->length;
 121                 atif_arg_elements[1].buffer.pointer = params->pointer;
 122         } else {
 123                 /* We need a second fake parameter */
 124                 atif_arg_elements[1].type = ACPI_TYPE_INTEGER;
 125                 atif_arg_elements[1].integer.value = 0;
 126         }
 127
 128         status = acpi_evaluate_object(handle, "ATIF", &atif_arg, &buffer);
 129
 130         /* Fail only if calling the method fails and ATIF is supported */
 131         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 132                 DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n",
 133                                  acpi_format_exception(status));
 134                 kfree(buffer.pointer);
 135                 return NULL;
 136         }
 137
 138         return buffer.pointer;
 139 }
 140
 141 /**
 142  * amdgpu_atif_parse_notification - parse supported notifications
 143  *
 144  * @n: supported notifications struct
 145  * @mask: supported notifications mask from ATIF
 146  *
 147  * Use the supported notifications mask from ATIF function
 148  * ATIF_FUNCTION_VERIFY_INTERFACE to determine what notifications
 149  * are supported (all asics).
 150  */
 151 static void amdgpu_atif_parse_notification(struct amdgpu_atif_notifications *n, u32 mask)
 152 {
 153         n->display_switch = mask & ATIF_DISPLAY_SWITCH_REQUEST_SUPPORTED;
 154         n->expansion_mode_change = mask & ATIF_EXPANSION_MODE_CHANGE_REQUEST_SUPPORTED;
 155         n->thermal_state = mask & ATIF_THERMAL_STATE_CHANGE_REQUEST_SUPPORTED;
 156         n->forced_power_state = mask & ATIF_FORCED_POWER_STATE_CHANGE_REQUEST_SUPPORTED;
 157         n->system_power_state = mask & ATIF_SYSTEM_POWER_SOURCE_CHANGE_REQUEST_SUPPORTED;
 158         n->display_conf_change = mask & ATIF_DISPLAY_CONF_CHANGE_REQUEST_SUPPORTED;
 159         n->px_gfx_switch = mask & ATIF_PX_GFX_SWITCH_REQUEST_SUPPORTED;
 160         n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED;
 161         n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED;
 162 }
 163
 164 /**
 165  * amdgpu_atif_parse_functions - parse supported functions
 166  *
 167  * @f: supported functions struct
 168  * @mask: supported functions mask from ATIF
 169  *
 170  * Use the supported functions mask from ATIF function
 171  * ATIF_FUNCTION_VERIFY_INTERFACE to determine what functions
 172  * are supported (all asics).
 173  */
 174 static void amdgpu_atif_parse_functions(struct amdgpu_atif_functions *f, u32 mask)
 175 {
 176         f->system_params = mask & ATIF_GET_SYSTEM_PARAMETERS_SUPPORTED;
 177         f->sbios_requests = mask & ATIF_GET_SYSTEM_BIOS_REQUESTS_SUPPORTED;
 178         f->select_active_disp = mask & ATIF_SELECT_ACTIVE_DISPLAYS_SUPPORTED;
 179         f->lid_state = mask & ATIF_GET_LID_STATE_SUPPORTED;
 180         f->get_tv_standard = mask & ATIF_GET_TV_STANDARD_FROM_CMOS_SUPPORTED;
 181         f->set_tv_standard = mask & ATIF_SET_TV_STANDARD_IN_CMOS_SUPPORTED;
 182         f->get_panel_expansion_mode = mask & ATIF_GET_PANEL_EXPANSION_MODE_FROM_CMOS_SUPPORTED;
 183         f->set_panel_expansion_mode = mask & ATIF_SET_PANEL_EXPANSION_MODE_IN_CMOS_SUPPORTED;
 184         f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED;
 185         f->graphics_device_types = mask & ATIF_GET_GRAPHICS_DEVICE_TYPES_SUPPORTED;
 186 }
 187
 188 /**
 189  * amdgpu_atif_verify_interface - verify ATIF
 190  *
 191  * @handle: acpi handle
 192  * @atif: amdgpu atif struct
 193  *
 194  * Execute the ATIF_FUNCTION_VERIFY_INTERFACE ATIF function
 195  * to initialize ATIF and determine what features are supported
 196  * (all asics).
 197  * returns 0 on success, error on failure.
 198  */
 199 static int amdgpu_atif_verify_interface(acpi_handle handle,
 200                 struct amdgpu_atif *atif)
 201 {
 202         union acpi_object *info;
 203         struct atif_verify_interface output;
 204         size_t size;
 205         int err = 0;
 206
 207         info = amdgpu_atif_call(handle, ATIF_FUNCTION_VERIFY_INTERFACE, NULL);
 208         if (!info)
 209                 return -EIO;
 210
 211         memset(&output, 0, sizeof(output));
 212
 213         size = *(u16 *) info->buffer.pointer;
 214         if (size < 12) {
 215                 DRM_INFO("ATIF buffer is too small: %zu\n", size);
 216                 err = -EINVAL;
 217                 goto out;
 218         }
 219         size = min(sizeof(output), size);
 220
 221         memcpy(&output, info->buffer.pointer, size);
 222
 223         /* TODO: check version? */
 224         DRM_DEBUG_DRIVER("ATIF version %u\n", output.version);
 225
 226         amdgpu_atif_parse_notification(&atif->notifications, output.notification_mask);
 227         amdgpu_atif_parse_functions(&atif->functions, output.function_bits);
 228
 229 out:
 230         kfree(info);
 231         return err;
 232 }
 233
 234 /**
 235  * amdgpu_atif_get_notification_params - determine notify configuration
 236  *
 237  * @handle: acpi handle
 238  * @n: atif notification configuration struct
 239  *
 240  * Execute the ATIF_FUNCTION_GET_SYSTEM_PARAMETERS ATIF function
 241  * to determine if a notifier is used and if so which one
 242  * (all asics).  This is either Notify(VGA, 0x81) or Notify(VGA, n)
 243  * where n is specified in the result if a notifier is used.
 244  * Returns 0 on success, error on failure.
 245  */
 246 static int amdgpu_atif_get_notification_params(acpi_handle handle,
 247                 struct amdgpu_atif_notification_cfg *n)
 248 {
 249         union acpi_object *info;
 250         struct atif_system_params params;
 251         size_t size;
 252         int err = 0;
 253
 254         info = amdgpu_atif_call(handle, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS, NULL);
 255         if (!info) {
 256                 err = -EIO;
 257                 goto out;
 258         }
 259
 260         size = *(u16 *) info->buffer.pointer;
 261         if (size < 10) {
 262                 err = -EINVAL;
 263                 goto out;
 264         }
 265
 266         memset(&params, 0, sizeof(params));
 267         size = min(sizeof(params), size);
 268         memcpy(&params, info->buffer.pointer, size);
 269
 270         DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n",
 271                         params.flags, params.valid_mask);
 272         params.flags = params.flags & params.valid_mask;
 273
 274         if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_NONE) {
 275                 n->enabled = false;
 276                 n->command_code = 0;
 277         } else if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_81) {
 278                 n->enabled = true;
 279                 n->command_code = 0x81;
 280         } else {
 281                 if (size < 11) {
 282                         err = -EINVAL;
 283                         goto out;
 284                 }
 285                 n->enabled = true;
 286                 n->command_code = params.command_code;
 287         }
 288
 289 out:
 290         DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n",
 291                         (n->enabled ? "enabled" : "disabled"),
 292                         n->command_code);
 293         kfree(info);
 294         return err;
 295 }
 296
 297 /**
 298  * amdgpu_atif_get_sbios_requests - get requested sbios event
 299  *
 300  * @handle: acpi handle
 301  * @req: atif sbios request struct
 302  *
 303  * Execute the ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS ATIF function
 304  * to determine what requests the sbios is making to the driver
 305  * (all asics).
 306  * Returns 0 on success, error on failure.
 307  */
 308 static int amdgpu_atif_get_sbios_requests(acpi_handle handle,
 309                 struct atif_sbios_requests *req)
 310 {
 311         union acpi_object *info;
 312         size_t size;
 313         int count = 0;
 314
 315         info = amdgpu_atif_call(handle, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS, NULL);
 316         if (!info)
 317                 return -EIO;
 318
 319         size = *(u16 *)info->buffer.pointer;
 320         if (size < 0xd) {
 321                 count = -EINVAL;
 322                 goto out;
 323         }
 324         memset(req, 0, sizeof(*req));
 325
 326         size = min(sizeof(*req), size);
 327         memcpy(req, info->buffer.pointer, size);
 328         DRM_DEBUG_DRIVER("SBIOS pending requests: %#x\n", req->pending);
 329
 330         count = hweight32(req->pending);
 331
 332 out:
 333         kfree(info);
 334         return count;
 335 }
 336
 337 /**
 338  * amdgpu_atif_handler - handle ATIF notify requests
 339  *
 340  * @adev: amdgpu_device pointer
 341  * @event: atif sbios request struct
 342  *
 343  * Checks the acpi event and if it matches an atif event,
 344  * handles it.
 345  * Returns NOTIFY code
 346  */
 347 int amdgpu_atif_handler(struct amdgpu_device *adev,
 348                         struct acpi_bus_event *event)
 349 {
 350         struct amdgpu_atif *atif = &adev->atif;
 351         struct atif_sbios_requests req;
 352         acpi_handle handle;
 353         int count;
 354
 355         DRM_DEBUG_DRIVER("event, device_class = %s, type = %#x\n",
 356                         event->device_class, event->type);
 357
 358         if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
 359                 return NOTIFY_DONE;
 360
 361         if (!atif->notification_cfg.enabled ||
 362             event->type != atif->notification_cfg.command_code)
 363                 /* Not our event */
 364                 return NOTIFY_DONE;
 365
 366         /* Check pending SBIOS requests */
 367         handle = ACPI_HANDLE(&adev->pdev->dev);
 368         count = amdgpu_atif_get_sbios_requests(handle, &req);
 369
 370         if (count <= 0)
 371                 return NOTIFY_DONE;
 372
 373         DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count);
 374
 375         if (req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) {
 376                 struct amdgpu_encoder *enc = atif->encoder_for_bl;
 377
 378                 if (enc) {
 379                         struct amdgpu_encoder_atom_dig *dig = enc->enc_priv;
 380
 381                         DRM_DEBUG_DRIVER("Changing brightness to %d\n",
 382                                         req.backlight_level);
 383
 384                         amdgpu_display_backlight_set_level(adev, enc, req.backlight_level);
 385
 386 #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE)
 387                         backlight_force_update(dig->bl_dev,
 388                                                BACKLIGHT_UPDATE_HOTKEY);
 389 #endif
 390                 }
 391         }
 392         /* TODO: check other events */
 393
 394         /* We've handled the event, stop the notifier chain. The ACPI interface
 395          * overloads ACPI_VIDEO_NOTIFY_PROBE, we don't want to send that to
 396          * userspace if the event was generated only to signal a SBIOS
 397          * request.
 398          */
 399         return NOTIFY_BAD;
 400 }
 401
 402 /* Call the ATCS method
 403  */
 404 /**
 405  * amdgpu_atcs_call - call an ATCS method
 406  *
 407  * @handle: acpi handle
 408  * @function: the ATCS function to execute
 409  * @params: ATCS function params
 410  *
 411  * Executes the requested ATCS function (all asics).
 412  * Returns a pointer to the acpi output buffer.
 413  */
 414 static union acpi_object *amdgpu_atcs_call(acpi_handle handle, int function,
 415                                            struct acpi_buffer *params)
 416 {
 417         acpi_status status;
 418         union acpi_object atcs_arg_elements[2];
 419         struct acpi_object_list atcs_arg;
 420         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 421
 422         atcs_arg.count = 2;
 423         atcs_arg.pointer = &atcs_arg_elements[0];
 424
 425         atcs_arg_elements[0].type = ACPI_TYPE_INTEGER;
 426         atcs_arg_elements[0].integer.value = function;
 427
 428         if (params) {
 429                 atcs_arg_elements[1].type = ACPI_TYPE_BUFFER;
 430                 atcs_arg_elements[1].buffer.length = params->length;
 431                 atcs_arg_elements[1].buffer.pointer = params->pointer;
 432         } else {
 433                 /* We need a second fake parameter */
 434                 atcs_arg_elements[1].type = ACPI_TYPE_INTEGER;
 435                 atcs_arg_elements[1].integer.value = 0;
 436         }
 437
 438         status = acpi_evaluate_object(handle, "ATCS", &atcs_arg, &buffer);
 439
 440         /* Fail only if calling the method fails and ATIF is supported */
 441         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 442                 DRM_DEBUG_DRIVER("failed to evaluate ATCS got %s\n",
 443                                  acpi_format_exception(status));
 444                 kfree(buffer.pointer);
 445                 return NULL;
 446         }
 447
 448         return buffer.pointer;
 449 }
 450
 451 /**
 452  * amdgpu_atcs_parse_functions - parse supported functions
 453  *
 454  * @f: supported functions struct
 455  * @mask: supported functions mask from ATCS
 456  *
 457  * Use the supported functions mask from ATCS function
 458  * ATCS_FUNCTION_VERIFY_INTERFACE to determine what functions
 459  * are supported (all asics).
 460  */
 461 static void amdgpu_atcs_parse_functions(struct amdgpu_atcs_functions *f, u32 mask)
 462 {
 463         f->get_ext_state = mask & ATCS_GET_EXTERNAL_STATE_SUPPORTED;
 464         f->pcie_perf_req = mask & ATCS_PCIE_PERFORMANCE_REQUEST_SUPPORTED;
 465         f->pcie_dev_rdy = mask & ATCS_PCIE_DEVICE_READY_NOTIFICATION_SUPPORTED;
 466         f->pcie_bus_width = mask & ATCS_SET_PCIE_BUS_WIDTH_SUPPORTED;
 467 }
 468
 469 /**
 470  * amdgpu_atcs_verify_interface - verify ATCS
 471  *
 472  * @handle: acpi handle
 473  * @atcs: amdgpu atcs struct
 474  *
 475  * Execute the ATCS_FUNCTION_VERIFY_INTERFACE ATCS function
 476  * to initialize ATCS and determine what features are supported
 477  * (all asics).
 478  * returns 0 on success, error on failure.
 479  */
 480 static int amdgpu_atcs_verify_interface(acpi_handle handle,
 481                                         struct amdgpu_atcs *atcs)
 482 {
 483         union acpi_object *info;
 484         struct atcs_verify_interface output;
 485         size_t size;
 486         int err = 0;
 487
 488         info = amdgpu_atcs_call(handle, ATCS_FUNCTION_VERIFY_INTERFACE, NULL);
 489         if (!info)
 490                 return -EIO;
 491
 492         memset(&output, 0, sizeof(output));
 493
 494         size = *(u16 *) info->buffer.pointer;
 495         if (size < 8) {
 496                 DRM_INFO("ATCS buffer is too small: %zu\n", size);
 497                 err = -EINVAL;
 498                 goto out;
 499         }
 500         size = min(sizeof(output), size);
 501
 502         memcpy(&output, info->buffer.pointer, size);
 503
 504         /* TODO: check version? */
 505         DRM_DEBUG_DRIVER("ATCS version %u\n", output.version);
 506
 507         amdgpu_atcs_parse_functions(&atcs->functions, output.function_bits);
 508
 509 out:
 510         kfree(info);
 511         return err;
 512 }
 513
 514 /**
 515  * amdgpu_acpi_is_pcie_performance_request_supported
 516  *
 517  * @adev: amdgpu_device pointer
 518  *
 519  * Check if the ATCS pcie_perf_req and pcie_dev_rdy methods
 520  * are supported (all asics).
 521  * returns true if supported, false if not.
 522  */
 523 bool amdgpu_acpi_is_pcie_performance_request_supported(struct amdgpu_device *adev)
 524 {
 525         struct amdgpu_atcs *atcs = &adev->atcs;
 526
 527         if (atcs->functions.pcie_perf_req && atcs->functions.pcie_dev_rdy)
 528                 return true;
 529
 530         return false;
 531 }
 532
 533 /**
 534  * amdgpu_acpi_pcie_notify_device_ready
 535  *
 536  * @adev: amdgpu_device pointer
 537  *
 538  * Executes the PCIE_DEVICE_READY_NOTIFICATION method
 539  * (all asics).
 540  * returns 0 on success, error on failure.
 541  */
 542 int amdgpu_acpi_pcie_notify_device_ready(struct amdgpu_device *adev)
 543 {
 544         acpi_handle handle;
 545         union acpi_object *info;
 546         struct amdgpu_atcs *atcs = &adev->atcs;
 547
 548         /* Get the device handle */
 549         handle = ACPI_HANDLE(&adev->pdev->dev);
 550         if (!handle)
 551                 return -EINVAL;
 552
 553         if (!atcs->functions.pcie_dev_rdy)
 554                 return -EINVAL;
 555
 556         info = amdgpu_atcs_call(handle, ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION, NULL);
 557         if (!info)
 558                 return -EIO;
 559
 560         kfree(info);
 561
 562         return 0;
 563 }
 564
 565 /**
 566  * amdgpu_acpi_pcie_performance_request
 567  *
 568  * @adev: amdgpu_device pointer
 569  * @perf_req: requested perf level (pcie gen speed)
 570  * @advertise: set advertise caps flag if set
 571  *
 572  * Executes the PCIE_PERFORMANCE_REQUEST method to
 573  * change the pcie gen speed (all asics).
 574  * returns 0 on success, error on failure.
 575  */
 576 int amdgpu_acpi_pcie_performance_request(struct amdgpu_device *adev,
 577                                          u8 perf_req, bool advertise)
 578 {
 579         acpi_handle handle;
 580         union acpi_object *info;
 581         struct amdgpu_atcs *atcs = &adev->atcs;
 582         struct atcs_pref_req_input atcs_input;
 583         struct atcs_pref_req_output atcs_output;
 584         struct acpi_buffer params;
 585         size_t size;
 586         u32 retry = 3;
 587
 588         /* Get the device handle */
 589         handle = ACPI_HANDLE(&adev->pdev->dev);
 590         if (!handle)
 591                 return -EINVAL;
 592
 593         if (!atcs->functions.pcie_perf_req)
 594                 return -EINVAL;
 595
 596         atcs_input.size = sizeof(struct atcs_pref_req_input);
 597         /* client id (bit 2-0: func num, 7-3: dev num, 15-8: bus num) */
 598         atcs_input.client_id = adev->pdev->devfn | (adev->pdev->bus->number << 8);
 599         atcs_input.valid_flags_mask = ATCS_VALID_FLAGS_MASK;
 600         atcs_input.flags = ATCS_WAIT_FOR_COMPLETION;
 601         if (advertise)
 602                 atcs_input.flags |= ATCS_ADVERTISE_CAPS;
 603         atcs_input.req_type = ATCS_PCIE_LINK_SPEED;
 604         atcs_input.perf_req = perf_req;
 605
 606         params.length = sizeof(struct atcs_pref_req_input);
 607         params.pointer = &atcs_input;
 608
 609         while (retry--) {
 610                 info = amdgpu_atcs_call(handle, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST, &params);
 611                 if (!info)
 612                         return -EIO;
 613
 614                 memset(&atcs_output, 0, sizeof(atcs_output));
 615
 616                 size = *(u16 *) info->buffer.pointer;
 617                 if (size < 3) {
 618                         DRM_INFO("ATCS buffer is too small: %zu\n", size);
 619                         kfree(info);
 620                         return -EINVAL;
 621                 }
 622                 size = min(sizeof(atcs_output), size);
 623
 624                 memcpy(&atcs_output, info->buffer.pointer, size);
 625
 626                 kfree(info);
 627
 628                 switch (atcs_output.ret_val) {
 629                 case ATCS_REQUEST_REFUSED:
 630                 default:
 631                         return -EINVAL;
 632                 case ATCS_REQUEST_COMPLETE:
 633                         return 0;
 634                 case ATCS_REQUEST_IN_PROGRESS:
 635                         udelay(10);
 636                         break;
 637                 }
 638         }
 639
 640         return 0;
 641 }
 642
 643 /**
 644  * amdgpu_acpi_event - handle notify events
 645  *
 646  * @nb: notifier block
 647  * @val: val
 648  * @data: acpi event
 649  *
 650  * Calls relevant amdgpu functions in response to various
 651  * acpi events.
 652  * Returns NOTIFY code
 653  */
 654 static int amdgpu_acpi_event(struct notifier_block *nb,
 655                              unsigned long val,
 656                              void *data)
 657 {
 658         struct amdgpu_device *adev = container_of(nb, struct amdgpu_device, acpi_nb);
 659         struct acpi_bus_event *entry = (struct acpi_bus_event *)data;
 660
 661         if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) {
 662                 if (power_supply_is_system_supplied() > 0)
 663                         DRM_DEBUG_DRIVER("pm: AC\n");
 664                 else
 665                         DRM_DEBUG_DRIVER("pm: DC\n");
 666
 667                 amdgpu_pm_acpi_event_handler(adev);
 668         }
 669
 670         /* Check for pending SBIOS requests */
 671         return amdgpu_atif_handler(adev, entry);
 672 }
 673
 674 /* Call all ACPI methods here */
 675 /**
 676  * amdgpu_acpi_init - init driver acpi support
 677  *
 678  * @adev: amdgpu_device pointer
 679  *
 680  * Verifies the AMD ACPI interfaces and registers with the acpi
 681  * notifier chain (all asics).
 682  * Returns 0 on success, error on failure.
 683  */
 684 int amdgpu_acpi_init(struct amdgpu_device *adev)
 685 {
 686         acpi_handle handle;
 687         struct amdgpu_atif *atif = &adev->atif;
 688         struct amdgpu_atcs *atcs = &adev->atcs;
 689         int ret;
 690
 691         /* Get the device handle */
 692         handle = ACPI_HANDLE(&adev->pdev->dev);
 693
 694         if (!adev->bios || !handle)
 695                 return 0;
 696
 697         /* Call the ATCS method */
 698         ret = amdgpu_atcs_verify_interface(handle, atcs);
 699         if (ret) {
 700                 DRM_DEBUG_DRIVER("Call to ATCS verify_interface failed: %d\n", ret);
 701         }
 702
 703         /* Call the ATIF method */
 704         ret = amdgpu_atif_verify_interface(handle, atif);
 705         if (ret) {
 706                 DRM_DEBUG_DRIVER("Call to ATIF verify_interface failed: %d\n", ret);
 707                 goto out;
 708         }
 709
 710         if (atif->notifications.brightness_change) {
 711                 struct drm_encoder *tmp;
 712
 713                 /* Find the encoder controlling the brightness */
 714                 list_for_each_entry(tmp, &adev->ddev->mode_config.encoder_list,
 715                                 head) {
 716                         struct amdgpu_encoder *enc = to_amdgpu_encoder(tmp);
 717
 718                         if ((enc->devices & (ATOM_DEVICE_LCD_SUPPORT)) &&
 719                             enc->enc_priv) {
 720                                 if (adev->is_atom_bios) {
 721                                         struct amdgpu_encoder_atom_dig *dig = enc->enc_priv;
 722                                         if (dig->bl_dev) {
 723                                                 atif->encoder_for_bl = enc;
 724                                                 break;
 725                                         }
 726                                 }
 727                         }
 728                 }
 729         }
 730
 731         if (atif->functions.sbios_requests && !atif->functions.system_params) {
 732                 /* XXX check this workraround, if sbios request function is
 733                  * present we have to see how it's configured in the system
 734                  * params
 735                  */
 736                 atif->functions.system_params = true;
 737         }
 738
 739         if (atif->functions.system_params) {
 740                 ret = amdgpu_atif_get_notification_params(handle,
 741                                 &atif->notification_cfg);
 742                 if (ret) {
 743                         DRM_DEBUG_DRIVER("Call to GET_SYSTEM_PARAMS failed: %d\n",
 744                                         ret);
 745                         /* Disable notification */
 746                         atif->notification_cfg.enabled = false;
 747                 }
 748         }
 749
 750 out:
 751         adev->acpi_nb.notifier_call = amdgpu_acpi_event;
 752         register_acpi_notifier(&adev->acpi_nb);
 753
 754         return ret;
 755 }
 756
 757 /**
 758  * amdgpu_acpi_fini - tear down driver acpi support
 759  *
 760  * @adev: amdgpu_device pointer
 761  *
 762  * Unregisters with the acpi notifier chain (all asics).
 763  */
 764 void amdgpu_acpi_fini(struct amdgpu_device *adev)
 765 {
 766         unregister_acpi_notifier(&adev->acpi_nb);
 767 }