radeon_pm.c 24.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Rafał Miłecki <zajec5@gmail.com>
21
 *          Alex Deucher <alexdeucher@gmail.com>
22 23 24
 */
#include "drmP.h"
#include "radeon.h"
25
#include "avivod.h"
26 27 28 29
#ifdef CONFIG_ACPI
#include <linux/acpi.h>
#endif
#include <linux/power_supply.h>
30

31 32
#define RADEON_IDLE_LOOP_MS 100
#define RADEON_RECLOCK_DELAY_MS 200
33
#define RADEON_WAIT_VBLANK_TIMEOUT 200
34
#define RADEON_WAIT_IDLE_TIMEOUT 200
35

36 37 38 39 40 41 42 43
static const char *radeon_pm_state_type_name[5] = {
	"Default",
	"Powersave",
	"Battery",
	"Balanced",
	"Performance",
};

44
static void radeon_dynpm_idle_work_handler(struct work_struct *work);
45
static int radeon_debugfs_pm_init(struct radeon_device *rdev);
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
static bool radeon_pm_in_vbl(struct radeon_device *rdev);
static bool radeon_pm_debug_check_in_vbl(struct radeon_device *rdev, bool finish);
static void radeon_pm_update_profile(struct radeon_device *rdev);
static void radeon_pm_set_clocks(struct radeon_device *rdev);

#define ACPI_AC_CLASS           "ac_adapter"

#ifdef CONFIG_ACPI
static int radeon_acpi_event(struct notifier_block *nb,
			     unsigned long val,
			     void *data)
{
	struct radeon_device *rdev = container_of(nb, struct radeon_device, acpi_nb);
	struct acpi_bus_event *entry = (struct acpi_bus_event *)data;

	if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) {
		if (power_supply_is_system_supplied() > 0)
63
			DRM_DEBUG("pm: AC\n");
64
		else
65
			DRM_DEBUG("pm: DC\n");
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

		if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
			if (rdev->pm.profile == PM_PROFILE_AUTO) {
				mutex_lock(&rdev->pm.mutex);
				radeon_pm_update_profile(rdev);
				radeon_pm_set_clocks(rdev);
				mutex_unlock(&rdev->pm.mutex);
			}
		}
	}

	return NOTIFY_OK;
}
#endif

static void radeon_pm_update_profile(struct radeon_device *rdev)
{
	switch (rdev->pm.profile) {
	case PM_PROFILE_DEFAULT:
		rdev->pm.profile_index = PM_PROFILE_DEFAULT_IDX;
		break;
	case PM_PROFILE_AUTO:
		if (power_supply_is_system_supplied() > 0) {
			if (rdev->pm.active_crtc_count > 1)
				rdev->pm.profile_index = PM_PROFILE_HIGH_MH_IDX;
			else
				rdev->pm.profile_index = PM_PROFILE_HIGH_SH_IDX;
		} else {
			if (rdev->pm.active_crtc_count > 1)
95
				rdev->pm.profile_index = PM_PROFILE_MID_MH_IDX;
96
			else
97
				rdev->pm.profile_index = PM_PROFILE_MID_SH_IDX;
98 99 100 101 102 103 104 105
		}
		break;
	case PM_PROFILE_LOW:
		if (rdev->pm.active_crtc_count > 1)
			rdev->pm.profile_index = PM_PROFILE_LOW_MH_IDX;
		else
			rdev->pm.profile_index = PM_PROFILE_LOW_SH_IDX;
		break;
106 107 108 109 110 111
	case PM_PROFILE_MID:
		if (rdev->pm.active_crtc_count > 1)
			rdev->pm.profile_index = PM_PROFILE_MID_MH_IDX;
		else
			rdev->pm.profile_index = PM_PROFILE_MID_SH_IDX;
		break;
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
	case PM_PROFILE_HIGH:
		if (rdev->pm.active_crtc_count > 1)
			rdev->pm.profile_index = PM_PROFILE_HIGH_MH_IDX;
		else
			rdev->pm.profile_index = PM_PROFILE_HIGH_SH_IDX;
		break;
	}

	if (rdev->pm.active_crtc_count == 0) {
		rdev->pm.requested_power_state_index =
			rdev->pm.profiles[rdev->pm.profile_index].dpms_off_ps_idx;
		rdev->pm.requested_clock_mode_index =
			rdev->pm.profiles[rdev->pm.profile_index].dpms_off_cm_idx;
	} else {
		rdev->pm.requested_power_state_index =
			rdev->pm.profiles[rdev->pm.profile_index].dpms_on_ps_idx;
		rdev->pm.requested_clock_mode_index =
			rdev->pm.profiles[rdev->pm.profile_index].dpms_on_cm_idx;
	}
}
132

