2 * Permission is hereby granted, free of charge, to any person obtaining a
3 * copy of this software and associated documentation files (the "Software"),
4 * to deal in the Software without restriction, including without limitation
5 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
6 * and/or sell copies of the Software, and to permit persons to whom the
7 * Software is furnished to do so, subject to the following conditions:
9 * The above copyright notice and this permission notice shall be included in
10 * all copies or substantial portions of the Software.
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
16 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
17 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
18 * OTHER DEALINGS IN THE SOFTWARE.
20 * Authors: Rafał Miłecki <zajec5@gmail.com>
21 * Alex Deucher <alexdeucher@gmail.com>
27 #include <linux/acpi.h>
29 #include <linux/power_supply.h>
31 #define RADEON_IDLE_LOOP_MS 100
32 #define RADEON_RECLOCK_DELAY_MS 200
33 #define RADEON_WAIT_VBLANK_TIMEOUT 200
34 #define RADEON_WAIT_IDLE_TIMEOUT 200
36 static void radeon_dynpm_idle_work_handler(struct work_struct *work);
37 static int radeon_debugfs_pm_init(struct radeon_device *rdev);
38 static bool radeon_pm_in_vbl(struct radeon_device *rdev);
39 static bool radeon_pm_debug_check_in_vbl(struct radeon_device *rdev, bool finish);
40 static void radeon_pm_update_profile(struct radeon_device *rdev);
41 static void radeon_pm_set_clocks(struct radeon_device *rdev);
43 #define ACPI_AC_CLASS "ac_adapter"
46 static int radeon_acpi_event(struct notifier_block *nb,
50 struct radeon_device *rdev = container_of(nb, struct radeon_device, acpi_nb);
51 struct acpi_bus_event *entry = (struct acpi_bus_event *)data;
53 if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) {
54 if (power_supply_is_system_supplied() > 0)
55 DRM_DEBUG("pm: AC\n");
57 DRM_DEBUG("pm: DC\n");
59 if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
60 if (rdev->pm.profile == PM_PROFILE_AUTO) {
61 mutex_lock(&rdev->pm.mutex);
62 radeon_pm_update_profile(rdev);
63 radeon_pm_set_clocks(rdev);
64 mutex_unlock(&rdev->pm.mutex);
73 static void radeon_pm_update_profile(struct radeon_device *rdev)
75 switch (rdev->pm.profile) {
76 case PM_PROFILE_DEFAULT:
77 rdev->pm.profile_index = PM_PROFILE_DEFAULT_IDX;
80 if (power_supply_is_system_supplied() > 0) {
81 if (rdev->pm.active_crtc_count > 1)
82 rdev->pm.profile_index = PM_PROFILE_HIGH_MH_IDX;
84 rdev->pm.profile_index = PM_PROFILE_HIGH_SH_IDX;
86 if (rdev->pm.active_crtc_count > 1)
87 rdev->pm.profile_index = PM_PROFILE_LOW_MH_IDX;
89 rdev->pm.profile_index = PM_PROFILE_LOW_SH_IDX;
93 if (rdev->pm.active_crtc_count > 1)
94 rdev->pm.profile_index = PM_PROFILE_LOW_MH_IDX;
96 rdev->pm.profile_index = PM_PROFILE_LOW_SH_IDX;
99 if (rdev->pm.active_crtc_count > 1)
100 rdev->pm.profile_index = PM_PROFILE_HIGH_MH_IDX;
102 rdev->pm.profile_index = PM_PROFILE_HIGH_SH_IDX;
106 if (rdev->pm.active_crtc_count == 0) {
107 rdev->pm.requested_power_state_index =
108 rdev->pm.profiles[rdev->pm.profile_index].dpms_off_ps_idx;
109 rdev->pm.requested_clock_mode_index =
110 rdev->pm.profiles[rdev->pm.profile_index].dpms_off_cm_idx;
112 rdev->pm.requested_power_state_index =
113 rdev->pm.profiles[rdev->pm.profile_index].dpms_on_ps_idx;
114 rdev->pm.requested_clock_mode_index =
115 rdev->pm.profiles[rdev->pm.profile_index].dpms_on_cm_idx;
119 static void radeon_unmap_vram_bos(struct radeon_device *rdev)
121 struct radeon_bo *bo, *n;
123 if (list_empty(&rdev->gem.objects))
126 list_for_each_entry_safe(bo, n, &rdev->gem.objects, list) {
127 if (bo->tbo.mem.mem_type == TTM_PL_VRAM)
128 ttm_bo_unmap_virtual(&bo->tbo);
131 if (rdev->gart.table.vram.robj)
132 ttm_bo_unmap_virtual(&rdev->gart.table.vram.robj->tbo);
134 if (rdev->stollen_vga_memory)
135 ttm_bo_unmap_virtual(&rdev->stollen_vga_memory->tbo);
137 if (rdev->r600_blit.shader_obj)
138 ttm_bo_unmap_virtual(&rdev->r600_blit.shader_obj->tbo);
141 static void radeon_sync_with_vblank(struct radeon_device *rdev)
143 if (rdev->pm.active_crtcs) {
144 rdev->pm.vblank_sync = false;
146 rdev->irq.vblank_queue, rdev->pm.vblank_sync,
147 msecs_to_jiffies(RADEON_WAIT_VBLANK_TIMEOUT));
151 static void radeon_set_power_state(struct radeon_device *rdev)
155 if ((rdev->pm.requested_clock_mode_index == rdev->pm.current_clock_mode_index) &&
156 (rdev->pm.requested_power_state_index == rdev->pm.current_power_state_index))
159 if (radeon_gui_idle(rdev)) {
160 sclk = rdev->pm.power_state[rdev->pm.requested_power_state_index].
161 clock_info[rdev->pm.requested_clock_mode_index].sclk;
162 if (sclk > rdev->clock.default_sclk)
163 sclk = rdev->clock.default_sclk;
165 mclk = rdev->pm.power_state[rdev->pm.requested_power_state_index].
166 clock_info[rdev->pm.requested_clock_mode_index].mclk;
167 if (mclk > rdev->clock.default_mclk)
168 mclk = rdev->clock.default_mclk;
170 /* voltage, pcie lanes, etc.*/
171 radeon_pm_misc(rdev);
173 if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
174 radeon_sync_with_vblank(rdev);
176 if (!radeon_pm_in_vbl(rdev))
179 radeon_pm_prepare(rdev);
180 /* set engine clock */
181 if (sclk != rdev->pm.current_sclk) {
182 radeon_pm_debug_check_in_vbl(rdev, false);
183 radeon_set_engine_clock(rdev, sclk);
184 radeon_pm_debug_check_in_vbl(rdev, true);
185 rdev->pm.current_sclk = sclk;
186 DRM_DEBUG("Setting: e: %d\n", sclk);
189 /* set memory clock */
190 if (rdev->asic->set_memory_clock && (mclk != rdev->pm.current_mclk)) {
191 radeon_pm_debug_check_in_vbl(rdev, false);
192 radeon_set_memory_clock(rdev, mclk);
193 radeon_pm_debug_check_in_vbl(rdev, true);
194 rdev->pm.current_mclk = mclk;
195 DRM_DEBUG("Setting: m: %d\n", mclk);
197 radeon_pm_finish(rdev);
199 /* set engine clock */
200 if (sclk != rdev->pm.current_sclk) {
201 radeon_sync_with_vblank(rdev);
202 radeon_pm_prepare(rdev);
203 radeon_set_engine_clock(rdev, sclk);
204 radeon_pm_finish(rdev);
205 rdev->pm.current_sclk = sclk;
206 DRM_DEBUG("Setting: e: %d\n", sclk);
208 /* set memory clock */
209 if (rdev->asic->set_memory_clock && (mclk != rdev->pm.current_mclk)) {
210 radeon_sync_with_vblank(rdev);
211 radeon_pm_prepare(rdev);
212 radeon_set_memory_clock(rdev, mclk);
213 radeon_pm_finish(rdev);
214 rdev->pm.current_mclk = mclk;
215 DRM_DEBUG("Setting: m: %d\n", mclk);
219 rdev->pm.current_power_state_index = rdev->pm.requested_power_state_index;
220 rdev->pm.current_clock_mode_index = rdev->pm.requested_clock_mode_index;
222 DRM_DEBUG("pm: GUI not idle!!!\n");
225 static void radeon_pm_set_clocks(struct radeon_device *rdev)
229 mutex_lock(&rdev->ddev->struct_mutex);
230 mutex_lock(&rdev->vram_mutex);
231 mutex_lock(&rdev->cp.mutex);
233 /* gui idle int has issues on older chips it seems */
234 if (rdev->family >= CHIP_R600) {
235 if (rdev->irq.installed) {
236 /* wait for GPU idle */
237 rdev->pm.gui_idle = false;
238 rdev->irq.gui_idle = true;
239 radeon_irq_set(rdev);
240 wait_event_interruptible_timeout(
241 rdev->irq.idle_queue, rdev->pm.gui_idle,
242 msecs_to_jiffies(RADEON_WAIT_IDLE_TIMEOUT));
243 rdev->irq.gui_idle = false;
244 radeon_irq_set(rdev);
247 if (rdev->cp.ready) {
248 struct radeon_fence *fence;
249 radeon_ring_alloc(rdev, 64);
250 radeon_fence_create(rdev, &fence);
251 radeon_fence_emit(rdev, fence);
252 radeon_ring_commit(rdev);
253 radeon_fence_wait(fence, false);
254 radeon_fence_unref(&fence);
257 radeon_unmap_vram_bos(rdev);
259 if (rdev->irq.installed) {
260 for (i = 0; i < rdev->num_crtc; i++) {
261 if (rdev->pm.active_crtcs & (1 << i)) {
262 rdev->pm.req_vblank |= (1 << i);
263 drm_vblank_get(rdev->ddev, i);
268 radeon_set_power_state(rdev);
270 if (rdev->irq.installed) {
271 for (i = 0; i < rdev->num_crtc; i++) {
272 if (rdev->pm.req_vblank & (1 << i)) {
273 rdev->pm.req_vblank &= ~(1 << i);
274 drm_vblank_put(rdev->ddev, i);
279 /* update display watermarks based on new power state */
280 radeon_update_bandwidth_info(rdev);
281 if (rdev->pm.active_crtc_count)
282 radeon_bandwidth_update(rdev);
284 rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
286 mutex_unlock(&rdev->cp.mutex);
287 mutex_unlock(&rdev->vram_mutex);
288 mutex_unlock(&rdev->ddev->struct_mutex);
291 static ssize_t radeon_get_pm_profile(struct device *dev,
292 struct device_attribute *attr,
295 struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
296 struct radeon_device *rdev = ddev->dev_private;
297 int cp = rdev->pm.profile;
299 return snprintf(buf, PAGE_SIZE, "%s\n",
300 (cp == PM_PROFILE_AUTO) ? "auto" :
301 (cp == PM_PROFILE_LOW) ? "low" :
302 (cp == PM_PROFILE_HIGH) ? "high" : "default");
305 static ssize_t radeon_set_pm_profile(struct device *dev,
306 struct device_attribute *attr,
310 struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
311 struct radeon_device *rdev = ddev->dev_private;
313 mutex_lock(&rdev->pm.mutex);
314 if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
315 if (strncmp("default", buf, strlen("default")) == 0)
316 rdev->pm.profile = PM_PROFILE_DEFAULT;
317 else if (strncmp("auto", buf, strlen("auto")) == 0)
318 rdev->pm.profile = PM_PROFILE_AUTO;
319 else if (strncmp("low", buf, strlen("low")) == 0)
320 rdev->pm.profile = PM_PROFILE_LOW;
321 else if (strncmp("high", buf, strlen("high")) == 0)
322 rdev->pm.profile = PM_PROFILE_HIGH;
324 DRM_ERROR("invalid power profile!\n");
327 radeon_pm_update_profile(rdev);
328 radeon_pm_set_clocks(rdev);
331 mutex_unlock(&rdev->pm.mutex);
336 static ssize_t radeon_get_pm_method(struct device *dev,
337 struct device_attribute *attr,
340 struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
341 struct radeon_device *rdev = ddev->dev_private;
342 int pm = rdev->pm.pm_method;
344 return snprintf(buf, PAGE_SIZE, "%s\n",
345 (pm == PM_METHOD_DYNPM) ? "dynpm" : "profile");
348 static ssize_t radeon_set_pm_method(struct device *dev,
349 struct device_attribute *attr,
353 struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
354 struct radeon_device *rdev = ddev->dev_private;
357 if (strncmp("dynpm", buf, strlen("dynpm")) == 0) {
358 mutex_lock(&rdev->pm.mutex);
359 rdev->pm.pm_method = PM_METHOD_DYNPM;
360 rdev->pm.dynpm_state = DYNPM_STATE_PAUSED;
361 rdev->pm.dynpm_planned_action = DYNPM_ACTION_DEFAULT;
362 mutex_unlock(&rdev->pm.mutex);
363 } else if (strncmp("profile", buf, strlen("profile")) == 0) {
364 mutex_lock(&rdev->pm.mutex);
365 rdev->pm.pm_method = PM_METHOD_PROFILE;
367 rdev->pm.dynpm_state = DYNPM_STATE_DISABLED;
368 rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
369 cancel_delayed_work(&rdev->pm.dynpm_idle_work);
370 mutex_unlock(&rdev->pm.mutex);
372 DRM_ERROR("invalid power method!\n");
375 radeon_pm_compute_clocks(rdev);
380 static DEVICE_ATTR(power_profile, S_IRUGO | S_IWUSR, radeon_get_pm_profile, radeon_set_pm_profile);
381 static DEVICE_ATTR(power_method, S_IRUGO | S_IWUSR, radeon_get_pm_method, radeon_set_pm_method);
383 void radeon_pm_suspend(struct radeon_device *rdev)
385 mutex_lock(&rdev->pm.mutex);
386 cancel_delayed_work(&rdev->pm.dynpm_idle_work);
387 rdev->pm.current_power_state_index = -1;
388 rdev->pm.current_clock_mode_index = -1;
389 rdev->pm.current_sclk = 0;
390 rdev->pm.current_mclk = 0;
391 mutex_unlock(&rdev->pm.mutex);
394 void radeon_pm_resume(struct radeon_device *rdev)
396 radeon_pm_compute_clocks(rdev);
399 int radeon_pm_init(struct radeon_device *rdev)
401 /* default to profile method */
402 rdev->pm.pm_method = PM_METHOD_PROFILE;
403 rdev->pm.dynpm_state = DYNPM_STATE_DISABLED;
404 rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
405 rdev->pm.dynpm_can_upclock = true;
406 rdev->pm.dynpm_can_downclock = true;
407 rdev->pm.current_sclk = 0;
408 rdev->pm.current_mclk = 0;
411 if (rdev->is_atom_bios)
412 radeon_atombios_get_power_modes(rdev);
414 radeon_combios_get_power_modes(rdev);
415 radeon_pm_init_profile(rdev);
416 rdev->pm.current_power_state_index = -1;
417 rdev->pm.current_clock_mode_index = -1;
420 if (rdev->pm.num_power_states > 1) {
421 if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
422 mutex_lock(&rdev->pm.mutex);
423 rdev->pm.profile = PM_PROFILE_DEFAULT;
424 radeon_pm_update_profile(rdev);
425 radeon_pm_set_clocks(rdev);
426 mutex_unlock(&rdev->pm.mutex);
429 /* where's the best place to put these? */
430 device_create_file(rdev->dev, &dev_attr_power_profile);
431 device_create_file(rdev->dev, &dev_attr_power_method);
434 rdev->acpi_nb.notifier_call = radeon_acpi_event;
435 register_acpi_notifier(&rdev->acpi_nb);
437 INIT_DELAYED_WORK(&rdev->pm.dynpm_idle_work, radeon_dynpm_idle_work_handler);
439 if (radeon_debugfs_pm_init(rdev)) {
440 DRM_ERROR("Failed to register debugfs file for PM!\n");
443 DRM_INFO("radeon: power management initialized\n");
449 void radeon_pm_fini(struct radeon_device *rdev)
451 if (rdev->pm.num_power_states > 1) {
452 mutex_lock(&rdev->pm.mutex);
453 if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
454 rdev->pm.profile = PM_PROFILE_DEFAULT;
455 radeon_pm_update_profile(rdev);
456 radeon_pm_set_clocks(rdev);
457 } else if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
459 cancel_delayed_work_sync(&rdev->pm.dynpm_idle_work);
460 /* reset default clocks */
461 rdev->pm.dynpm_state = DYNPM_STATE_DISABLED;
462 rdev->pm.dynpm_planned_action = DYNPM_ACTION_DEFAULT;
463 radeon_pm_set_clocks(rdev);
465 mutex_unlock(&rdev->pm.mutex);
467 device_remove_file(rdev->dev, &dev_attr_power_profile);
468 device_remove_file(rdev->dev, &dev_attr_power_method);
470 unregister_acpi_notifier(&rdev->acpi_nb);
474 if (rdev->pm.i2c_bus)
475 radeon_i2c_destroy(rdev->pm.i2c_bus);
478 void radeon_pm_compute_clocks(struct radeon_device *rdev)
480 struct drm_device *ddev = rdev->ddev;
481 struct drm_crtc *crtc;
482 struct radeon_crtc *radeon_crtc;
484 if (rdev->pm.num_power_states < 2)
487 mutex_lock(&rdev->pm.mutex);
489 rdev->pm.active_crtcs = 0;
490 rdev->pm.active_crtc_count = 0;
491 list_for_each_entry(crtc,
492 &ddev->mode_config.crtc_list, head) {
493 radeon_crtc = to_radeon_crtc(crtc);
494 if (radeon_crtc->enabled) {
495 rdev->pm.active_crtcs |= (1 << radeon_crtc->crtc_id);
496 rdev->pm.active_crtc_count++;
500 if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
501 radeon_pm_update_profile(rdev);
502 radeon_pm_set_clocks(rdev);
503 } else if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
504 if (rdev->pm.dynpm_state != DYNPM_STATE_DISABLED) {
505 if (rdev->pm.active_crtc_count > 1) {
506 if (rdev->pm.dynpm_state == DYNPM_STATE_ACTIVE) {
507 cancel_delayed_work(&rdev->pm.dynpm_idle_work);
509 rdev->pm.dynpm_state = DYNPM_STATE_PAUSED;
510 rdev->pm.dynpm_planned_action = DYNPM_ACTION_DEFAULT;
511 radeon_pm_get_dynpm_state(rdev);
512 radeon_pm_set_clocks(rdev);
514 DRM_DEBUG("radeon: dynamic power management deactivated\n");
516 } else if (rdev->pm.active_crtc_count == 1) {
517 /* TODO: Increase clocks if needed for current mode */
519 if (rdev->pm.dynpm_state == DYNPM_STATE_MINIMUM) {
520 rdev->pm.dynpm_state = DYNPM_STATE_ACTIVE;
521 rdev->pm.dynpm_planned_action = DYNPM_ACTION_UPCLOCK;
522 radeon_pm_get_dynpm_state(rdev);
523 radeon_pm_set_clocks(rdev);
525 queue_delayed_work(rdev->wq, &rdev->pm.dynpm_idle_work,
526 msecs_to_jiffies(RADEON_IDLE_LOOP_MS));
527 } else if (rdev->pm.dynpm_state == DYNPM_STATE_PAUSED) {
528 rdev->pm.dynpm_state = DYNPM_STATE_ACTIVE;
529 queue_delayed_work(rdev->wq, &rdev->pm.dynpm_idle_work,
530 msecs_to_jiffies(RADEON_IDLE_LOOP_MS));
531 DRM_DEBUG("radeon: dynamic power management activated\n");
533 } else { /* count == 0 */
534 if (rdev->pm.dynpm_state != DYNPM_STATE_MINIMUM) {
535 cancel_delayed_work(&rdev->pm.dynpm_idle_work);
537 rdev->pm.dynpm_state = DYNPM_STATE_MINIMUM;
538 rdev->pm.dynpm_planned_action = DYNPM_ACTION_MINIMUM;
539 radeon_pm_get_dynpm_state(rdev);
540 radeon_pm_set_clocks(rdev);
546 mutex_unlock(&rdev->pm.mutex);
549 static bool radeon_pm_in_vbl(struct radeon_device *rdev)
551 u32 stat_crtc = 0, vbl = 0, position = 0;
554 if (ASIC_IS_DCE4(rdev)) {
555 if (rdev->pm.active_crtcs & (1 << 0)) {
556 vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
557 EVERGREEN_CRTC0_REGISTER_OFFSET) & 0xfff;
558 position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
559 EVERGREEN_CRTC0_REGISTER_OFFSET) & 0xfff;
561 if (rdev->pm.active_crtcs & (1 << 1)) {
562 vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
563 EVERGREEN_CRTC1_REGISTER_OFFSET) & 0xfff;
564 position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
565 EVERGREEN_CRTC1_REGISTER_OFFSET) & 0xfff;
567 if (rdev->pm.active_crtcs & (1 << 2)) {
568 vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
569 EVERGREEN_CRTC2_REGISTER_OFFSET) & 0xfff;
570 position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
571 EVERGREEN_CRTC2_REGISTER_OFFSET) & 0xfff;
573 if (rdev->pm.active_crtcs & (1 << 3)) {
574 vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
575 EVERGREEN_CRTC3_REGISTER_OFFSET) & 0xfff;
576 position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
577 EVERGREEN_CRTC3_REGISTER_OFFSET) & 0xfff;
579 if (rdev->pm.active_crtcs & (1 << 4)) {
580 vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
581 EVERGREEN_CRTC4_REGISTER_OFFSET) & 0xfff;
582 position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
583 EVERGREEN_CRTC4_REGISTER_OFFSET) & 0xfff;
585 if (rdev->pm.active_crtcs & (1 << 5)) {
586 vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
587 EVERGREEN_CRTC5_REGISTER_OFFSET) & 0xfff;
588 position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
589 EVERGREEN_CRTC5_REGISTER_OFFSET) & 0xfff;
591 } else if (ASIC_IS_AVIVO(rdev)) {
592 if (rdev->pm.active_crtcs & (1 << 0)) {
593 vbl = RREG32(AVIVO_D1CRTC_V_BLANK_START_END) & 0xfff;
594 position = RREG32(AVIVO_D1CRTC_STATUS_POSITION) & 0xfff;
596 if (rdev->pm.active_crtcs & (1 << 1)) {
597 vbl = RREG32(AVIVO_D2CRTC_V_BLANK_START_END) & 0xfff;
598 position = RREG32(AVIVO_D2CRTC_STATUS_POSITION) & 0xfff;
600 if (position < vbl && position > 1)
603 if (rdev->pm.active_crtcs & (1 << 0)) {
604 stat_crtc = RREG32(RADEON_CRTC_STATUS);
605 if (!(stat_crtc & 1))
608 if (rdev->pm.active_crtcs & (1 << 1)) {
609 stat_crtc = RREG32(RADEON_CRTC2_STATUS);
610 if (!(stat_crtc & 1))
615 if (position < vbl && position > 1)
621 static bool radeon_pm_debug_check_in_vbl(struct radeon_device *rdev, bool finish)
624 bool in_vbl = radeon_pm_in_vbl(rdev);
627 DRM_DEBUG("not in vbl for pm change %08x at %s\n", stat_crtc,
628 finish ? "exit" : "entry");
632 static void radeon_dynpm_idle_work_handler(struct work_struct *work)
634 struct radeon_device *rdev;
636 rdev = container_of(work, struct radeon_device,
637 pm.dynpm_idle_work.work);
639 resched = ttm_bo_lock_delayed_workqueue(&rdev->mman.bdev);
640 mutex_lock(&rdev->pm.mutex);
641 if (rdev->pm.dynpm_state == DYNPM_STATE_ACTIVE) {
642 unsigned long irq_flags;
643 int not_processed = 0;
645 read_lock_irqsave(&rdev->fence_drv.lock, irq_flags);
646 if (!list_empty(&rdev->fence_drv.emited)) {
647 struct list_head *ptr;
648 list_for_each(ptr, &rdev->fence_drv.emited) {
649 /* count up to 3, that's enought info */
650 if (++not_processed >= 3)
654 read_unlock_irqrestore(&rdev->fence_drv.lock, irq_flags);
656 if (not_processed >= 3) { /* should upclock */
657 if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_DOWNCLOCK) {
658 rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
659 } else if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_NONE &&
660 rdev->pm.dynpm_can_upclock) {
661 rdev->pm.dynpm_planned_action =
662 DYNPM_ACTION_UPCLOCK;
663 rdev->pm.dynpm_action_timeout = jiffies +
664 msecs_to_jiffies(RADEON_RECLOCK_DELAY_MS);
666 } else if (not_processed == 0) { /* should downclock */
667 if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_UPCLOCK) {
668 rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
669 } else if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_NONE &&
670 rdev->pm.dynpm_can_downclock) {
671 rdev->pm.dynpm_planned_action =
672 DYNPM_ACTION_DOWNCLOCK;
673 rdev->pm.dynpm_action_timeout = jiffies +
674 msecs_to_jiffies(RADEON_RECLOCK_DELAY_MS);
678 /* Note, radeon_pm_set_clocks is called with static_switch set
679 * to false since we want to wait for vbl to avoid flicker.
681 if (rdev->pm.dynpm_planned_action != DYNPM_ACTION_NONE &&
682 jiffies > rdev->pm.dynpm_action_timeout) {
683 radeon_pm_get_dynpm_state(rdev);
684 radeon_pm_set_clocks(rdev);
687 mutex_unlock(&rdev->pm.mutex);
688 ttm_bo_unlock_delayed_workqueue(&rdev->mman.bdev, resched);
690 queue_delayed_work(rdev->wq, &rdev->pm.dynpm_idle_work,
691 msecs_to_jiffies(RADEON_IDLE_LOOP_MS));
697 #if defined(CONFIG_DEBUG_FS)
699 static int radeon_debugfs_pm_info(struct seq_file *m, void *data)
701 struct drm_info_node *node = (struct drm_info_node *) m->private;
702 struct drm_device *dev = node->minor->dev;
703 struct radeon_device *rdev = dev->dev_private;
705 seq_printf(m, "default engine clock: %u0 kHz\n", rdev->clock.default_sclk);
706 seq_printf(m, "current engine clock: %u0 kHz\n", radeon_get_engine_clock(rdev));
707 seq_printf(m, "default memory clock: %u0 kHz\n", rdev->clock.default_mclk);
708 if (rdev->asic->get_memory_clock)
709 seq_printf(m, "current memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev));
710 if (rdev->asic->get_pcie_lanes)
711 seq_printf(m, "PCIE lanes: %d\n", radeon_get_pcie_lanes(rdev));
716 static struct drm_info_list radeon_pm_info_list[] = {
717 {"radeon_pm_info", radeon_debugfs_pm_info, 0, NULL},
721 static int radeon_debugfs_pm_init(struct radeon_device *rdev)
723 #if defined(CONFIG_DEBUG_FS)
724 return radeon_debugfs_add_files(rdev, radeon_pm_info_list, ARRAY_SIZE(radeon_pm_info_list));