radeon_acpi.c revision 282199
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 <sys/cdefs.h> 25__FBSDID("$FreeBSD: stable/10/sys/dev/drm2/radeon/radeon_acpi.c 282199 2015-04-28 19:35:05Z dumbbell $"); 26 27#include <dev/drm2/drmP.h> 28#include <dev/drm2/drm_crtc_helper.h> 29#include "radeon.h" 30#include "radeon_acpi.h" 31#include "atom.h" 32 33#define ACPI_AC_CLASS "ac_adapter" 34 35extern void radeon_pm_acpi_event_handler(struct radeon_device *rdev); 36 37struct atif_verify_interface { 38 u16 size; /* structure size in bytes (includes size field) */ 39 u16 version; /* version */ 40 u32 notification_mask; /* supported notifications mask */ 41 u32 function_bits; /* supported functions bit vector */ 42} __packed; 43 44struct atif_system_params { 45 u16 size; /* structure size in bytes (includes size field) */ 46 u32 valid_mask; /* valid flags mask */ 47 u32 flags; /* flags */ 48 u8 command_code; /* notify command code */ 49} __packed; 50 51struct atif_sbios_requests { 52 u16 size; /* structure size in bytes (includes size field) */ 53 u32 pending; /* pending sbios requests */ 54 u8 panel_exp_mode; /* panel expansion mode */ 55 u8 thermal_gfx; /* thermal state: target gfx controller */ 56 u8 thermal_state; /* thermal state: state id (0: exit state, non-0: state) */ 57 u8 forced_power_gfx; /* forced power state: target gfx controller */ 58 u8 forced_power_state; /* forced power state: state id */ 59 u8 system_power_src; /* system power source */ 60 u8 backlight_level; /* panel backlight level (0-255) */ 61} __packed; 62 63#define ATIF_NOTIFY_MASK 0x3 64#define ATIF_NOTIFY_NONE 0 65#define ATIF_NOTIFY_81 1 66#define ATIF_NOTIFY_N 2 67 68struct atcs_verify_interface { 69 u16 size; /* structure size in bytes (includes size field) */ 70 u16 version; /* version */ 71 u32 function_bits; /* supported functions bit vector */ 72} __packed; 73 74/* Call the ATIF method 75 */ 76/** 77 * radeon_atif_call - call an ATIF method 78 * 79 * @handle: acpi handle 80 * @function: the ATIF function to execute 81 * @params: ATIF function params 82 * 83 * Executes the requested ATIF function (all asics). 84 * Returns a pointer to the acpi output buffer. 85 */ 86static ACPI_OBJECT *radeon_atif_call(ACPI_HANDLE handle, int function, 87 ACPI_BUFFER *params) 88{ 89 ACPI_STATUS status; 90 ACPI_OBJECT atif_arg_elements[2]; 91 ACPI_OBJECT_LIST atif_arg; 92 ACPI_BUFFER buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 93 94 atif_arg.Count = 2; 95 atif_arg.Pointer = &atif_arg_elements[0]; 96 97 atif_arg_elements[0].Type = ACPI_TYPE_INTEGER; 98 atif_arg_elements[0].Integer.Value = function; 99 100 if (params) { 101 atif_arg_elements[1].Type = ACPI_TYPE_BUFFER; 102 atif_arg_elements[1].Buffer.Length = params->Length; 103 atif_arg_elements[1].Buffer.Pointer = params->Pointer; 104 } else { 105 /* We need a second fake parameter */ 106 atif_arg_elements[1].Type = ACPI_TYPE_INTEGER; 107 atif_arg_elements[1].Integer.Value = 0; 108 } 109 110 status = AcpiEvaluateObject(handle, "ATIF", &atif_arg, &buffer); 111 112 /* Fail only if calling the method fails and ATIF is supported */ 113 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 114 DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n", 115 AcpiFormatException(status)); 116 AcpiOsFree(buffer.Pointer); 117 return NULL; 118 } 119 120 return buffer.Pointer; 121} 122 123/** 124 * radeon_atif_parse_notification - parse supported notifications 125 * 126 * @n: supported notifications struct 127 * @mask: supported notifications mask from ATIF 128 * 129 * Use the supported notifications mask from ATIF function 130 * ATIF_FUNCTION_VERIFY_INTERFACE to determine what notifications 131 * are supported (all asics). 132 */ 133static void radeon_atif_parse_notification(struct radeon_atif_notifications *n, u32 mask) 134{ 135 n->display_switch = mask & ATIF_DISPLAY_SWITCH_REQUEST_SUPPORTED; 136 n->expansion_mode_change = mask & ATIF_EXPANSION_MODE_CHANGE_REQUEST_SUPPORTED; 137 n->thermal_state = mask & ATIF_THERMAL_STATE_CHANGE_REQUEST_SUPPORTED; 138 n->forced_power_state = mask & ATIF_FORCED_POWER_STATE_CHANGE_REQUEST_SUPPORTED; 139 n->system_power_state = mask & ATIF_SYSTEM_POWER_SOURCE_CHANGE_REQUEST_SUPPORTED; 140 n->display_conf_change = mask & ATIF_DISPLAY_CONF_CHANGE_REQUEST_SUPPORTED; 141 n->px_gfx_switch = mask & ATIF_PX_GFX_SWITCH_REQUEST_SUPPORTED; 142 n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED; 143 n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED; 144} 145 146/** 147 * radeon_atif_parse_functions - parse supported functions 148 * 149 * @f: supported functions struct 150 * @mask: supported functions mask from ATIF 151 * 152 * Use the supported functions mask from ATIF function 153 * ATIF_FUNCTION_VERIFY_INTERFACE to determine what functions 154 * are supported (all asics). 155 */ 156static void radeon_atif_parse_functions(struct radeon_atif_functions *f, u32 mask) 157{ 158 f->system_params = mask & ATIF_GET_SYSTEM_PARAMETERS_SUPPORTED; 159 f->sbios_requests = mask & ATIF_GET_SYSTEM_BIOS_REQUESTS_SUPPORTED; 160 f->select_active_disp = mask & ATIF_SELECT_ACTIVE_DISPLAYS_SUPPORTED; 161 f->lid_state = mask & ATIF_GET_LID_STATE_SUPPORTED; 162 f->get_tv_standard = mask & ATIF_GET_TV_STANDARD_FROM_CMOS_SUPPORTED; 163 f->set_tv_standard = mask & ATIF_SET_TV_STANDARD_IN_CMOS_SUPPORTED; 164 f->get_panel_expansion_mode = mask & ATIF_GET_PANEL_EXPANSION_MODE_FROM_CMOS_SUPPORTED; 165 f->set_panel_expansion_mode = mask & ATIF_SET_PANEL_EXPANSION_MODE_IN_CMOS_SUPPORTED; 166 f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED; 167 f->graphics_device_types = mask & ATIF_GET_GRAPHICS_DEVICE_TYPES_SUPPORTED; 168} 169 170/** 171 * radeon_atif_verify_interface - verify ATIF 172 * 173 * @handle: acpi handle 174 * @atif: radeon atif struct 175 * 176 * Execute the ATIF_FUNCTION_VERIFY_INTERFACE ATIF function 177 * to initialize ATIF and determine what features are supported 178 * (all asics). 179 * returns 0 on success, error on failure. 180 */ 181static int radeon_atif_verify_interface(ACPI_HANDLE handle, 182 struct radeon_atif *atif) 183{ 184 ACPI_OBJECT *info; 185 struct atif_verify_interface output; 186 size_t size; 187 int err = 0; 188 189 info = radeon_atif_call(handle, ATIF_FUNCTION_VERIFY_INTERFACE, NULL); 190 if (!info) 191 return -EIO; 192 193 memset(&output, 0, sizeof(output)); 194 195 size = *(u16 *) info->Buffer.Pointer; 196 if (size < 12) { 197 DRM_INFO("ATIF buffer is too small: %zu\n", size); 198 err = -EINVAL; 199 goto out; 200 } 201 size = min(sizeof(output), size); 202 203 memcpy(&output, info->Buffer.Pointer, size); 204 205 /* TODO: check version? */ 206 DRM_DEBUG_DRIVER("ATIF version %u\n", output.version); 207 208 radeon_atif_parse_notification(&atif->notifications, output.notification_mask); 209 radeon_atif_parse_functions(&atif->functions, output.function_bits); 210 211out: 212 AcpiOsFree(info); 213 return err; 214} 215 216/** 217 * radeon_atif_get_notification_params - determine notify configuration 218 * 219 * @handle: acpi handle 220 * @n: atif notification configuration struct 221 * 222 * Execute the ATIF_FUNCTION_GET_SYSTEM_PARAMETERS ATIF function 223 * to determine if a notifier is used and if so which one 224 * (all asics). This is either Notify(VGA, 0x81) or Notify(VGA, n) 225 * where n is specified in the result if a notifier is used. 226 * Returns 0 on success, error on failure. 227 */ 228static int radeon_atif_get_notification_params(ACPI_HANDLE handle, 229 struct radeon_atif_notification_cfg *n) 230{ 231 ACPI_OBJECT *info; 232 struct atif_system_params params; 233 size_t size; 234 int err = 0; 235 236 info = radeon_atif_call(handle, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS, NULL); 237 if (!info) { 238 err = -EIO; 239 goto out; 240 } 241 242 size = *(u16 *) info->Buffer.Pointer; 243 if (size < 10) { 244 err = -EINVAL; 245 goto out; 246 } 247 248 memset(¶ms, 0, sizeof(params)); 249 size = min(sizeof(params), size); 250 memcpy(¶ms, info->Buffer.Pointer, size); 251 252 DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n", 253 params.flags, params.valid_mask); 254 params.flags = params.flags & params.valid_mask; 255 256 if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_NONE) { 257 n->enabled = false; 258 n->command_code = 0; 259 } else if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_81) { 260 n->enabled = true; 261 n->command_code = 0x81; 262 } else { 263 if (size < 11) { 264 err = -EINVAL; 265 goto out; 266 } 267 n->enabled = true; 268 n->command_code = params.command_code; 269 } 270 271out: 272 DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n", 273 (n->enabled ? "enabled" : "disabled"), 274 n->command_code); 275 AcpiOsFree(info); 276 return err; 277} 278 279/** 280 * radeon_atif_get_sbios_requests - get requested sbios event 281 * 282 * @handle: acpi handle 283 * @req: atif sbios request struct 284 * 285 * Execute the ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS ATIF function 286 * to determine what requests the sbios is making to the driver 287 * (all asics). 288 * Returns 0 on success, error on failure. 289 */ 290static int radeon_atif_get_sbios_requests(ACPI_HANDLE handle, 291 struct atif_sbios_requests *req) 292{ 293 ACPI_OBJECT *info; 294 size_t size; 295 int count = 0; 296 297 info = radeon_atif_call(handle, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS, NULL); 298 if (!info) 299 return -EIO; 300 301 size = *(u16 *)info->Buffer.Pointer; 302 if (size < 0xd) { 303 count = -EINVAL; 304 goto out; 305 } 306 memset(req, 0, sizeof(*req)); 307 308 size = min(sizeof(*req), size); 309 memcpy(req, info->Buffer.Pointer, size); 310 DRM_DEBUG_DRIVER("SBIOS pending requests: %#x\n", req->pending); 311 312 count = hweight32(req->pending); 313 314out: 315 AcpiOsFree(info); 316 return count; 317} 318 319/** 320 * radeon_atif_handler - handle ATIF notify requests 321 * 322 * @rdev: radeon_device pointer 323 * @event: atif sbios request struct 324 * 325 * Checks the acpi event and if it matches an atif event, 326 * handles it. 327 * Returns NOTIFY code 328 */ 329void radeon_atif_handler(struct radeon_device *rdev, 330 UINT32 type) 331{ 332 struct radeon_atif *atif = &rdev->atif; 333 struct atif_sbios_requests req; 334 ACPI_HANDLE handle; 335 int count; 336 337 DRM_DEBUG_DRIVER("event, type = %#x\n", 338 type); 339 340 if (!atif->notification_cfg.enabled || 341 type != atif->notification_cfg.command_code) 342 /* Not our event */ 343 return; 344 345 /* Check pending SBIOS requests */ 346 handle = rdev->acpi.handle; 347 count = radeon_atif_get_sbios_requests(handle, &req); 348 349 if (count <= 0) 350 return; 351 352 DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count); 353 354 if (req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) { 355 struct radeon_encoder *enc = atif->encoder_for_bl; 356 357 if (enc) { 358 DRM_DEBUG_DRIVER("Changing brightness to %d\n", 359 req.backlight_level); 360 361 radeon_set_backlight_level(rdev, enc, req.backlight_level); 362 363#ifdef FREEBSD_WIP 364 if (rdev->is_atom_bios) { 365 struct radeon_encoder_atom_dig *dig = enc->enc_priv; 366 backlight_force_update(dig->bl_dev, 367 BACKLIGHT_UPDATE_HOTKEY); 368 } else { 369 struct radeon_encoder_lvds *dig = enc->enc_priv; 370 backlight_force_update(dig->bl_dev, 371 BACKLIGHT_UPDATE_HOTKEY); 372 } 373#endif /* FREEBSD_WIP */ 374 } 375 } 376 /* TODO: check other events */ 377 378 /* We've handled the event, stop the notifier chain. The ACPI interface 379 * overloads ACPI_VIDEO_NOTIFY_PROBE, we don't want to send that to 380 * userspace if the event was generated only to signal a SBIOS 381 * request. 382 */ 383} 384 385/* Call the ATCS method 386 */ 387/** 388 * radeon_atcs_call - call an ATCS method 389 * 390 * @handle: acpi handle 391 * @function: the ATCS function to execute 392 * @params: ATCS function params 393 * 394 * Executes the requested ATCS function (all asics). 395 * Returns a pointer to the acpi output buffer. 396 */ 397static union acpi_object *radeon_atcs_call(ACPI_HANDLE handle, int function, 398 ACPI_BUFFER *params) 399{ 400 ACPI_STATUS status; 401 ACPI_OBJECT atcs_arg_elements[2]; 402 ACPI_OBJECT_LIST atcs_arg; 403 ACPI_BUFFER buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 404 405 atcs_arg.Count = 2; 406 atcs_arg.Pointer = &atcs_arg_elements[0]; 407 408 atcs_arg_elements[0].Type = ACPI_TYPE_INTEGER; 409 atcs_arg_elements[0].Integer.Value = function; 410 411 if (params) { 412 atcs_arg_elements[1].Type = ACPI_TYPE_BUFFER; 413 atcs_arg_elements[1].Buffer.Length = params->Length; 414 atcs_arg_elements[1].Buffer.Pointer = params->Pointer; 415 } else { 416 /* We need a second fake parameter */ 417 atcs_arg_elements[1].Type = ACPI_TYPE_INTEGER; 418 atcs_arg_elements[1].Integer.Value = 0; 419 } 420 421 status = AcpiEvaluateObject(handle, "ATCS", &atcs_arg, &buffer); 422 423 /* Fail only if calling the method fails and ATIF is supported */ 424 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 425 DRM_DEBUG_DRIVER("failed to evaluate ATCS got %s\n", 426 AcpiFormatException(status)); 427 AcpiOsFree(buffer.Pointer); 428 return NULL; 429 } 430 431 return buffer.Pointer; 432} 433 434/** 435 * radeon_atcs_parse_functions - parse supported functions 436 * 437 * @f: supported functions struct 438 * @mask: supported functions mask from ATCS 439 * 440 * Use the supported functions mask from ATCS function 441 * ATCS_FUNCTION_VERIFY_INTERFACE to determine what functions 442 * are supported (all asics). 443 */ 444static void radeon_atcs_parse_functions(struct radeon_atcs_functions *f, u32 mask) 445{ 446 f->get_ext_state = mask & ATCS_GET_EXTERNAL_STATE_SUPPORTED; 447 f->pcie_perf_req = mask & ATCS_PCIE_PERFORMANCE_REQUEST_SUPPORTED; 448 f->pcie_dev_rdy = mask & ATCS_PCIE_DEVICE_READY_NOTIFICATION_SUPPORTED; 449 f->pcie_bus_width = mask & ATCS_SET_PCIE_BUS_WIDTH_SUPPORTED; 450} 451 452/** 453 * radeon_atcs_verify_interface - verify ATCS 454 * 455 * @handle: acpi handle 456 * @atcs: radeon atcs struct 457 * 458 * Execute the ATCS_FUNCTION_VERIFY_INTERFACE ATCS function 459 * to initialize ATCS and determine what features are supported 460 * (all asics). 461 * returns 0 on success, error on failure. 462 */ 463static int radeon_atcs_verify_interface(ACPI_HANDLE handle, 464 struct radeon_atcs *atcs) 465{ 466 ACPI_OBJECT *info; 467 struct atcs_verify_interface output; 468 size_t size; 469 int err = 0; 470 471 info = radeon_atcs_call(handle, ATCS_FUNCTION_VERIFY_INTERFACE, NULL); 472 if (!info) 473 return -EIO; 474 475 memset(&output, 0, sizeof(output)); 476 477 size = *(u16 *) info->Buffer.Pointer; 478 if (size < 8) { 479 DRM_INFO("ATCS buffer is too small: %zu\n", size); 480 err = -EINVAL; 481 goto out; 482 } 483 size = min(sizeof(output), size); 484 485 memcpy(&output, info->Buffer.Pointer, size); 486 487 /* TODO: check version? */ 488 DRM_DEBUG_DRIVER("ATCS version %u\n", output.version); 489 490 radeon_atcs_parse_functions(&atcs->functions, output.function_bits); 491 492out: 493 AcpiOsFree(info); 494 return err; 495} 496 497/** 498 * radeon_acpi_event - handle notify events 499 * 500 * @nb: notifier block 501 * @val: val 502 * @data: acpi event 503 * 504 * Calls relevant radeon functions in response to various 505 * acpi events. 506 * Returns NOTIFY code 507 */ 508static void radeon_acpi_event(ACPI_HANDLE handle, UINT32 type, 509 void *context) 510{ 511 struct radeon_device *rdev = (struct radeon_device *)context; 512 513#ifdef FREEBSD_WIP 514 if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) { 515 if (power_supply_is_system_supplied() > 0) 516 DRM_DEBUG_DRIVER("pm: AC\n"); 517 else 518 DRM_DEBUG_DRIVER("pm: DC\n"); 519 520 radeon_pm_acpi_event_handler(rdev); 521 } 522#endif /* FREEBSD_WIP */ 523 524 /* Check for pending SBIOS requests */ 525 radeon_atif_handler(rdev, type); 526} 527 528/* Call all ACPI methods here */ 529/** 530 * radeon_acpi_init - init driver acpi support 531 * 532 * @rdev: radeon_device pointer 533 * 534 * Verifies the AMD ACPI interfaces and registers with the acpi 535 * notifier chain (all asics). 536 * Returns 0 on success, error on failure. 537 */ 538int radeon_acpi_init(struct radeon_device *rdev) 539{ 540 ACPI_HANDLE handle; 541 struct radeon_atif *atif = &rdev->atif; 542 struct radeon_atcs *atcs = &rdev->atcs; 543 int ret; 544 545 /* Get the device handle */ 546 handle = acpi_get_handle(rdev->dev); 547 548 /* No need to proceed if we're sure that ATIF is not supported */ 549 if (!ASIC_IS_AVIVO(rdev) || !rdev->bios || !handle) 550 return 0; 551 552 /* Call the ATCS method */ 553 ret = radeon_atcs_verify_interface(handle, atcs); 554 if (ret) { 555 DRM_DEBUG_DRIVER("Call to ATCS verify_interface failed: %d\n", ret); 556 } 557 558 /* Call the ATIF method */ 559 ret = radeon_atif_verify_interface(handle, atif); 560 if (ret) { 561 DRM_DEBUG_DRIVER("Call to ATIF verify_interface failed: %d\n", ret); 562 goto out; 563 } 564 565 if (atif->notifications.brightness_change) { 566 struct drm_encoder *tmp; 567 struct radeon_encoder *target = NULL; 568 569 /* Find the encoder controlling the brightness */ 570 list_for_each_entry(tmp, &rdev->ddev->mode_config.encoder_list, 571 head) { 572 struct radeon_encoder *enc = to_radeon_encoder(tmp); 573 574 if ((enc->devices & (ATOM_DEVICE_LCD_SUPPORT)) && 575 enc->enc_priv) { 576 if (rdev->is_atom_bios) { 577 struct radeon_encoder_atom_dig *dig = enc->enc_priv; 578 if (dig->bl_dev) { 579 target = enc; 580 break; 581 } 582 } else { 583 struct radeon_encoder_lvds *dig = enc->enc_priv; 584 if (dig->bl_dev) { 585 target = enc; 586 break; 587 } 588 } 589 } 590 } 591 592 atif->encoder_for_bl = target; 593 if (!target) { 594 /* Brightness change notification is enabled, but we 595 * didn't find a backlight controller, this should 596 * never happen. 597 */ 598 DRM_ERROR("Cannot find a backlight controller\n"); 599 } 600 } 601 602 if (atif->functions.sbios_requests && !atif->functions.system_params) { 603 /* XXX check this workraround, if sbios request function is 604 * present we have to see how it's configured in the system 605 * params 606 */ 607 atif->functions.system_params = true; 608 } 609 610 if (atif->functions.system_params) { 611 ret = radeon_atif_get_notification_params(handle, 612 &atif->notification_cfg); 613 if (ret) { 614 DRM_DEBUG_DRIVER("Call to GET_SYSTEM_PARAMS failed: %d\n", 615 ret); 616 /* Disable notification */ 617 atif->notification_cfg.enabled = false; 618 } 619 } 620 621out: 622 rdev->acpi.handle = handle; 623 rdev->acpi.notifier_call = radeon_acpi_event; 624 AcpiInstallNotifyHandler(handle, ACPI_DEVICE_NOTIFY, 625 rdev->acpi.notifier_call, rdev); 626 627 return ret; 628} 629 630/** 631 * radeon_acpi_fini - tear down driver acpi support 632 * 633 * @rdev: radeon_device pointer 634 * 635 * Unregisters with the acpi notifier chain (all asics). 636 */ 637void radeon_acpi_fini(struct radeon_device *rdev) 638{ 639 AcpiRemoveNotifyHandler(rdev->acpi.handle, ACPI_DEVICE_NOTIFY, 640 rdev->acpi.notifier_call); 641} 642