133 134 135 136 137 138 139 140 141 142 143 144 145
static void radeon_unmap_vram_bos(struct radeon_device *rdev)
{
	struct radeon_bo *bo, *n;

	if (list_empty(&rdev->gem.objects))
		return;

	list_for_each_entry_safe(bo, n, &rdev->gem.objects, list) {
		if (bo->tbo.mem.mem_type == TTM_PL_VRAM)
			ttm_bo_unmap_virtual(&bo->tbo);
	}
}

146
static void radeon_sync_with_vblank(struct radeon_device *rdev)
147
{
148 149 150 151 152 153 154 155 156 157 158
	if (rdev->pm.active_crtcs) {
		rdev->pm.vblank_sync = false;
		wait_event_timeout(
			rdev->irq.vblank_queue, rdev->pm.vblank_sync,
			msecs_to_jiffies(RADEON_WAIT_VBLANK_TIMEOUT));
	}
}

static void radeon_set_power_state(struct radeon_device *rdev)
{
	u32 sclk, mclk;
159
	bool misc_after = false;
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175

	if ((rdev->pm.requested_clock_mode_index == rdev->pm.current_clock_mode_index) &&
	    (rdev->pm.requested_power_state_index == rdev->pm.current_power_state_index))
		return;

	if (radeon_gui_idle(rdev)) {
		sclk = rdev->pm.power_state[rdev->pm.requested_power_state_index].
			clock_info[rdev->pm.requested_clock_mode_index].sclk;
		if (sclk > rdev->clock.default_sclk)
			sclk = rdev->clock.default_sclk;

		mclk = rdev->pm.power_state[rdev->pm.requested_power_state_index].
			clock_info[rdev->pm.requested_clock_mode_index].mclk;
		if (mclk > rdev->clock.default_mclk)
			mclk = rdev->clock.default_mclk;

176 177 178
		/* upvolt before raising clocks, downvolt after lowering clocks */
		if (sclk < rdev->pm.current_sclk)
			misc_after = true;
179

180
		radeon_sync_with_vblank(rdev);
181

182
		if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
183 184
			if (!radeon_pm_in_vbl(rdev))
				return;
185
		}
186

187
		radeon_pm_prepare(rdev);
188

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
		if (!misc_after)
			/* voltage, pcie lanes, etc.*/
			radeon_pm_misc(rdev);

		/* set engine clock */
		if (sclk != rdev->pm.current_sclk) {
			radeon_pm_debug_check_in_vbl(rdev, false);
			radeon_set_engine_clock(rdev, sclk);
			radeon_pm_debug_check_in_vbl(rdev, true);
			rdev->pm.current_sclk = sclk;
			DRM_DEBUG("Setting: e: %d\n", sclk);
		}

		/* set memory clock */
		if (rdev->asic->set_memory_clock && (mclk != rdev->pm.current_mclk)) {
			radeon_pm_debug_check_in_vbl(rdev, false);
			radeon_set_memory_clock(rdev, mclk);
			radeon_pm_debug_check_in_vbl(rdev, true);
			rdev->pm.current_mclk = mclk;
			DRM_DEBUG("Setting: m: %d\n", mclk);
209
		}
Matthew Garrett's avatar
Matthew Garrett committed
210

211 212 213 214 215 216
		if (misc_after)
			/* voltage, pcie lanes, etc.*/
			radeon_pm_misc(rdev);

		radeon_pm_finish(rdev);

217 218 219
		rdev->pm.current_power_state_index = rdev->pm.requested_power_state_index;
		rdev->pm.current_clock_mode_index = rdev->pm.requested_clock_mode_index;
	} else
220
		DRM_DEBUG("pm: GUI not idle!!!\n");
221 222 223 224 225
}

