Rev 3764 | Rev 5271 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 3764 | Rev 5078 | ||
---|---|---|---|
Line 63... | Line 63... | ||
63 | return rdev->pm.default_power_state_index; |
63 | return rdev->pm.default_power_state_index; |
64 | } |
64 | } |
Line 65... | Line 65... | ||
65 | 65 | ||
66 | void radeon_pm_acpi_event_handler(struct radeon_device *rdev) |
66 | void radeon_pm_acpi_event_handler(struct radeon_device *rdev) |
- | 67 | { |
|
- | 68 | if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) { |
|
- | 69 | mutex_lock(&rdev->pm.mutex); |
|
- | 70 | if (power_supply_is_system_supplied() > 0) |
|
- | 71 | rdev->pm.dpm.ac_power = true; |
|
- | 72 | else |
|
- | 73 | rdev->pm.dpm.ac_power = false; |
|
- | 74 | if (rdev->family == CHIP_ARUBA) { |
|
- | 75 | if (rdev->asic->dpm.enable_bapm) |
|
- | 76 | radeon_dpm_enable_bapm(rdev, rdev->pm.dpm.ac_power); |
|
- | 77 | } |
|
67 | { |
78 | mutex_unlock(&rdev->pm.mutex); |
68 | if (rdev->pm.pm_method == PM_METHOD_PROFILE) { |
79 | } else if (rdev->pm.pm_method == PM_METHOD_PROFILE) { |
69 | if (rdev->pm.profile == PM_PROFILE_AUTO) { |
80 | if (rdev->pm.profile == PM_PROFILE_AUTO) { |
70 | mutex_lock(&rdev->pm.mutex); |
81 | mutex_lock(&rdev->pm.mutex); |
71 | radeon_pm_update_profile(rdev); |
82 | radeon_pm_update_profile(rdev); |
72 | radeon_pm_set_clocks(rdev); |
83 | radeon_pm_set_clocks(rdev); |
Line 132... | Line 143... | ||
132 | struct radeon_bo *bo, *n; |
143 | struct radeon_bo *bo, *n; |
Line 133... | Line 144... | ||
133 | 144 | ||
134 | if (list_empty(&rdev->gem.objects)) |
145 | if (list_empty(&rdev->gem.objects)) |
Line -... | Line 146... | ||
- | 146 | return; |
|
- | 147 | ||
- | 148 | list_for_each_entry_safe(bo, n, &rdev->gem.objects, list) { |
|
- | 149 | if (bo->tbo.mem.mem_type == TTM_PL_VRAM) |
|
135 | return; |
150 | ttm_bo_unmap_virtual(&bo->tbo); |
Line 136... | Line 151... | ||
136 | 151 | } |
|
137 | } |
152 | } |
138 | 153 | ||
Line 243... | Line 258... | ||
243 | for (i = 0; i < RADEON_NUM_RINGS; i++) { |
258 | for (i = 0; i < RADEON_NUM_RINGS; i++) { |
244 | struct radeon_ring *ring = &rdev->ring[i]; |
259 | struct radeon_ring *ring = &rdev->ring[i]; |
245 | if (!ring->ready) { |
260 | if (!ring->ready) { |
246 | continue; |
261 | continue; |
247 | } |
262 | } |
248 | r = radeon_fence_wait_empty_locked(rdev, i); |
263 | r = radeon_fence_wait_empty(rdev, i); |
249 | if (r) { |
264 | if (r) { |
250 | /* needs a GPU reset dont reset here */ |
265 | /* needs a GPU reset dont reset here */ |
251 | mutex_unlock(&rdev->ring_lock); |
266 | mutex_unlock(&rdev->ring_lock); |
252 | // up_write(&rdev->pm.mclk_lock); |
267 | // up_write(&rdev->pm.mclk_lock); |
253 | mutex_unlock(&rdev->ddev->struct_mutex); |
268 | mutex_unlock(&rdev->ddev->struct_mutex); |
Line 325... | Line 340... | ||
325 | 340 | ||
326 | static ssize_t radeon_get_pm_profile(struct device *dev, |
341 | static ssize_t radeon_get_pm_profile(struct device *dev, |
327 | struct device_attribute *attr, |
342 | struct device_attribute *attr, |
328 | char *buf) |
343 | char *buf) |
329 | { |
344 | { |
330 | struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev)); |
345 | struct drm_device *ddev = dev_get_drvdata(dev); |
331 | struct radeon_device *rdev = ddev->dev_private; |
346 | struct radeon_device *rdev = ddev->dev_private; |
Line 332... | Line 347... | ||
332 | int cp = rdev->pm.profile; |
347 | int cp = rdev->pm.profile; |
333 | 348 | ||
Line 341... | Line 356... | ||
341 | static ssize_t radeon_set_pm_profile(struct device *dev, |
356 | static ssize_t radeon_set_pm_profile(struct device *dev, |
342 | struct device_attribute *attr, |
357 | struct device_attribute *attr, |
343 | const char *buf, |
358 | const char *buf, |
344 | size_t count) |
359 | size_t count) |
345 | { |
360 | { |
346 | struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev)); |
361 | struct drm_device *ddev = dev_get_drvdata(dev); |
347 | struct radeon_device *rdev = ddev->dev_private; |
362 | struct radeon_device *rdev = ddev->dev_private; |
Line -... | Line 363... | ||
- | 363 | ||
- | 364 | /* Can't set profile when the card is off */ |
|
- | 365 | if ((rdev->flags & RADEON_IS_PX) && |
|
- | 366 | (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) |
|
- | 367 | return -EINVAL; |
|
348 | 368 | ||
349 | mutex_lock(&rdev->pm.mutex); |
369 | mutex_lock(&rdev->pm.mutex); |
350 | if (rdev->pm.pm_method == PM_METHOD_PROFILE) { |
370 | if (rdev->pm.pm_method == PM_METHOD_PROFILE) { |
351 | if (strncmp("default", buf, strlen("default")) == 0) |
371 | if (strncmp("default", buf, strlen("default")) == 0) |
352 | rdev->pm.profile = PM_PROFILE_DEFAULT; |
372 | rdev->pm.profile = PM_PROFILE_DEFAULT; |
Line 375... | Line 395... | ||
375 | 395 | ||
376 | static ssize_t radeon_get_pm_method(struct device *dev, |
396 | static ssize_t radeon_get_pm_method(struct device *dev, |
377 | struct device_attribute *attr, |
397 | struct device_attribute *attr, |
378 | char *buf) |
398 | char *buf) |
379 | { |
399 | { |
380 | struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev)); |
400 | struct drm_device *ddev = dev_get_drvdata(dev); |
381 | struct radeon_device *rdev = ddev->dev_private; |
401 | struct radeon_device *rdev = ddev->dev_private; |
Line 382... | Line 402... | ||
382 | int pm = rdev->pm.pm_method; |
402 | int pm = rdev->pm.pm_method; |
383 | 403 | ||
- | 404 | return snprintf(buf, PAGE_SIZE, "%s\n", |
|
384 | return snprintf(buf, PAGE_SIZE, "%s\n", |
405 | (pm == PM_METHOD_DYNPM) ? "dynpm" : |
Line 385... | Line 406... | ||
385 | (pm == PM_METHOD_DYNPM) ? "dynpm" : "profile"); |
406 | (pm == PM_METHOD_PROFILE) ? "profile" : "dpm"); |
386 | } |
407 | } |
387 | 408 | ||
388 | static ssize_t radeon_set_pm_method(struct device *dev, |
409 | static ssize_t radeon_set_pm_method(struct device *dev, |
389 | struct device_attribute *attr, |
410 | struct device_attribute *attr, |
390 | const char *buf, |
411 | const char *buf, |
391 | size_t count) |
412 | size_t count) |
Line -... | Line 413... | ||
- | 413 | { |
|
- | 414 | struct drm_device *ddev = dev_get_drvdata(dev); |
|
- | 415 | struct radeon_device *rdev = ddev->dev_private; |
|
- | 416 | ||
- | 417 | /* Can't set method when the card is off */ |
|
- | 418 | if ((rdev->flags & RADEON_IS_PX) && |
|
- | 419 | (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) { |
|
- | 420 | count = -EINVAL; |
|
- | 421 | goto fail; |
|
- | 422 | } |
|
- | 423 | ||
- | 424 | /* we don't support the legacy modes with dpm */ |
|
Line 392... | Line 425... | ||
392 | { |
425 | if (rdev->pm.pm_method == PM_METHOD_DPM) { |
393 | struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev)); |
426 | count = -EINVAL; |
394 | struct radeon_device *rdev = ddev->dev_private; |
427 | goto fail; |
395 | 428 | } |
|
Line 415... | Line 448... | ||
415 | radeon_pm_compute_clocks(rdev); |
448 | radeon_pm_compute_clocks(rdev); |
416 | fail: |
449 | fail: |
417 | return count; |
450 | return count; |
418 | } |
451 | } |
Line 419... | Line 452... | ||
419 | 452 | ||
- | 453 | static ssize_t radeon_get_dpm_state(struct device *dev, |
|
- | 454 | struct device_attribute *attr, |
|
- | 455 | char *buf) |
|
- | 456 | { |
|
- | 457 | struct drm_device *ddev = dev_get_drvdata(dev); |
|
420 | //static DEVICE_ATTR(power_profile, S_IRUGO | S_IWUSR, radeon_get_pm_profile, radeon_set_pm_profile); |
458 | struct radeon_device *rdev = ddev->dev_private; |
Line -... | Line 459... | ||
- | 459 | enum radeon_pm_state_type pm = rdev->pm.dpm.user_state; |
|
- | 460 | ||
- | 461 | return snprintf(buf, PAGE_SIZE, "%s\n", |
|
- | 462 | (pm == POWER_STATE_TYPE_BATTERY) ? "battery" : |
|
- | 463 | (pm == POWER_STATE_TYPE_BALANCED) ? "balanced" : "performance"); |
|
421 | //static DEVICE_ATTR(power_method, S_IRUGO | S_IWUSR, radeon_get_pm_method, radeon_set_pm_method); |
464 | } |
- | 465 | ||
- | 466 | static ssize_t radeon_set_dpm_state(struct device *dev, |
|
- | 467 | struct device_attribute *attr, |
|
- | 468 | const char *buf, |
|
- | 469 | size_t count) |
|
- | 470 | { |
|
- | 471 | struct drm_device *ddev = dev_get_drvdata(dev); |
|
- | 472 | struct radeon_device *rdev = ddev->dev_private; |
|
- | 473 | ||
- | 474 | mutex_lock(&rdev->pm.mutex); |
|
- | 475 | if (strncmp("battery", buf, strlen("battery")) == 0) |
|
- | 476 | rdev->pm.dpm.user_state = POWER_STATE_TYPE_BATTERY; |
|
- | 477 | else if (strncmp("balanced", buf, strlen("balanced")) == 0) |
|
- | 478 | rdev->pm.dpm.user_state = POWER_STATE_TYPE_BALANCED; |
|
- | 479 | else if (strncmp("performance", buf, strlen("performance")) == 0) |
|
- | 480 | rdev->pm.dpm.user_state = POWER_STATE_TYPE_PERFORMANCE; |
|
- | 481 | else { |
|
- | 482 | mutex_unlock(&rdev->pm.mutex); |
|
- | 483 | count = -EINVAL; |
|
- | 484 | goto fail; |
|
- | 485 | } |
|
- | 486 | mutex_unlock(&rdev->pm.mutex); |
|
- | 487 | ||
- | 488 | /* Can't set dpm state when the card is off */ |
|
- | 489 | if (!(rdev->flags & RADEON_IS_PX) || |
|
- | 490 | (ddev->switch_power_state == DRM_SWITCH_POWER_ON)) |
|
- | 491 | radeon_pm_compute_clocks(rdev); |
|
- | 492 | ||
- | 493 | fail: |
|
- | 494 | return count; |
|
- | 495 | } |
|
422 | 496 | ||
423 | static ssize_t radeon_hwmon_show_temp(struct device *dev, |
497 | static ssize_t radeon_get_dpm_forced_performance_level(struct device *dev, |
424 | struct device_attribute *attr, |
498 | struct device_attribute *attr, |
425 | char *buf) |
499 | char *buf) |
- | 500 | { |
|
- | 501 | struct drm_device *ddev = dev_get_drvdata(dev); |
|
- | 502 | struct radeon_device *rdev = ddev->dev_private; |
|
- | 503 | enum radeon_dpm_forced_level level = rdev->pm.dpm.forced_level; |
|
- | 504 | ||
- | 505 | if ((rdev->flags & RADEON_IS_PX) && |
|
- | 506 | (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) |
|
- | 507 | return snprintf(buf, PAGE_SIZE, "off\n"); |
|
- | 508 | ||
- | 509 | return snprintf(buf, PAGE_SIZE, "%s\n", |
|
- | 510 | (level == RADEON_DPM_FORCED_LEVEL_AUTO) ? "auto" : |
|
- | 511 | (level == RADEON_DPM_FORCED_LEVEL_LOW) ? "low" : "high"); |
|
- | 512 | } |
|
- | 513 | ||
- | 514 | static ssize_t radeon_set_dpm_forced_performance_level(struct device *dev, |
|
- | 515 | struct device_attribute *attr, |
|
- | 516 | const char *buf, |
|
- | 517 | size_t count) |
|
426 | { |
518 | { |
- | 519 | struct drm_device *ddev = dev_get_drvdata(dev); |
|
- | 520 | struct radeon_device *rdev = ddev->dev_private; |
|
- | 521 | enum radeon_dpm_forced_level level; |
|
- | 522 | int ret = 0; |
|
- | 523 | ||
- | 524 | /* Can't force performance level when the card is off */ |
|
- | 525 | if ((rdev->flags & RADEON_IS_PX) && |
|
- | 526 | (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) |
|
- | 527 | return -EINVAL; |
|
- | 528 | ||
- | 529 | mutex_lock(&rdev->pm.mutex); |
|
- | 530 | if (strncmp("low", buf, strlen("low")) == 0) { |
|
- | 531 | level = RADEON_DPM_FORCED_LEVEL_LOW; |
|
- | 532 | } else if (strncmp("high", buf, strlen("high")) == 0) { |
|
- | 533 | level = RADEON_DPM_FORCED_LEVEL_HIGH; |
|
- | 534 | } else if (strncmp("auto", buf, strlen("auto")) == 0) { |
|
- | 535 | level = RADEON_DPM_FORCED_LEVEL_AUTO; |
|
- | 536 | } else { |
|
- | 537 | count = -EINVAL; |
|
- | 538 | goto fail; |
|
- | 539 | } |
|
- | 540 | if (rdev->asic->dpm.force_performance_level) { |
|
- | 541 | if (rdev->pm.dpm.thermal_active) { |
|
- | 542 | count = -EINVAL; |
|
- | 543 | goto fail; |
|
- | 544 | } |
|
- | 545 | ret = radeon_dpm_force_performance_level(rdev, level); |
|
- | 546 | if (ret) |
|
- | 547 | count = -EINVAL; |
|
- | 548 | } |
|
- | 549 | fail: |
|
- | 550 | mutex_unlock(&rdev->pm.mutex); |
|
- | 551 | ||
- | 552 | return count; |
|
- | 553 | } |
|
- | 554 | ||
- | 555 | ||
- | 556 | static ssize_t radeon_hwmon_show_temp(struct device *dev, |
|
- | 557 | struct device_attribute *attr, |
|
- | 558 | char *buf) |
|
- | 559 | { |
|
- | 560 | struct radeon_device *rdev = dev_get_drvdata(dev); |
|
- | 561 | struct drm_device *ddev = rdev->ddev; |
|
- | 562 | int temp; |
|
- | 563 | ||
- | 564 | /* Can't get temperature when the card is off */ |
|
- | 565 | if ((rdev->flags & RADEON_IS_PX) && |
|
- | 566 | (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) |
|
- | 567 | return -EINVAL; |
|
- | 568 | ||
- | 569 | if (rdev->asic->pm.get_temperature) |
|
- | 570 | temp = radeon_get_temperature(rdev); |
|
- | 571 | else |
|
- | 572 | temp = 0; |
|
- | 573 | ||
- | 574 | return snprintf(buf, PAGE_SIZE, "%d\n", temp); |
|
- | 575 | } |
|
- | 576 | ||
- | 577 | static ssize_t radeon_hwmon_show_temp_thresh(struct device *dev, |
|
- | 578 | struct device_attribute *attr, |
|
- | 579 | char *buf) |
|
- | 580 | { |
|
427 | struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev)); |
581 | struct radeon_device *rdev = dev_get_drvdata(dev); |
Line -... | Line 582... | ||
- | 582 | // int hyst = to_sensor_dev_attr(attr)->index; |
|
- | 583 | int temp; |
|
- | 584 | ||
- | 585 | // if (hyst) |
|
- | 586 | // temp = rdev->pm.dpm.thermal.min_temp; |
|
- | 587 | // else |
|
- | 588 | temp = rdev->pm.dpm.thermal.max_temp; |
|
- | 589 | ||
- | 590 | return snprintf(buf, PAGE_SIZE, "%d\n", temp); |
|
- | 591 | } |
|
- | 592 | ||
- | 593 | ||
- | 594 | static struct attribute *hwmon_attributes[] = { |
|
- | 595 | // &sensor_dev_attr_temp1_input.dev_attr.attr, |
|
- | 596 | // &sensor_dev_attr_temp1_crit.dev_attr.attr, |
|
- | 597 | // &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, |
|
- | 598 | NULL |
|
- | 599 | }; |
|
- | 600 | ||
- | 601 | ||
- | 602 | ||
- | 603 | static int radeon_hwmon_init(struct radeon_device *rdev) |
|
428 | struct radeon_device *rdev = ddev->dev_private; |
604 | { |
429 | int temp; |
605 | int err = 0; |
430 | - | ||
431 | switch (rdev->pm.int_thermal_type) { |
- | |
432 | case THERMAL_TYPE_RV6XX: |
606 | |
433 | temp = rv6xx_get_temp(rdev); |
- | |
434 | break; |
- | |
435 | case THERMAL_TYPE_RV770: |
607 | switch (rdev->pm.int_thermal_type) { |
436 | temp = rv770_get_temp(rdev); |
608 | case THERMAL_TYPE_RV6XX: |
437 | break; |
- | |
438 | case THERMAL_TYPE_EVERGREEN: |
- | |
439 | case THERMAL_TYPE_NI: |
609 | case THERMAL_TYPE_RV770: |
440 | temp = evergreen_get_temp(rdev); |
- | |
441 | break; |
- | |
442 | case THERMAL_TYPE_SUMO: |
610 | case THERMAL_TYPE_EVERGREEN: |
- | 611 | case THERMAL_TYPE_NI: |
|
- | 612 | case THERMAL_TYPE_SUMO: |
|
443 | temp = sumo_get_temp(rdev); |
613 | case THERMAL_TYPE_SI: |
- | 614 | case THERMAL_TYPE_CI: |
|
- | 615 | case THERMAL_TYPE_KV: |
|
444 | break; |
616 | if (rdev->asic->pm.get_temperature == NULL) |
445 | case THERMAL_TYPE_SI: |
617 | return err; |
446 | temp = si_get_temp(rdev); |
- | |
447 | break; |
618 | |
448 | default: |
619 | break; |
Line 449... | Line 620... | ||
449 | temp = 0; |
620 | default: |
450 | break; |
621 | break; |
Line 451... | Line 622... | ||
451 | } |
622 | } |
452 | - | ||
453 | return snprintf(buf, PAGE_SIZE, "%d\n", temp); |
- | |
454 | } |
623 | |
455 | 624 | return err; |
|
- | 625 | } |
|
456 | static ssize_t radeon_hwmon_show_name(struct device *dev, |
626 | |
Line 457... | Line 627... | ||
457 | struct device_attribute *attr, |
627 | static void radeon_hwmon_fini(struct radeon_device *rdev) |
458 | char *buf) |
628 | { |
- | 629 | // if (rdev->pm.int_hwmon_dev) |
|
- | 630 | // hwmon_device_unregister(rdev->pm.int_hwmon_dev); |
|
- | 631 | } |
|
459 | { |
632 | |
- | 633 | static void radeon_dpm_thermal_work_handler(struct work_struct *work) |
|
Line 460... | Line 634... | ||
460 | return sprintf(buf, "radeon\n"); |
634 | { |
- | 635 | struct radeon_device *rdev = |
|
Line -... | Line 636... | ||
- | 636 | container_of(work, struct radeon_device, |
|
- | 637 | pm.dpm.thermal.work); |
|
- | 638 | /* switch to the thermal state */ |
|
- | 639 | enum radeon_pm_state_type dpm_state = POWER_STATE_TYPE_INTERNAL_THERMAL; |
|
- | 640 | ||
- | 641 | if (!rdev->pm.dpm_enabled) |
|
461 | } |
642 | return; |
- | 643 | ||
- | 644 | if (rdev->asic->pm.get_temperature) { |
|
- | 645 | int temp = radeon_get_temperature(rdev); |
|
462 | 646 | ||
- | 647 | if (temp < rdev->pm.dpm.thermal.min_temp) |
|
- | 648 | /* switch back the user state */ |
|
- | 649 | dpm_state = rdev->pm.dpm.user_state; |
|
- | 650 | } else { |
|
- | 651 | if (rdev->pm.dpm.thermal.high_to_low) |
|
- | 652 | /* switch back the user state */ |
|
- | 653 | dpm_state = rdev->pm.dpm.user_state; |
|
Line -... | Line 654... | ||
- | 654 | } |
|
- | 655 | mutex_lock(&rdev->pm.mutex); |
|
- | 656 | if (dpm_state == POWER_STATE_TYPE_INTERNAL_THERMAL) |
|
463 | static int radeon_hwmon_init(struct radeon_device *rdev) |
657 | rdev->pm.dpm.thermal_active = true; |
- | 658 | else |
|
464 | { |
659 | rdev->pm.dpm.thermal_active = false; |
- | 660 | rdev->pm.dpm.state = dpm_state; |
|
- | 661 | mutex_unlock(&rdev->pm.mutex); |
|
- | 662 | ||
- | 663 | radeon_pm_compute_clocks(rdev); |
|
- | 664 | } |
|
- | 665 | ||
- | 666 | static struct radeon_ps *radeon_dpm_pick_power_state(struct radeon_device *rdev, |
|
- | 667 | enum radeon_pm_state_type dpm_state) |
|
- | 668 | { |
|
- | 669 | int i; |
|
465 | int err = 0; |
670 | struct radeon_ps *ps; |
Line -... | Line 671... | ||
- | 671 | u32 ui_class; |
|
- | 672 | bool single_display = (rdev->pm.dpm.new_active_crtc_count < 2) ? |
|
- | 673 | true : false; |
|
- | 674 | ||
- | 675 | /* check if the vblank period is too short to adjust the mclk */ |
|
- | 676 | if (single_display && rdev->asic->dpm.vblank_too_short) { |
|
- | 677 | if (radeon_dpm_vblank_too_short(rdev)) |
|
- | 678 | single_display = false; |
|
- | 679 | } |
|
- | 680 | ||
- | 681 | /* certain older asics have a separare 3D performance state, |
|
- | 682 | * so try that first if the user selected performance |
|
- | 683 | */ |
|
- | 684 | if (dpm_state == POWER_STATE_TYPE_PERFORMANCE) |
|
- | 685 | dpm_state = POWER_STATE_TYPE_INTERNAL_3DPERF; |
|
- | 686 | /* balanced states don't exist at the moment */ |
|
- | 687 | if (dpm_state == POWER_STATE_TYPE_BALANCED) |
|
- | 688 | dpm_state = POWER_STATE_TYPE_PERFORMANCE; |
|
- | 689 | ||
- | 690 | restart_search: |
|
- | 691 | /* Pick the best power state based on current conditions */ |
|
- | 692 | for (i = 0; i < rdev->pm.dpm.num_ps; i++) { |
|
- | 693 | ps = &rdev->pm.dpm.ps[i]; |
|
- | 694 | ui_class = ps->class & ATOM_PPLIB_CLASSIFICATION_UI_MASK; |
|
- | 695 | switch (dpm_state) { |
|
- | 696 | /* user states */ |
|
- | 697 | case POWER_STATE_TYPE_BATTERY: |
|
- | 698 | if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_BATTERY) { |
|
- | 699 | if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) { |
|
- | 700 | if (single_display) |
|
- | 701 | return ps; |
|
- | 702 | } else |
|
- | 703 | return ps; |
|
- | 704 | } |
|
- | 705 | break; |
|
- | 706 | case POWER_STATE_TYPE_BALANCED: |
|
- | 707 | if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_BALANCED) { |
|
- | 708 | if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) { |
|
- | 709 | if (single_display) |
|
- | 710 | return ps; |
|
- | 711 | } else |
|
- | 712 | return ps; |
|
- | 713 | } |
|
- | 714 | break; |
|
- | 715 | case POWER_STATE_TYPE_PERFORMANCE: |
|
- | 716 | if (ui_class == ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE) { |
|
- | 717 | if (ps->caps & ATOM_PPLIB_SINGLE_DISPLAY_ONLY) { |
|
- | 718 | if (single_display) |
|
- | 719 | return ps; |
|
- | 720 | } else |
|
- | 721 | return ps; |
|
- | 722 | } |
|
- | 723 | break; |
|
- | 724 | /* internal states */ |
|
- | 725 | case POWER_STATE_TYPE_INTERNAL_UVD: |
|
- | 726 | if (rdev->pm.dpm.uvd_ps) |
|
- | 727 | return rdev->pm.dpm.uvd_ps; |
|
- | 728 | else |
|
- | 729 | break; |
|
- | 730 | case POWER_STATE_TYPE_INTERNAL_UVD_SD: |
|
- | 731 | if (ps->class & ATOM_PPLIB_CLASSIFICATION_SDSTATE) |
|
- | 732 | return ps; |
|
- | 733 | break; |
|
- | 734 | case POWER_STATE_TYPE_INTERNAL_UVD_HD: |
|
- | 735 | if (ps->class & ATOM_PPLIB_CLASSIFICATION_HDSTATE) |
|
- | 736 | return ps; |
|
- | 737 | break; |
|
- | 738 | case POWER_STATE_TYPE_INTERNAL_UVD_HD2: |
|
- | 739 | if (ps->class & ATOM_PPLIB_CLASSIFICATION_HD2STATE) |
|
- | 740 | return ps; |
|
- | 741 | break; |
|
- | 742 | case POWER_STATE_TYPE_INTERNAL_UVD_MVC: |
|
- | 743 | if (ps->class2 & ATOM_PPLIB_CLASSIFICATION2_MVC) |
|
- | 744 | return ps; |
|
- | 745 | break; |
|
- | 746 | case POWER_STATE_TYPE_INTERNAL_BOOT: |
|
- | 747 | return rdev->pm.dpm.boot_ps; |
|
- | 748 | case POWER_STATE_TYPE_INTERNAL_THERMAL: |
|
- | 749 | if (ps->class & ATOM_PPLIB_CLASSIFICATION_THERMAL) |
|
- | 750 | return ps; |
|
- | 751 | break; |
|
- | 752 | case POWER_STATE_TYPE_INTERNAL_ACPI: |
|
- | 753 | if (ps->class & ATOM_PPLIB_CLASSIFICATION_ACPI) |
|
- | 754 | return ps; |
|
- | 755 | break; |
|
- | 756 | case POWER_STATE_TYPE_INTERNAL_ULV: |
|
- | 757 | if (ps->class2 & ATOM_PPLIB_CLASSIFICATION2_ULV) |
|
- | 758 | return ps; |
|
- | 759 | break; |
|
- | 760 | case POWER_STATE_TYPE_INTERNAL_3DPERF: |
|
- | 761 | if (ps->class & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE) |
|
- | 762 | return ps; |
|
- | 763 | break; |
|
- | 764 | default: |
|
- | 765 | break; |
|
- | 766 | } |
|
- | 767 | } |
|
- | 768 | /* use a fallback state if we didn't match */ |
|
- | 769 | switch (dpm_state) { |
|
- | 770 | case POWER_STATE_TYPE_INTERNAL_UVD_SD: |
|
- | 771 | dpm_state = POWER_STATE_TYPE_INTERNAL_UVD_HD; |
|
- | 772 | goto restart_search; |
|
- | 773 | case POWER_STATE_TYPE_INTERNAL_UVD_HD: |
|
- | 774 | case POWER_STATE_TYPE_INTERNAL_UVD_HD2: |
|
- | 775 | case POWER_STATE_TYPE_INTERNAL_UVD_MVC: |
|
- | 776 | if (rdev->pm.dpm.uvd_ps) { |
|
- | 777 | return rdev->pm.dpm.uvd_ps; |
|
- | 778 | } else { |
|
- | 779 | dpm_state = POWER_STATE_TYPE_PERFORMANCE; |
|
- | 780 | goto restart_search; |
|
- | 781 | } |
|
- | 782 | case POWER_STATE_TYPE_INTERNAL_THERMAL: |
|
- | 783 | dpm_state = POWER_STATE_TYPE_INTERNAL_ACPI; |
|
- | 784 | goto restart_search; |
|
- | 785 | case POWER_STATE_TYPE_INTERNAL_ACPI: |
|
- | 786 | dpm_state = POWER_STATE_TYPE_BATTERY; |
|
- | 787 | goto restart_search; |
|
- | 788 | case POWER_STATE_TYPE_BATTERY: |
|
- | 789 | case POWER_STATE_TYPE_BALANCED: |
|
- | 790 | case POWER_STATE_TYPE_INTERNAL_3DPERF: |
|
- | 791 | dpm_state = POWER_STATE_TYPE_PERFORMANCE; |
|
- | 792 | goto restart_search; |
|
- | 793 | default: |
|
- | 794 | break; |
|
- | 795 | } |
|
- | 796 | ||
- | 797 | return NULL; |
|
- | 798 | } |
|
- | 799 | ||
- | 800 | static void radeon_dpm_change_power_state_locked(struct radeon_device *rdev) |
|
- | 801 | { |
|
- | 802 | int i; |
|
- | 803 | struct radeon_ps *ps; |
|
- | 804 | enum radeon_pm_state_type dpm_state; |
|
- | 805 | int ret; |
|
- | 806 | ||
- | 807 | /* if dpm init failed */ |
|
- | 808 | if (!rdev->pm.dpm_enabled) |
|
- | 809 | return; |
|
- | 810 | ||
- | 811 | if (rdev->pm.dpm.user_state != rdev->pm.dpm.state) { |
|
- | 812 | /* add other state override checks here */ |
|
- | 813 | if ((!rdev->pm.dpm.thermal_active) && |
|
- | 814 | (!rdev->pm.dpm.uvd_active)) |
|
- | 815 | rdev->pm.dpm.state = rdev->pm.dpm.user_state; |
|
- | 816 | } |
|
- | 817 | dpm_state = rdev->pm.dpm.state; |
|
- | 818 | ||
- | 819 | ps = radeon_dpm_pick_power_state(rdev, dpm_state); |
|
- | 820 | if (ps) |
|
- | 821 | rdev->pm.dpm.requested_ps = ps; |
|
- | 822 | else |
|
- | 823 | return; |
|
- | 824 | ||
- | 825 | /* no need to reprogram if nothing changed unless we are on BTC+ */ |
|
- | 826 | if (rdev->pm.dpm.current_ps == rdev->pm.dpm.requested_ps) { |
|
- | 827 | /* vce just modifies an existing state so force a change */ |
|
- | 828 | if (ps->vce_active != rdev->pm.dpm.vce_active) |
|
- | 829 | goto force; |
|
- | 830 | if ((rdev->family < CHIP_BARTS) || (rdev->flags & RADEON_IS_IGP)) { |
|
- | 831 | /* for pre-BTC and APUs if the num crtcs changed but state is the same, |
|
- | 832 | * all we need to do is update the display configuration. |
|
- | 833 | */ |
|
- | 834 | if (rdev->pm.dpm.new_active_crtcs != rdev->pm.dpm.current_active_crtcs) { |
|
- | 835 | /* update display watermarks based on new power state */ |
|
- | 836 | radeon_bandwidth_update(rdev); |
|
- | 837 | /* update displays */ |
|
- | 838 | radeon_dpm_display_configuration_changed(rdev); |
|
- | 839 | rdev->pm.dpm.current_active_crtcs = rdev->pm.dpm.new_active_crtcs; |
|
- | 840 | rdev->pm.dpm.current_active_crtc_count = rdev->pm.dpm.new_active_crtc_count; |
|
- | 841 | } |
|
- | 842 | return; |
|
- | 843 | } else { |
|
- | 844 | /* for BTC+ if the num crtcs hasn't changed and state is the same, |
|
- | 845 | * nothing to do, if the num crtcs is > 1 and state is the same, |
|
- | 846 | * update display configuration. |
|
- | 847 | */ |
|
- | 848 | if (rdev->pm.dpm.new_active_crtcs == |
|
- | 849 | rdev->pm.dpm.current_active_crtcs) { |
|
- | 850 | return; |
|
- | 851 | } else { |
|
- | 852 | if ((rdev->pm.dpm.current_active_crtc_count > 1) && |
|
- | 853 | (rdev->pm.dpm.new_active_crtc_count > 1)) { |
|
- | 854 | /* update display watermarks based on new power state */ |
|
- | 855 | radeon_bandwidth_update(rdev); |
|
- | 856 | /* update displays */ |
|
- | 857 | radeon_dpm_display_configuration_changed(rdev); |
|
- | 858 | rdev->pm.dpm.current_active_crtcs = rdev->pm.dpm.new_active_crtcs; |
|
- | 859 | rdev->pm.dpm.current_active_crtc_count = rdev->pm.dpm.new_active_crtc_count; |
|
- | 860 | return; |
|
- | 861 | } |
|
- | 862 | } |
|
- | 863 | } |
|
- | 864 | } |
|
- | 865 | ||
- | 866 | force: |
|
- | 867 | if (radeon_dpm == 1) { |
|
- | 868 | printk("switching from power state:\n"); |
|
- | 869 | radeon_dpm_print_power_state(rdev, rdev->pm.dpm.current_ps); |
|
- | 870 | printk("switching to power state:\n"); |
|
- | 871 | radeon_dpm_print_power_state(rdev, rdev->pm.dpm.requested_ps); |
|
- | 872 | } |
|
- | 873 | ||
- | 874 | mutex_lock(&rdev->ddev->struct_mutex); |
|
- | 875 | // down_write(&rdev->pm.mclk_lock); |
|
- | 876 | mutex_lock(&rdev->ring_lock); |
|
- | 877 | ||
- | 878 | /* update whether vce is active */ |
|
- | 879 | ps->vce_active = rdev->pm.dpm.vce_active; |
|
- | 880 | ||
- | 881 | ret = radeon_dpm_pre_set_power_state(rdev); |
|
- | 882 | if (ret) |
|
- | 883 | goto done; |
|
- | 884 | ||
- | 885 | /* update display watermarks based on new power state */ |
|
- | 886 | radeon_bandwidth_update(rdev); |
|
- | 887 | /* update displays */ |
|
- | 888 | radeon_dpm_display_configuration_changed(rdev); |
|
- | 889 | ||
- | 890 | rdev->pm.dpm.current_active_crtcs = rdev->pm.dpm.new_active_crtcs; |
|
- | 891 | rdev->pm.dpm.current_active_crtc_count = rdev->pm.dpm.new_active_crtc_count; |
|
- | 892 | ||
- | 893 | /* wait for the rings to drain */ |
|
- | 894 | for (i = 0; i < RADEON_NUM_RINGS; i++) { |
|
- | 895 | struct radeon_ring *ring = &rdev->ring[i]; |
|
- | 896 | if (ring->ready) |
|
- | 897 | radeon_fence_wait_empty(rdev, i); |
|
- | 898 | } |
|
- | 899 | ||
- | 900 | /* program the new power state */ |
|
- | 901 | radeon_dpm_set_power_state(rdev); |
|
- | 902 | ||
- | 903 | /* update current power state */ |
|
- | 904 | rdev->pm.dpm.current_ps = rdev->pm.dpm.requested_ps; |
|
- | 905 | ||
- | 906 | radeon_dpm_post_set_power_state(rdev); |
|
- | 907 | ||
- | 908 | if (rdev->asic->dpm.force_performance_level) { |
|
- | 909 | if (rdev->pm.dpm.thermal_active) { |
|
- | 910 | enum radeon_dpm_forced_level level = rdev->pm.dpm.forced_level; |
|
- | 911 | /* force low perf level for thermal */ |
|
- | 912 | radeon_dpm_force_performance_level(rdev, RADEON_DPM_FORCED_LEVEL_LOW); |
|
- | 913 | /* save the user's level */ |
|
- | 914 | rdev->pm.dpm.forced_level = level; |
|
- | 915 | } else { |
|
- | 916 | /* otherwise, user selected level */ |
|
- | 917 | radeon_dpm_force_performance_level(rdev, rdev->pm.dpm.forced_level); |
|
- | 918 | } |
|
- | 919 | } |
|
- | 920 | ||
- | 921 | done: |
|
- | 922 | mutex_unlock(&rdev->ring_lock); |
|
- | 923 | // up_write(&rdev->pm.mclk_lock); |
|
- | 924 | mutex_unlock(&rdev->ddev->struct_mutex); |
|
- | 925 | } |
|
- | 926 | ||
- | 927 | void radeon_dpm_enable_uvd(struct radeon_device *rdev, bool enable) |
|
- | 928 | { |
|
- | 929 | enum radeon_pm_state_type dpm_state; |
|
- | 930 | ||
- | 931 | if (rdev->asic->dpm.powergate_uvd) { |
|
- | 932 | mutex_lock(&rdev->pm.mutex); |
|
- | 933 | /* don't powergate anything if we |
|
- | 934 | have active but pause streams */ |
|
- | 935 | enable |= rdev->pm.dpm.sd > 0; |
|
- | 936 | enable |= rdev->pm.dpm.hd > 0; |
|
- | 937 | /* enable/disable UVD */ |
|
- | 938 | radeon_dpm_powergate_uvd(rdev, !enable); |
|
- | 939 | mutex_unlock(&rdev->pm.mutex); |
|
- | 940 | } else { |
|
- | 941 | if (enable) { |
|
- | 942 | mutex_lock(&rdev->pm.mutex); |
|
- | 943 | rdev->pm.dpm.uvd_active = true; |
|
- | 944 | /* disable this for now */ |
|
- | 945 | #if 0 |
|
- | 946 | if ((rdev->pm.dpm.sd == 1) && (rdev->pm.dpm.hd == 0)) |
|
- | 947 | dpm_state = POWER_STATE_TYPE_INTERNAL_UVD_SD; |
|
- | 948 | else if ((rdev->pm.dpm.sd == 2) && (rdev->pm.dpm.hd == 0)) |
|
- | 949 | dpm_state = POWER_STATE_TYPE_INTERNAL_UVD_HD; |
|
- | 950 | else if ((rdev->pm.dpm.sd == 0) && (rdev->pm.dpm.hd == 1)) |
|
- | 951 | dpm_state = POWER_STATE_TYPE_INTERNAL_UVD_HD; |
|
- | 952 | else if ((rdev->pm.dpm.sd == 0) && (rdev->pm.dpm.hd == 2)) |
|
- | 953 | dpm_state = POWER_STATE_TYPE_INTERNAL_UVD_HD2; |
|
- | 954 | else |
|
- | 955 | #endif |
|
- | 956 | dpm_state = POWER_STATE_TYPE_INTERNAL_UVD; |
|
- | 957 | rdev->pm.dpm.state = dpm_state; |
|
- | 958 | mutex_unlock(&rdev->pm.mutex); |
|
- | 959 | } else { |
|
- | 960 | mutex_lock(&rdev->pm.mutex); |
|
- | 961 | rdev->pm.dpm.uvd_active = false; |
|
- | 962 | mutex_unlock(&rdev->pm.mutex); |
|
- | 963 | } |
|
- | 964 | ||
- | 965 | radeon_pm_compute_clocks(rdev); |
|
- | 966 | } |
|
- | 967 | } |
|
- | 968 | ||
- | 969 | void radeon_dpm_enable_vce(struct radeon_device *rdev, bool enable) |
|
- | 970 | { |
|
- | 971 | if (enable) { |
|
- | 972 | mutex_lock(&rdev->pm.mutex); |
|
- | 973 | rdev->pm.dpm.vce_active = true; |
|
- | 974 | /* XXX select vce level based on ring/task */ |
|
- | 975 | rdev->pm.dpm.vce_level = RADEON_VCE_LEVEL_AC_ALL; |
|
466 | 976 | mutex_unlock(&rdev->pm.mutex); |
|
467 | rdev->pm.int_hwmon_dev = NULL; |
977 | } else { |
468 | 978 | mutex_lock(&rdev->pm.mutex); |
|
469 | return err; |
979 | rdev->pm.dpm.vce_active = false; |
470 | } |
980 | mutex_unlock(&rdev->pm.mutex); |
471 | 981 | } |
|
472 | static void radeon_hwmon_fini(struct radeon_device *rdev) |
982 | |
473 | { |
983 | radeon_pm_compute_clocks(rdev); |
Line 474... | Line -... | ||
474 | } |
- | |
475 | 984 | } |
|
Line -... | Line 985... | ||
- | 985 | ||
- | 986 | static void radeon_pm_suspend_old(struct radeon_device *rdev) |
|
- | 987 | { |
|
- | 988 | mutex_lock(&rdev->pm.mutex); |
|
- | 989 | if (rdev->pm.pm_method == PM_METHOD_DYNPM) { |
|
- | 990 | if (rdev->pm.dynpm_state == DYNPM_STATE_ACTIVE) |
|
- | 991 | rdev->pm.dynpm_state = DYNPM_STATE_SUSPENDED; |
|
- | 992 | } |
|
- | 993 | mutex_unlock(&rdev->pm.mutex); |
|
- | 994 | ||
- | 995 | } |
|
476 | void radeon_pm_suspend(struct radeon_device *rdev) |
996 | |
477 | { |
997 | static void radeon_pm_suspend_dpm(struct radeon_device *rdev) |
- | 998 | { |
|
- | 999 | mutex_lock(&rdev->pm.mutex); |
|
- | 1000 | /* disable dpm */ |
|
- | 1001 | radeon_dpm_disable(rdev); |
|
- | 1002 | /* reset the power state */ |
|
- | 1003 | rdev->pm.dpm.current_ps = rdev->pm.dpm.requested_ps = rdev->pm.dpm.boot_ps; |
|
- | 1004 | rdev->pm.dpm_enabled = false; |
|
- | 1005 | mutex_unlock(&rdev->pm.mutex); |
|
- | 1006 | } |
|
- | 1007 | ||
- | 1008 | void radeon_pm_suspend(struct radeon_device *rdev) |
|
- | 1009 | { |
|
- | 1010 | if (rdev->pm.pm_method == PM_METHOD_DPM) |
|
- | 1011 | radeon_pm_suspend_dpm(rdev); |
|
- | 1012 | else |
|
- | 1013 | radeon_pm_suspend_old(rdev); |
|
- | 1014 | } |
|
- | 1015 | ||
- | 1016 | static void radeon_pm_resume_old(struct radeon_device *rdev) |
|
- | 1017 | { |
|
- | 1018 | /* set up the default clocks if the MC ucode is loaded */ |
|
- | 1019 | if ((rdev->family >= CHIP_BARTS) && |
|
- | 1020 | (rdev->family <= CHIP_CAYMAN) && |
|
478 | mutex_lock(&rdev->pm.mutex); |
1021 | rdev->mc_fw) { |
479 | if (rdev->pm.pm_method == PM_METHOD_DYNPM) { |
1022 | if (rdev->pm.default_vddc) |
480 | if (rdev->pm.dynpm_state == DYNPM_STATE_ACTIVE) |
1023 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddc, |
481 | rdev->pm.dynpm_state = DYNPM_STATE_SUSPENDED; |
1024 | SET_VOLTAGE_TYPE_ASIC_VDDC); |
482 | } |
1025 | if (rdev->pm.default_vddci) |
483 | mutex_unlock(&rdev->pm.mutex); |
1026 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddci, |
- | 1027 | SET_VOLTAGE_TYPE_ASIC_VDDCI); |
|
484 | 1028 | if (rdev->pm.default_sclk) |
|
485 | // cancel_delayed_work_sync(&rdev->pm.dynpm_idle_work); |
1029 | radeon_set_engine_clock(rdev, rdev->pm.default_sclk); |
- | 1030 | if (rdev->pm.default_mclk) |
|
486 | } |
1031 | radeon_set_memory_clock(rdev, rdev->pm.default_mclk); |
487 | 1032 | } |
|
488 | void radeon_pm_resume(struct radeon_device *rdev) |
1033 | /* asic init will reset the default power state */ |
489 | { |
1034 | mutex_lock(&rdev->pm.mutex); |
490 | /* asic init will reset the default power state */ |
1035 | rdev->pm.current_power_state_index = rdev->pm.default_power_state_index; |
491 | mutex_lock(&rdev->pm.mutex); |
1036 | rdev->pm.current_clock_mode_index = 0; |
492 | rdev->pm.current_power_state_index = rdev->pm.default_power_state_index; |
1037 | rdev->pm.current_sclk = rdev->pm.default_sclk; |
493 | rdev->pm.current_clock_mode_index = 0; |
1038 | rdev->pm.current_mclk = rdev->pm.default_mclk; |
494 | rdev->pm.current_sclk = rdev->pm.default_sclk; |
1039 | if (rdev->pm.power_state) { |
Line -... | Line 1040... | ||
- | 1040 | rdev->pm.current_vddc = rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.voltage; |
|
- | 1041 | rdev->pm.current_vddci = rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.vddci; |
|
- | 1042 | } |
|
- | 1043 | if (rdev->pm.pm_method == PM_METHOD_DYNPM |
|
- | 1044 | && rdev->pm.dynpm_state == DYNPM_STATE_SUSPENDED) { |
|
- | 1045 | rdev->pm.dynpm_state = DYNPM_STATE_ACTIVE; |
|
- | 1046 | // schedule_delayed_work(&rdev->pm.dynpm_idle_work, |
|
- | 1047 | // msecs_to_jiffies(RADEON_IDLE_LOOP_MS)); |
|
- | 1048 | } |
|
- | 1049 | mutex_unlock(&rdev->pm.mutex); |
|
- | 1050 | radeon_pm_compute_clocks(rdev); |
|
- | 1051 | } |
|
- | 1052 | ||
- | 1053 | static void radeon_pm_resume_dpm(struct radeon_device *rdev) |
|
- | 1054 | { |
|
- | 1055 | int ret; |
|
- | 1056 | ||
- | 1057 | /* asic init will reset to the boot state */ |
|
- | 1058 | mutex_lock(&rdev->pm.mutex); |
|
- | 1059 | rdev->pm.dpm.current_ps = rdev->pm.dpm.requested_ps = rdev->pm.dpm.boot_ps; |
|
- | 1060 | radeon_dpm_setup_asic(rdev); |
|
- | 1061 | ret = radeon_dpm_enable(rdev); |
|
- | 1062 | mutex_unlock(&rdev->pm.mutex); |
|
- | 1063 | if (ret) |
|
- | 1064 | goto dpm_resume_fail; |
|
- | 1065 | rdev->pm.dpm_enabled = true; |
|
- | 1066 | return; |
|
- | 1067 | ||
- | 1068 | dpm_resume_fail: |
|
- | 1069 | DRM_ERROR("radeon: dpm resume failed\n"); |
|
- | 1070 | if ((rdev->family >= CHIP_BARTS) && |
|
- | 1071 | (rdev->family <= CHIP_CAYMAN) && |
|
- | 1072 | rdev->mc_fw) { |
|
495 | rdev->pm.current_mclk = rdev->pm.default_mclk; |
1073 | if (rdev->pm.default_vddc) |
- | 1074 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddc, |
|
- | 1075 | SET_VOLTAGE_TYPE_ASIC_VDDC); |
|
- | 1076 | if (rdev->pm.default_vddci) |
|
- | 1077 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddci, |
|
- | 1078 | SET_VOLTAGE_TYPE_ASIC_VDDCI); |
|
- | 1079 | if (rdev->pm.default_sclk) |
|
- | 1080 | radeon_set_engine_clock(rdev, rdev->pm.default_sclk); |
|
- | 1081 | if (rdev->pm.default_mclk) |
|
496 | rdev->pm.current_vddc = rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.voltage; |
1082 | radeon_set_memory_clock(rdev, rdev->pm.default_mclk); |
497 | rdev->pm.current_vddci = rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.vddci; |
1083 | } |
Line 498... | Line -... | ||
498 | if (rdev->pm.pm_method == PM_METHOD_DYNPM |
- | |
499 | && rdev->pm.dynpm_state == DYNPM_STATE_SUSPENDED) { |
- | |
500 | rdev->pm.dynpm_state = DYNPM_STATE_ACTIVE; |
1084 | } |
501 | // schedule_delayed_work(&rdev->pm.dynpm_idle_work, |
1085 | |
502 | // msecs_to_jiffies(RADEON_IDLE_LOOP_MS)); |
1086 | void radeon_pm_resume(struct radeon_device *rdev) |
503 | } |
1087 | { |
504 | mutex_unlock(&rdev->pm.mutex); |
1088 | if (rdev->pm.pm_method == PM_METHOD_DPM) |
Line 527... | Line 1111... | ||
527 | radeon_atombios_get_power_modes(rdev); |
1111 | radeon_atombios_get_power_modes(rdev); |
528 | else |
1112 | else |
529 | radeon_combios_get_power_modes(rdev); |
1113 | radeon_combios_get_power_modes(rdev); |
530 | radeon_pm_print_states(rdev); |
1114 | radeon_pm_print_states(rdev); |
531 | radeon_pm_init_profile(rdev); |
1115 | radeon_pm_init_profile(rdev); |
- | 1116 | /* set up the default clocks if the MC ucode is loaded */ |
|
- | 1117 | if ((rdev->family >= CHIP_BARTS) && |
|
- | 1118 | (rdev->family <= CHIP_CAYMAN) && |
|
- | 1119 | rdev->mc_fw) { |
|
- | 1120 | if (rdev->pm.default_vddc) |
|
- | 1121 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddc, |
|
- | 1122 | SET_VOLTAGE_TYPE_ASIC_VDDC); |
|
- | 1123 | if (rdev->pm.default_vddci) |
|
- | 1124 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddci, |
|
- | 1125 | SET_VOLTAGE_TYPE_ASIC_VDDCI); |
|
- | 1126 | if (rdev->pm.default_sclk) |
|
- | 1127 | radeon_set_engine_clock(rdev, rdev->pm.default_sclk); |
|
- | 1128 | if (rdev->pm.default_mclk) |
|
- | 1129 | radeon_set_memory_clock(rdev, rdev->pm.default_mclk); |
|
- | 1130 | } |
|
532 | } |
1131 | } |
Line 533... | Line 1132... | ||
533 | 1132 | ||
534 | /* set up the internal thermal sensor if applicable */ |
1133 | /* set up the internal thermal sensor if applicable */ |
535 | ret = radeon_hwmon_init(rdev); |
1134 | ret = radeon_hwmon_init(rdev); |
536 | if (ret) |
1135 | if (ret) |
Line -... | Line 1136... | ||
- | 1136 | return ret; |
|
- | 1137 | ||
537 | return ret; |
1138 | // INIT_DELAYED_WORK(&rdev->pm.dynpm_idle_work, radeon_dynpm_idle_work_handler); |
- | 1139 | ||
- | 1140 | if (rdev->pm.num_power_states > 1) { |
|
Line 538... | Line 1141... | ||
538 | 1141 | /* where's the best place to put these? */ |
|
539 | if (rdev->pm.num_power_states > 1) { |
1142 | |
Line 540... | Line 1143... | ||
540 | 1143 | ||
541 | DRM_INFO("radeon: power management initialized\n"); |
1144 | DRM_INFO("radeon: power management initialized\n"); |
Line -... | Line 1145... | ||
- | 1145 | } |
|
- | 1146 | ||
- | 1147 | return 0; |
|
- | 1148 | } |
|
- | 1149 | ||
- | 1150 | static void radeon_dpm_print_power_states(struct radeon_device *rdev) |
|
- | 1151 | { |
|
- | 1152 | int i; |
|
- | 1153 | ||
- | 1154 | for (i = 0; i < rdev->pm.dpm.num_ps; i++) { |
|
- | 1155 | printk("== power state %d ==\n", i); |
|
- | 1156 | radeon_dpm_print_power_state(rdev, &rdev->pm.dpm.ps[i]); |
|
- | 1157 | } |
|
- | 1158 | } |
|
- | 1159 | ||
- | 1160 | static int radeon_pm_init_dpm(struct radeon_device *rdev) |
|
- | 1161 | { |
|
- | 1162 | int ret; |
|
- | 1163 | ||
- | 1164 | /* default to balanced state */ |
|
- | 1165 | rdev->pm.dpm.state = POWER_STATE_TYPE_BALANCED; |
|
- | 1166 | rdev->pm.dpm.user_state = POWER_STATE_TYPE_BALANCED; |
|
- | 1167 | rdev->pm.dpm.forced_level = RADEON_DPM_FORCED_LEVEL_AUTO; |
|
- | 1168 | rdev->pm.default_sclk = rdev->clock.default_sclk; |
|
- | 1169 | rdev->pm.default_mclk = rdev->clock.default_mclk; |
|
- | 1170 | rdev->pm.current_sclk = rdev->clock.default_sclk; |
|
- | 1171 | rdev->pm.current_mclk = rdev->clock.default_mclk; |
|
- | 1172 | rdev->pm.int_thermal_type = THERMAL_TYPE_NONE; |
|
- | 1173 | ||
- | 1174 | if (rdev->bios && rdev->is_atom_bios) |
|
- | 1175 | radeon_atombios_get_power_modes(rdev); |
|
- | 1176 | else |
|
- | 1177 | return -EINVAL; |
|
- | 1178 | ||
- | 1179 | /* set up the internal thermal sensor if applicable */ |
|
- | 1180 | ret = radeon_hwmon_init(rdev); |
|
- | 1181 | if (ret) |
|
- | 1182 | return ret; |
|
- | 1183 | ||
- | 1184 | INIT_WORK(&rdev->pm.dpm.thermal.work, radeon_dpm_thermal_work_handler); |
|
- | 1185 | mutex_lock(&rdev->pm.mutex); |
|
- | 1186 | radeon_dpm_init(rdev); |
|
- | 1187 | rdev->pm.dpm.current_ps = rdev->pm.dpm.requested_ps = rdev->pm.dpm.boot_ps; |
|
- | 1188 | if (radeon_dpm == 1) |
|
- | 1189 | radeon_dpm_print_power_states(rdev); |
|
- | 1190 | radeon_dpm_setup_asic(rdev); |
|
- | 1191 | ret = radeon_dpm_enable(rdev); |
|
- | 1192 | mutex_unlock(&rdev->pm.mutex); |
|
- | 1193 | if (ret) |
|
- | 1194 | goto dpm_failed; |
|
- | 1195 | rdev->pm.dpm_enabled = true; |
|
- | 1196 | ||
- | 1197 | DRM_INFO("radeon: dpm initialized\n"); |
|
- | 1198 | ||
- | 1199 | return 0; |
|
- | 1200 | ||
- | 1201 | dpm_failed: |
|
- | 1202 | rdev->pm.dpm_enabled = false; |
|
- | 1203 | if ((rdev->family >= CHIP_BARTS) && |
|
- | 1204 | (rdev->family <= CHIP_CAYMAN) && |
|
- | 1205 | rdev->mc_fw) { |
|
- | 1206 | if (rdev->pm.default_vddc) |
|
- | 1207 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddc, |
|
- | 1208 | SET_VOLTAGE_TYPE_ASIC_VDDC); |
|
- | 1209 | if (rdev->pm.default_vddci) |
|
- | 1210 | radeon_atom_set_voltage(rdev, rdev->pm.default_vddci, |
|
- | 1211 | SET_VOLTAGE_TYPE_ASIC_VDDCI); |
|
- | 1212 | if (rdev->pm.default_sclk) |
|
- | 1213 | radeon_set_engine_clock(rdev, rdev->pm.default_sclk); |
|
- | 1214 | if (rdev->pm.default_mclk) |
|
- | 1215 | radeon_set_memory_clock(rdev, rdev->pm.default_mclk); |
|
542 | } |
1216 | } |
- | 1217 | DRM_ERROR("radeon: dpm initialization failed\n"); |
|
- | 1218 | return ret; |
|
- | 1219 | } |
|
- | 1220 | ||
- | 1221 | int radeon_pm_init(struct radeon_device *rdev) |
|
- | 1222 | { |
|
- | 1223 | /* enable dpm on rv6xx+ */ |
|
- | 1224 | switch (rdev->family) { |
|
- | 1225 | case CHIP_RV610: |
|
- | 1226 | case CHIP_RV630: |
|
- | 1227 | case CHIP_RV620: |
|
- | 1228 | case CHIP_RV635: |
|
- | 1229 | case CHIP_RV670: |
|
- | 1230 | case CHIP_RS780: |
|
- | 1231 | case CHIP_RS880: |
|
- | 1232 | case CHIP_RV770: |
|
- | 1233 | /* DPM requires the RLC, RV770+ dGPU requires SMC */ |
|
- | 1234 | if (!rdev->rlc_fw) |
|
- | 1235 | rdev->pm.pm_method = PM_METHOD_PROFILE; |
|
- | 1236 | else if ((rdev->family >= CHIP_RV770) && |
|
- | 1237 | (!(rdev->flags & RADEON_IS_IGP)) && |
|
- | 1238 | (!rdev->smc_fw)) |
|
- | 1239 | rdev->pm.pm_method = PM_METHOD_PROFILE; |
|
- | 1240 | else if (radeon_dpm == 1) |
|
- | 1241 | rdev->pm.pm_method = PM_METHOD_DPM; |
|
- | 1242 | else |
|
- | 1243 | rdev->pm.pm_method = PM_METHOD_PROFILE; |
|
- | 1244 | break; |
|
- | 1245 | case CHIP_RV730: |
|
- | 1246 | case CHIP_RV710: |
|
- | 1247 | case CHIP_RV740: |
|
- | 1248 | case CHIP_CEDAR: |
|
- | 1249 | case CHIP_REDWOOD: |
|
- | 1250 | case CHIP_JUNIPER: |
|
- | 1251 | case CHIP_CYPRESS: |
|
- | 1252 | case CHIP_HEMLOCK: |
|
- | 1253 | case CHIP_PALM: |
|
- | 1254 | case CHIP_SUMO: |
|
- | 1255 | case CHIP_SUMO2: |
|
- | 1256 | case CHIP_BARTS: |
|
- | 1257 | case CHIP_TURKS: |
|
- | 1258 | case CHIP_CAICOS: |
|
- | 1259 | case CHIP_CAYMAN: |
|
- | 1260 | case CHIP_ARUBA: |
|
- | 1261 | case CHIP_TAHITI: |
|
- | 1262 | case CHIP_PITCAIRN: |
|
- | 1263 | case CHIP_VERDE: |
|
- | 1264 | case CHIP_OLAND: |
|
- | 1265 | case CHIP_HAINAN: |
|
- | 1266 | case CHIP_BONAIRE: |
|
- | 1267 | case CHIP_KABINI: |
|
- | 1268 | case CHIP_KAVERI: |
|
- | 1269 | case CHIP_HAWAII: |
|
- | 1270 | case CHIP_MULLINS: |
|
- | 1271 | /* DPM requires the RLC, RV770+ dGPU requires SMC */ |
|
- | 1272 | if (!rdev->rlc_fw) |
|
- | 1273 | rdev->pm.pm_method = PM_METHOD_PROFILE; |
|
- | 1274 | else if ((rdev->family >= CHIP_RV770) && |
|
- | 1275 | (!(rdev->flags & RADEON_IS_IGP)) && |
|
- | 1276 | (!rdev->smc_fw)) |
|
- | 1277 | rdev->pm.pm_method = PM_METHOD_PROFILE; |
|
- | 1278 | else if (radeon_dpm == 0) |
|
- | 1279 | rdev->pm.pm_method = PM_METHOD_PROFILE; |
|
- | 1280 | else |
|
- | 1281 | rdev->pm.pm_method = PM_METHOD_DPM; |
|
- | 1282 | break; |
|
- | 1283 | default: |
|
- | 1284 | /* default to profile method */ |
|
- | 1285 | rdev->pm.pm_method = PM_METHOD_PROFILE; |
|
- | 1286 | break; |
|
- | 1287 | } |
|
- | 1288 | ||
- | 1289 | if (rdev->pm.pm_method == PM_METHOD_DPM) |
|
- | 1290 | return radeon_pm_init_dpm(rdev); |
|
- | 1291 | else |
|
- | 1292 | return radeon_pm_init_old(rdev); |
|
- | 1293 | } |
|
- | 1294 | ||
- | 1295 | int radeon_pm_late_init(struct radeon_device *rdev) |
|
- | 1296 | { |
|
- | 1297 | int ret = 0; |
|
- | 1298 | ||
- | 1299 | if (rdev->pm.pm_method == PM_METHOD_DPM) { |
|
- | 1300 | mutex_lock(&rdev->pm.mutex); |
|
- | 1301 | ret = radeon_dpm_late_enable(rdev); |
|
- | 1302 | mutex_unlock(&rdev->pm.mutex); |
|
543 | 1303 | } |
|
544 | return 0; |
1304 | return ret; |
545 | } |
1305 | } |
546 | 1306 | ||
547 | void radeon_pm_fini(struct radeon_device *rdev) |
1307 | static void radeon_pm_fini_old(struct radeon_device *rdev) |
Line 563... | Line 1323... | ||
563 | // cancel_delayed_work_sync(&rdev->pm.dynpm_idle_work); |
1323 | // cancel_delayed_work_sync(&rdev->pm.dynpm_idle_work); |
Line 564... | Line 1324... | ||
564 | 1324 | ||
Line 565... | Line 1325... | ||
565 | } |
1325 | } |
- | 1326 | ||
566 | 1327 | radeon_hwmon_fini(rdev); |
|
Line -... | Line 1328... | ||
- | 1328 | kfree(rdev->pm.power_state); |
|
- | 1329 | } |
|
- | 1330 | ||
- | 1331 | static void radeon_pm_fini_dpm(struct radeon_device *rdev) |
|
- | 1332 | { |
|
- | 1333 | if (rdev->pm.num_power_states > 1) { |
|
- | 1334 | mutex_lock(&rdev->pm.mutex); |
|
- | 1335 | radeon_dpm_disable(rdev); |
|
- | 1336 | mutex_unlock(&rdev->pm.mutex); |
|
- | 1337 | } |
|
- | 1338 | radeon_dpm_fini(rdev); |
|
- | 1339 | ||
- | 1340 | radeon_hwmon_fini(rdev); |
|
- | 1341 | kfree(rdev->pm.power_state); |
|
- | 1342 | } |
|
- | 1343 | ||
- | 1344 | void radeon_pm_fini(struct radeon_device *rdev) |
|
- | 1345 | { |
|
- | 1346 | if (rdev->pm.pm_method == PM_METHOD_DPM) |
|
- | 1347 | radeon_pm_fini_dpm(rdev); |
|
- | 1348 | else |
|
567 | radeon_hwmon_fini(rdev); |
1349 | radeon_pm_fini_old(rdev); |
568 | } |
1350 | } |
569 | 1351 | ||
570 | void radeon_pm_compute_clocks(struct radeon_device *rdev) |
1352 | static void radeon_pm_compute_clocks_old(struct radeon_device *rdev) |
571 | { |
1353 | { |
Line 578... | Line 1360... | ||
578 | 1360 | ||
Line 579... | Line 1361... | ||
579 | mutex_lock(&rdev->pm.mutex); |
1361 | mutex_lock(&rdev->pm.mutex); |
580 | 1362 | ||
- | 1363 | rdev->pm.active_crtcs = 0; |
|
581 | rdev->pm.active_crtcs = 0; |
1364 | rdev->pm.active_crtc_count = 0; |
582 | rdev->pm.active_crtc_count = 0; |
1365 | if (rdev->num_crtc && rdev->mode_info.mode_config_initialized) { |
583 | list_for_each_entry(crtc, |
1366 | list_for_each_entry(crtc, |
584 | &ddev->mode_config.crtc_list, head) { |
1367 | &ddev->mode_config.crtc_list, head) { |
585 | radeon_crtc = to_radeon_crtc(crtc); |
1368 | radeon_crtc = to_radeon_crtc(crtc); |
586 | if (radeon_crtc->enabled) { |
1369 | if (radeon_crtc->enabled) { |
587 | rdev->pm.active_crtcs |= (1 << radeon_crtc->crtc_id); |
1370 | rdev->pm.active_crtcs |= (1 << radeon_crtc->crtc_id); |
588 | rdev->pm.active_crtc_count++; |
1371 | rdev->pm.active_crtc_count++; |
- | 1372 | } |
|
Line 589... | Line 1373... | ||
589 | } |
1373 | } |
590 | } |
1374 | } |
591 | 1375 | ||
592 | if (rdev->pm.pm_method == PM_METHOD_PROFILE) { |
1376 | if (rdev->pm.pm_method == PM_METHOD_PROFILE) { |
Line 636... | Line 1420... | ||
636 | } |
1420 | } |
Line 637... | Line 1421... | ||
637 | 1421 | ||
638 | mutex_unlock(&rdev->pm.mutex); |
1422 | mutex_unlock(&rdev->pm.mutex); |
Line -... | Line 1423... | ||
- | 1423 | } |
|
- | 1424 | ||
- | 1425 | static void radeon_pm_compute_clocks_dpm(struct radeon_device *rdev) |
|
- | 1426 | { |
|
- | 1427 | struct drm_device *ddev = rdev->ddev; |
|
- | 1428 | struct drm_crtc *crtc; |
|
- | 1429 | struct radeon_crtc *radeon_crtc; |
|
- | 1430 | ||
- | 1431 | if (!rdev->pm.dpm_enabled) |
|
- | 1432 | return; |
|
- | 1433 | ||
- | 1434 | mutex_lock(&rdev->pm.mutex); |
|
- | 1435 | ||
- | 1436 | /* update active crtc counts */ |
|
- | 1437 | rdev->pm.dpm.new_active_crtcs = 0; |
|
- | 1438 | rdev->pm.dpm.new_active_crtc_count = 0; |
|
- | 1439 | if (rdev->num_crtc && rdev->mode_info.mode_config_initialized) { |
|
- | 1440 | list_for_each_entry(crtc, |
|
- | 1441 | &ddev->mode_config.crtc_list, head) { |
|
- | 1442 | radeon_crtc = to_radeon_crtc(crtc); |
|
- | 1443 | if (crtc->enabled) { |
|
- | 1444 | rdev->pm.dpm.new_active_crtcs |= (1 << radeon_crtc->crtc_id); |
|
- | 1445 | rdev->pm.dpm.new_active_crtc_count++; |
|
- | 1446 | } |
|
- | 1447 | } |
|
- | 1448 | } |
|
- | 1449 | ||
- | 1450 | /* update battery/ac status */ |
|
- | 1451 | if (power_supply_is_system_supplied() > 0) |
|
- | 1452 | rdev->pm.dpm.ac_power = true; |
|
- | 1453 | else |
|
- | 1454 | rdev->pm.dpm.ac_power = false; |
|
- | 1455 | ||
- | 1456 | radeon_dpm_change_power_state_locked(rdev); |
|
- | 1457 | ||
- | 1458 | mutex_unlock(&rdev->pm.mutex); |
|
- | 1459 | ||
- | 1460 | } |
|
- | 1461 | ||
- | 1462 | void radeon_pm_compute_clocks(struct radeon_device *rdev) |
|
- | 1463 | { |
|
- | 1464 | if (rdev->pm.pm_method == PM_METHOD_DPM) |
|
- | 1465 | radeon_pm_compute_clocks_dpm(rdev); |
|
- | 1466 | else |
|
- | 1467 | radeon_pm_compute_clocks_old(rdev); |
|
639 | } |
1468 | } |
640 | 1469 | ||
641 | static bool radeon_pm_in_vbl(struct radeon_device *rdev) |
1470 | static bool radeon_pm_in_vbl(struct radeon_device *rdev) |
642 | { |
1471 | { |
Line 643... | Line 1472... | ||
643 | int crtc, vpos, hpos, vbl_status; |
1472 | int crtc, vpos, hpos, vbl_status; |
644 | bool in_vbl = true; |
1473 | bool in_vbl = true; |
645 | 1474 | ||
646 | /* Iterate over all active crtc's. All crtc's must be in vblank, |
1475 | /* Iterate over all active crtc's. All crtc's must be in vblank, |
647 | * otherwise return in_vbl == false. |
1476 | * otherwise return in_vbl == false. |
648 | */ |
1477 | */ |
649 | for (crtc = 0; (crtc < rdev->num_crtc) && in_vbl; crtc++) { |
1478 | for (crtc = 0; (crtc < rdev->num_crtc) && in_vbl; crtc++) { |
650 | if (rdev->pm.active_crtcs & (1 << crtc)) { |
1479 | if (rdev->pm.active_crtcs & (1 << crtc)) { |
651 | vbl_status = radeon_get_crtc_scanoutpos(rdev->ddev, crtc, &vpos, &hpos); |
1480 | vbl_status = radeon_get_crtc_scanoutpos(rdev->ddev, crtc, 0, &vpos, &hpos, NULL, NULL); |
652 | if ((vbl_status & DRM_SCANOUTPOS_VALID) && |
1481 | if ((vbl_status & DRM_SCANOUTPOS_VALID) && |
653 | !(vbl_status & DRM_SCANOUTPOS_INVBL)) |
1482 | !(vbl_status & DRM_SCANOUTPOS_INVBL)) |
Line 678... | Line 1507... | ||
678 | static int radeon_debugfs_pm_info(struct seq_file *m, void *data) |
1507 | static int radeon_debugfs_pm_info(struct seq_file *m, void *data) |
679 | { |
1508 | { |
680 | struct drm_info_node *node = (struct drm_info_node *) m->private; |
1509 | struct drm_info_node *node = (struct drm_info_node *) m->private; |
681 | struct drm_device *dev = node->minor->dev; |
1510 | struct drm_device *dev = node->minor->dev; |
682 | struct radeon_device *rdev = dev->dev_private; |
1511 | struct radeon_device *rdev = dev->dev_private; |
- | 1512 | struct drm_device *ddev = rdev->ddev; |
|
Line -... | Line 1513... | ||
- | 1513 | ||
- | 1514 | if ((rdev->flags & RADEON_IS_PX) && |
|
- | 1515 | (ddev->switch_power_state != DRM_SWITCH_POWER_ON)) { |
|
- | 1516 | seq_printf(m, "PX asic powered off\n"); |
|
- | 1517 | } else if (rdev->pm.dpm_enabled) { |
|
- | 1518 | mutex_lock(&rdev->pm.mutex); |
|
- | 1519 | if (rdev->asic->dpm.debugfs_print_current_performance_level) |
|
- | 1520 | radeon_dpm_debugfs_print_current_performance_level(rdev, m); |
|
- | 1521 | else |
|
- | 1522 | seq_printf(m, "Debugfs support not implemented for this asic\n"); |
|
- | 1523 | mutex_unlock(&rdev->pm.mutex); |
|
683 | 1524 | } else { |
|
684 | seq_printf(m, "default engine clock: %u0 kHz\n", rdev->pm.default_sclk); |
1525 | seq_printf(m, "default engine clock: %u0 kHz\n", rdev->pm.default_sclk); |
685 | /* radeon_get_engine_clock is not reliable on APUs so just print the current clock */ |
1526 | /* radeon_get_engine_clock is not reliable on APUs so just print the current clock */ |
686 | if ((rdev->family >= CHIP_PALM) && (rdev->flags & RADEON_IS_IGP)) |
1527 | if ((rdev->family >= CHIP_PALM) && (rdev->flags & RADEON_IS_IGP)) |
687 | seq_printf(m, "current engine clock: %u0 kHz\n", rdev->pm.current_sclk); |
1528 | seq_printf(m, "current engine clock: %u0 kHz\n", rdev->pm.current_sclk); |
Line 692... | Line 1533... | ||
692 | seq_printf(m, "current memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev)); |
1533 | seq_printf(m, "current memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev)); |
693 | if (rdev->pm.current_vddc) |
1534 | if (rdev->pm.current_vddc) |
694 | seq_printf(m, "voltage: %u mV\n", rdev->pm.current_vddc); |
1535 | seq_printf(m, "voltage: %u mV\n", rdev->pm.current_vddc); |
695 | if (rdev->asic->pm.get_pcie_lanes) |
1536 | if (rdev->asic->pm.get_pcie_lanes) |
696 | seq_printf(m, "PCIE lanes: %d\n", radeon_get_pcie_lanes(rdev)); |
1537 | seq_printf(m, "PCIE lanes: %d\n", radeon_get_pcie_lanes(rdev)); |
- | 1538 | } |
|
Line 697... | Line 1539... | ||
697 | 1539 | ||
698 | return 0; |
1540 | return 0; |
Line 699... | Line 1541... | ||
699 | } |
1541 | } |