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