static void radeon_pm_set_clocks(struct radeon_device *rdev)
{
	int i;
226

227 228
	mutex_lock(&rdev->ddev->struct_mutex);
	mutex_lock(&rdev->vram_mutex);
229
	mutex_lock(&rdev->cp.mutex);
230 231 232

	/* gui idle int has issues on older chips it seems */
	if (rdev->family >= CHIP_R600) {
233 234 235 236 237 238 239 240 241 242 243
		if (rdev->irq.installed) {
			/* wait for GPU idle */
			rdev->pm.gui_idle = false;
			rdev->irq.gui_idle = true;
			radeon_irq_set(rdev);
			wait_event_interruptible_timeout(
				rdev->irq.idle_queue, rdev->pm.gui_idle,
				msecs_to_jiffies(RADEON_WAIT_IDLE_TIMEOUT));
			rdev->irq.gui_idle = false;
			radeon_irq_set(rdev);
		}
244
	} else {
245 246 247 248 249 250 251 252 253
		if (rdev->cp.ready) {
			struct radeon_fence *fence;
			radeon_ring_alloc(rdev, 64);
			radeon_fence_create(rdev, &fence);
			radeon_fence_emit(rdev, fence);
			radeon_ring_commit(rdev);
			radeon_fence_wait(fence, false);
			radeon_fence_unref(&fence);
		}
254
	}
255 256
	radeon_unmap_vram_bos(rdev);

257
	if (rdev->irq.installed) {
Matthew Garrett's avatar
Matthew Garrett committed
258 259 260 261 262 263 264
		for (i = 0; i < rdev->num_crtc; i++) {
			if (rdev->pm.active_crtcs & (1 << i)) {
				rdev->pm.req_vblank |= (1 << i);
				drm_vblank_get(rdev->ddev, i);
			}
		}
	}
Alex Deucher's avatar
Alex Deucher committed
265

266
	radeon_set_power_state(rdev);
Matthew Garrett's avatar
Matthew Garrett committed
267

268
	if (rdev->irq.installed) {
Matthew Garrett's avatar
Matthew Garrett committed
269 270 271 272 273 274 275
		for (i = 0; i < rdev->num_crtc; i++) {
			if (rdev->pm.req_vblank & (1 << i)) {
				rdev->pm.req_vblank &= ~(1 << i);
				drm_vblank_put(rdev->ddev, i);
			}
		}
	}
276

277 278 279 280 281
	/* update display watermarks based on new power state */
	radeon_update_bandwidth_info(rdev);
	if (rdev->pm.active_crtc_count)
		radeon_bandwidth_update(rdev);

282
	rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
Matthew Garrett's avatar
Matthew Garrett committed
283

284
	mutex_unlock(&rdev->cp.mutex);
285 286
	mutex_unlock(&rdev->vram_mutex);
	mutex_unlock(&rdev->ddev->struct_mutex);
287 288
}

289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
static void radeon_pm_print_states(struct radeon_device *rdev)
{
	int i, j;
	struct radeon_power_state *power_state;
	struct radeon_pm_clock_info *clock_info;

	DRM_DEBUG("%d Power State(s)\n", rdev->pm.num_power_states);
	for (i = 0; i < rdev->pm.num_power_states; i++) {
		power_state = &rdev->pm.power_state[i];
		DRM_DEBUG("State %d: %s\n", i,
			radeon_pm_state_type_name[power_state->type]);
		if (i == rdev->pm.default_power_state_index)
			DRM_DEBUG("\tDefault");
		if ((rdev->flags & RADEON_IS_PCIE) && !(rdev->flags & RADEON_IS_IGP))
			DRM_DEBUG("\t%d PCIE Lanes\n", power_state->pcie_lanes);
		if (power_state->flags & RADEON_PM_STATE_SINGLE_DISPLAY_ONLY)
			DRM_DEBUG("\tSingle display only\n");
		DRM_DEBUG("\t%d Clock Mode(s)\n", power_state->num_clock_modes);
		for (j = 0; j < power_state->num_clock_modes; j++) {
			clock_info = &(power_state->clock_info[j]);
			if (rdev->flags & RADEON_IS_IGP)
				DRM_DEBUG("\t\t%d e: %d%s\n",
					j,
					clock_info->sclk * 10,
					clock_info->flags & RADEON_PM_MODE_NO_DISPLAY ? "\tNo display only" : "");
			else
				DRM_DEBUG("\t\t%d e: %d\tm: %d\tv: %d%s\n",
					j,
					clock_info->sclk * 10,
					clock_info->mclk * 10,
					clock_info->voltage.voltage,
					clock_info->flags & RADEON_PM_MODE_NO_DISPLAY ? "\tNo display only" : "");
		}
	}
}

325 326 327
static ssize_t radeon_get_pm_profile(struct device *dev,
				     struct device_attribute *attr,
				     char *buf)
328 329 330
{
	struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
	struct radeon_device *rdev = ddev->dev_private;
331
	int cp = rdev->pm.profile;
332

333 334 335
	return snprintf(buf, PAGE_SIZE, "%s\n",
			(cp == PM_PROFILE_AUTO) ? "auto" :
			(cp == PM_PROFILE_LOW) ? "low" :
336
			(cp == PM_PROFILE_MID) ? "mid" :
337
			(cp == PM_PROFILE_HIGH) ? "high" : "default");
338 339
}

340 341 342 343
static ssize_t radeon_set_pm_profile(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf,
				     size_t count)
344 345 346 347 348
{
	struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
	struct radeon_device *rdev = ddev->dev_private;

	mutex_lock(&rdev->pm.mutex);
349 350 351 352 353 354 355
	if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
		if (strncmp("default", buf, strlen("default")) == 0)
			rdev->pm.profile = PM_PROFILE_DEFAULT;
		else if (strncmp("auto", buf, strlen("auto")) == 0)
			rdev->pm.profile = PM_PROFILE_AUTO;
		else if (strncmp("low", buf, strlen("low")) == 0)
			rdev->pm.profile = PM_PROFILE_LOW;
356 357
		else if (strncmp("mid", buf, strlen("mid")) == 0)
			rdev->pm.profile = PM_PROFILE_MID;
358 359 360 361 362
		else if (strncmp("high", buf, strlen("high")) == 0)
			rdev->pm.profile = PM_PROFILE_HIGH;
		else {
			DRM_ERROR("invalid power profile!\n");
			goto fail;
363
		}
364 365 366 367
		radeon_pm_update_profile(rdev);
		radeon_pm_set_clocks(rdev);
	}
fail:
368 369 370 371 372
	mutex_unlock(&rdev->pm.mutex);

	return count;
}

373 374 375
static ssize_t radeon_get_pm_method(struct device *dev,
				    struct device_attribute *attr,
				    char *buf)
376 377 378
{
	struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
	struct radeon_device *rdev = ddev->dev_private;
379
	int pm = rdev->pm.pm_method;
380 381

	return snprintf(buf, PAGE_SIZE, "%s\n",
382
			(pm == PM_METHOD_DYNPM) ? "dynpm" : "profile");
383 384
}

385 386 387 388
static ssize_t radeon_set_pm_method(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf,
				    size_t count)
389 390 391 392
{
	struct drm_device *ddev = pci_get_drvdata(to_pci_dev(dev));
	struct radeon_device *rdev = ddev->dev_private;

393 394

	if (strncmp("dynpm", buf, strlen("dynpm")) == 0) {
395
		mutex_lock(&rdev->pm.mutex);
396 397 398
		rdev->pm.pm_method = PM_METHOD_DYNPM;
		rdev->pm.dynpm_state = DYNPM_STATE_PAUSED;
		rdev->pm.dynpm_planned_action = DYNPM_ACTION_DEFAULT;
399
		mutex_unlock(&rdev->pm.mutex);
400
	} else if (strncmp("profile", buf, strlen("profile")) == 0) {
401 402
		bool flush_wq = false;

403
		mutex_lock(&rdev->pm.mutex);
404 405 406 407
		if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
			cancel_delayed_work(&rdev->pm.dynpm_idle_work);
			flush_wq = true;
		}
408 409 410
		/* disable dynpm */
		rdev->pm.dynpm_state = DYNPM_STATE_DISABLED;
		rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
411
		rdev->pm.pm_method = PM_METHOD_PROFILE;
412
		mutex_unlock(&rdev->pm.mutex);
413 414
		if (flush_wq)
			flush_workqueue(rdev->wq);
415 416 417 418 419 420
	} else {
		DRM_ERROR("invalid power method!\n");
		goto fail;
	}
	radeon_pm_compute_clocks(rdev);
fail:
421 422 423
	return count;
}

424 425
static DEVICE_ATTR(power_profile, S_IRUGO | S_IWUSR, radeon_get_pm_profile, radeon_set_pm_profile);
static DEVICE_ATTR(power_method, S_IRUGO | S_IWUSR, radeon_get_pm_method, radeon_set_pm_method);
426

427
void radeon_pm_suspend(struct radeon_device *rdev)
428
{
429 430
	bool flush_wq = false;

431
	mutex_lock(&rdev->pm.mutex);
432 433 434 435 436 437
	if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
		cancel_delayed_work(&rdev->pm.dynpm_idle_work);
		if (rdev->pm.dynpm_state == DYNPM_STATE_ACTIVE)
			rdev->pm.dynpm_state = DYNPM_STATE_SUSPENDED;
		flush_wq = true;
	}
438
	mutex_unlock(&rdev->pm.mutex);
439 440
	if (flush_wq)
		flush_workqueue(rdev->wq);
441 442
}

443
void radeon_pm_resume(struct radeon_device *rdev)
444
{
Alex Deucher's avatar
Alex Deucher committed
445 446 447 448 449 450
	/* asic init will reset the default power state */
	mutex_lock(&rdev->pm.mutex);
	rdev->pm.current_power_state_index = rdev->pm.default_power_state_index;
	rdev->pm.current_clock_mode_index = 0;
	rdev->pm.current_sclk = rdev->clock.default_sclk;
	rdev->pm.current_mclk = rdev->clock.default_mclk;
451
	rdev->pm.current_vddc = rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.voltage;
452 453 454 455 456 457
	if (rdev->pm.pm_method == PM_METHOD_DYNPM
	    && rdev->pm.dynpm_state == DYNPM_STATE_SUSPENDED) {
		rdev->pm.dynpm_state = DYNPM_STATE_ACTIVE;
		queue_delayed_work(rdev->wq, &rdev->pm.dynpm_idle_work,
					msecs_to_jiffies(RADEON_IDLE_LOOP_MS));
	}
Alex Deucher's avatar
Alex Deucher committed
458
	mutex_unlock(&rdev->pm.mutex);
459
	radeon_pm_compute_clocks(rdev);
460 461
}

462 463
int radeon_pm_init(struct radeon_device *rdev)
{
464
	int ret;
465 466
	/* default to profile method */
	rdev->pm.pm_method = PM_METHOD_PROFILE;
Alex Deucher's avatar
Alex Deucher committed
467
	rdev->pm.profile = PM_PROFILE_DEFAULT;
468 469 470 471
	rdev->pm.dynpm_state = DYNPM_STATE_DISABLED;
	rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
	rdev->pm.dynpm_can_upclock = true;
	rdev->pm.dynpm_can_downclock = true;
Alex Deucher's avatar
Alex Deucher committed
472 473
	rdev->pm.current_sclk = rdev->clock.default_sclk;
	rdev->pm.current_mclk = rdev->clock.default_mclk;
474

475 476 477 478 479
	if (rdev->bios) {
		if (rdev->is_atom_bios)
			radeon_atombios_get_power_modes(rdev);
		else
			radeon_combios_get_power_modes(rdev);
480
		radeon_pm_print_states(rdev);
481
		radeon_pm_init_profile(rdev);
482 483
	}

484 485
	if (rdev->pm.num_power_states > 1) {
		/* where's the best place to put these? */
486 487 488 489 490 491
		ret = device_create_file(rdev->dev, &dev_attr_power_profile);
		if (ret)
			DRM_ERROR("failed to create device file for power profile\n");
		ret = device_create_file(rdev->dev, &dev_attr_power_method);
		if (ret)
			DRM_ERROR("failed to create device file for power method\n");
492

493 494 495 496 497
#ifdef CONFIG_ACPI
		rdev->acpi_nb.notifier_call = radeon_acpi_event;
		register_acpi_notifier(&rdev->acpi_nb);
#endif
		INIT_DELAYED_WORK(&rdev->pm.dynpm_idle_work, radeon_dynpm_idle_work_handler);
498

499 500 501
		if (radeon_debugfs_pm_init(rdev)) {
			DRM_ERROR("Failed to register debugfs file for PM!\n");
		}
502

503 504
		DRM_INFO("radeon: power management initialized\n");
	}
505

506 507 508
	return 0;
}

509 510
void radeon_pm_fini(struct radeon_device *rdev)
{
511
	if (rdev->pm.num_power_states > 1) {
512 513
		bool flush_wq = false;

514
		mutex_lock(&rdev->pm.mutex);
515 516 517 518 519 520
		if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
			rdev->pm.profile = PM_PROFILE_DEFAULT;
			radeon_pm_update_profile(rdev);
			radeon_pm_set_clocks(rdev);
		} else if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
			/* cancel work */
521 522
			cancel_delayed_work(&rdev->pm.dynpm_idle_work);
			flush_wq = true;
523 524 525 526 527
			/* reset default clocks */
			rdev->pm.dynpm_state = DYNPM_STATE_DISABLED;
			rdev->pm.dynpm_planned_action = DYNPM_ACTION_DEFAULT;
			radeon_pm_set_clocks(rdev);
		}
528
		mutex_unlock(&rdev->pm.mutex);
529 530
		if (flush_wq)
			flush_workqueue(rdev->wq);
531

532 533 534 535 536 537
		device_remove_file(rdev->dev, &dev_attr_power_profile);
		device_remove_file(rdev->dev, &dev_attr_power_method);
#ifdef CONFIG_ACPI
		unregister_acpi_notifier(&rdev->acpi_nb);
#endif
	}
538

539 540 541 542
	if (rdev->pm.i2c_bus)
		radeon_i2c_destroy(rdev->pm.i2c_bus);
}

543 544 545
void radeon_pm_compute_clocks(struct radeon_device *rdev)
{
	struct drm_device *ddev = rdev->ddev;
546
	struct drm_crtc *crtc;
547 548
	struct radeon_crtc *radeon_crtc;

549 550 551
	if (rdev->pm.num_power_states < 2)
		return;

552 553 554
	mutex_lock(&rdev->pm.mutex);

	rdev->pm.active_crtcs = 0;
555 556 557 558 559
	rdev->pm.active_crtc_count = 0;
	list_for_each_entry(crtc,
		&ddev->mode_config.crtc_list, head) {
		radeon_crtc = to_radeon_crtc(crtc);
		if (radeon_crtc->enabled) {
560
			rdev->pm.active_crtcs |= (1 << radeon_crtc->crtc_id);
561
			rdev->pm.active_crtc_count++;
562 563 564
		}
	}

565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
	if (rdev->pm.pm_method == PM_METHOD_PROFILE) {
		radeon_pm_update_profile(rdev);
		radeon_pm_set_clocks(rdev);
	} else if (rdev->pm.pm_method == PM_METHOD_DYNPM) {
		if (rdev->pm.dynpm_state != DYNPM_STATE_DISABLED) {
			if (rdev->pm.active_crtc_count > 1) {
				if (rdev->pm.dynpm_state == DYNPM_STATE_ACTIVE) {
					cancel_delayed_work(&rdev->pm.dynpm_idle_work);

					rdev->pm.dynpm_state = DYNPM_STATE_PAUSED;
					rdev->pm.dynpm_planned_action = DYNPM_ACTION_DEFAULT;
					radeon_pm_get_dynpm_state(rdev);
					radeon_pm_set_clocks(rdev);

					DRM_DEBUG("radeon: dynamic power management deactivated\n");
				}
			} else if (rdev->pm.active_crtc_count == 1) {
				/* TODO: Increase clocks if needed for current mode */

				if (rdev->pm.dynpm_state == DYNPM_STATE_MINIMUM) {
					rdev->pm.dynpm_state = DYNPM_STATE_ACTIVE;
					rdev->pm.dynpm_planned_action = DYNPM_ACTION_UPCLOCK;
					radeon_pm_get_dynpm_state(rdev);
					radeon_pm_set_clocks(rdev);

					queue_delayed_work(rdev->wq, &rdev->pm.dynpm_idle_work,
							   msecs_to_jiffies(RADEON_IDLE_LOOP_MS));
				} else if (rdev->pm.dynpm_state == DYNPM_STATE_PAUSED) {
					rdev->pm.dynpm_state = DYNPM_STATE_ACTIVE;
					queue_delayed_work(rdev->wq, &rdev->pm.dynpm_idle_work,
							   msecs_to_jiffies(RADEON_IDLE_LOOP_MS));
					DRM_DEBUG("radeon: dynamic power management activated\n");
				}
			} else { /* count == 0 */
				if (rdev->pm.dynpm_state != DYNPM_STATE_MINIMUM) {
					cancel_delayed_work(&rdev->pm.dynpm_idle_work);

					rdev->pm.dynpm_state = DYNPM_STATE_MINIMUM;
					rdev->pm.dynpm_planned_action = DYNPM_ACTION_MINIMUM;
					radeon_pm_get_dynpm_state(rdev);
					radeon_pm_set_clocks(rdev);
				}
			}
608 609
		}
	}
610 611

	mutex_unlock(&rdev->pm.mutex);
612 613
}

614
static bool radeon_pm_in_vbl(struct radeon_device *rdev)
615
{
Alex Deucher's avatar
Alex Deucher committed
616
	u32 stat_crtc = 0, vbl = 0, position = 0;
617 618
	bool in_vbl = true;

619 620
	if (ASIC_IS_DCE4(rdev)) {
		if (rdev->pm.active_crtcs & (1 << 0)) {
Alex Deucher's avatar
Alex Deucher committed
621 622 623 624
			vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
				     EVERGREEN_CRTC0_REGISTER_OFFSET) & 0xfff;
			position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
					  EVERGREEN_CRTC0_REGISTER_OFFSET) & 0xfff;
625 626
		}
		if (rdev->pm.active_crtcs & (1 << 1)) {
Alex Deucher's avatar
Alex Deucher committed
627 628 629 630
			vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
				     EVERGREEN_CRTC1_REGISTER_OFFSET) & 0xfff;
			position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
					  EVERGREEN_CRTC1_REGISTER_OFFSET) & 0xfff;
631 632
		}
		if (rdev->pm.active_crtcs & (1 << 2)) {
Alex Deucher's avatar
Alex Deucher committed
633 634 635 636
			vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
				     EVERGREEN_CRTC2_REGISTER_OFFSET) & 0xfff;
			position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
					  EVERGREEN_CRTC2_REGISTER_OFFSET) & 0xfff;
637 638
		}
		if (rdev->pm.active_crtcs & (1 << 3)) {
Alex Deucher's avatar
Alex Deucher committed
639 640 641 642
			vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
				     EVERGREEN_CRTC3_REGISTER_OFFSET) & 0xfff;
			position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
					  EVERGREEN_CRTC3_REGISTER_OFFSET) & 0xfff;
643 644
		}
		if (rdev->pm.active_crtcs & (1 << 4)) {
Alex Deucher's avatar
Alex Deucher committed
645 646 647 648
			vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
				     EVERGREEN_CRTC4_REGISTER_OFFSET) & 0xfff;
			position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
					  EVERGREEN_CRTC4_REGISTER_OFFSET) & 0xfff;
649 650
		}
		if (rdev->pm.active_crtcs & (1 << 5)) {
Alex Deucher's avatar
Alex Deucher committed
651 652 653 654
			vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
				     EVERGREEN_CRTC5_REGISTER_OFFSET) & 0xfff;
			position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
					  EVERGREEN_CRTC5_REGISTER_OFFSET) & 0xfff;
655 656 657
		}
	} else if (ASIC_IS_AVIVO(rdev)) {
		if (rdev->pm.active_crtcs & (1 << 0)) {
Alex Deucher's avatar
Alex Deucher committed
658 659
			vbl = RREG32(AVIVO_D1CRTC_V_BLANK_START_END) & 0xfff;
			position = RREG32(AVIVO_D1CRTC_STATUS_POSITION) & 0xfff;
660 661
		}
		if (rdev->pm.active_crtcs & (1 << 1)) {
Alex Deucher's avatar
Alex Deucher committed
662 663
			vbl = RREG32(AVIVO_D2CRTC_V_BLANK_START_END) & 0xfff;
			position = RREG32(AVIVO_D2CRTC_STATUS_POSITION) & 0xfff;
664
		}
Alex Deucher's avatar
Alex Deucher committed
665 666
		if (position < vbl && position > 1)
			in_vbl = false;
667
	} else {
668
		if (rdev->pm.active_crtcs & (1 << 0)) {
669 670
			stat_crtc = RREG32(RADEON_CRTC_STATUS);
			if (!(stat_crtc & 1))
671 672 673
				in_vbl = false;
		}
		if (rdev->pm.active_crtcs & (1 << 1)) {
674 675
			stat_crtc = RREG32(RADEON_CRTC2_STATUS);
			if (!(stat_crtc & 1))
676 677 678
				in_vbl = false;
		}
	}
679

Alex Deucher's avatar
Alex Deucher committed
680 681 682
	if (position < vbl && position > 1)
		in_vbl = false;

683 684 685
	return in_vbl;
}

686
static bool radeon_pm_debug_check_in_vbl(struct radeon_device *rdev, bool finish)
687 688 689 690
{
	u32 stat_crtc = 0;
	bool in_vbl = radeon_pm_in_vbl(rdev);

691
	if (in_vbl == false)
692
		DRM_DEBUG("not in vbl for pm change %08x at %s\n", stat_crtc,
693
			 finish ? "exit" : "entry");
694 695
	return in_vbl;
}
696

697
static void radeon_dynpm_idle_work_handler(struct work_struct *work)
698 699
{
	struct radeon_device *rdev;
700
	int resched;
701
	rdev = container_of(work, struct radeon_device,
702
				pm.dynpm_idle_work.work);
703

704
	resched = ttm_bo_lock_delayed_workqueue(&rdev->mman.bdev);
705
	mutex_lock(&rdev->pm.mutex);
706
	if (rdev->pm.dynpm_state == DYNPM_STATE_ACTIVE) {
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
		unsigned long irq_flags;
		int not_processed = 0;

		read_lock_irqsave(&rdev->fence_drv.lock, irq_flags);
		if (!list_empty(&rdev->fence_drv.emited)) {
			struct list_head *ptr;
			list_for_each(ptr, &rdev->fence_drv.emited) {
				/* count up to 3, that's enought info */
				if (++not_processed >= 3)
					break;
			}
		}
		read_unlock_irqrestore(&rdev->fence_drv.lock, irq_flags);

		if (not_processed >= 3) { /* should upclock */
722 723 724 725 726 727 728
			if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_DOWNCLOCK) {
				rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
			} else if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_NONE &&
				   rdev->pm.dynpm_can_upclock) {
				rdev->pm.dynpm_planned_action =
					DYNPM_ACTION_UPCLOCK;
				rdev->pm.dynpm_action_timeout = jiffies +
729 730 731
				msecs_to_jiffies(RADEON_RECLOCK_DELAY_MS);
			}
		} else if (not_processed == 0) { /* should downclock */
732 733 734 735 736 737 738
			if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_UPCLOCK) {
				rdev->pm.dynpm_planned_action = DYNPM_ACTION_NONE;
			} else if (rdev->pm.dynpm_planned_action == DYNPM_ACTION_NONE &&
				   rdev->pm.dynpm_can_downclock) {
				rdev->pm.dynpm_planned_action =
					DYNPM_ACTION_DOWNCLOCK;
				rdev->pm.dynpm_action_timeout = jiffies +
739 740 741 742
				msecs_to_jiffies(RADEON_RECLOCK_DELAY_MS);
			}
		}

743 744 745
		/* Note, radeon_pm_set_clocks is called with static_switch set
		 * to false since we want to wait for vbl to avoid flicker.
		 */
746 747 748 749
		if (rdev->pm.dynpm_planned_action != DYNPM_ACTION_NONE &&
		    jiffies > rdev->pm.dynpm_action_timeout) {
			radeon_pm_get_dynpm_state(rdev);
			radeon_pm_set_clocks(rdev);
750
		}
751 752 753

		queue_delayed_work(rdev->wq, &rdev->pm.dynpm_idle_work,
					msecs_to_jiffies(RADEON_IDLE_LOOP_MS));
754 755
	}
	mutex_unlock(&rdev->pm.mutex);
756
	ttm_bo_unlock_delayed_workqueue(&rdev->mman.bdev, resched);
757 758
}

759 760 761 762 763 764 765 766 767 768 769
/*
 * Debugfs info
 */
#if defined(CONFIG_DEBUG_FS)

static int radeon_debugfs_pm_info(struct seq_file *m, void *data)
{
	struct drm_info_node *node = (struct drm_info_node *) m->private;
	struct drm_device *dev = node->minor->dev;
	struct radeon_device *rdev = dev->dev_private;

770 771 772 773 774
	seq_printf(m, "default engine clock: %u0 kHz\n", rdev->clock.default_sclk);
	seq_printf(m, "current engine clock: %u0 kHz\n", radeon_get_engine_clock(rdev));
	seq_printf(m, "default memory clock: %u0 kHz\n", rdev->clock.default_mclk);
	if (rdev->asic->get_memory_clock)
		seq_printf(m, "current memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev));
775 776
	if (rdev->pm.current_vddc)
		seq_printf(m, "voltage: %u mV\n", rdev->pm.current_vddc);
777 778
	if (rdev->asic->get_pcie_lanes)
		seq_printf(m, "PCIE lanes: %d\n", radeon_get_pcie_lanes(rdev));
779 780 781 782 783 784 785 786 787

	return 0;
}

static struct drm_info_list radeon_pm_info_list[] = {
	{"radeon_pm_info", radeon_debugfs_pm_info, 0, NULL},
};
#endif

788
static int radeon_debugfs_pm_init(struct radeon_device *rdev)
789 790 791 792 793 794 795
{
#if defined(CONFIG_DEBUG_FS)
	return radeon_debugfs_add_files(rdev, radeon_pm_info_list, ARRAY_SIZE(radeon_pm_info_list));
#else
	return 0;
#endif
}