WebSVN – Kolibri OS – Blame – /drivers/video/drm/i915/intel_pm.c

Rev	Author	Line No.	Line
3031	serge	1	/*
		2	* Copyright © 2012 Intel Corporation
		3	*
		4	* Permission is hereby granted, free of charge, to any person obtaining a
		5	* copy of this software and associated documentation files (the "Software"),
		6	* to deal in the Software without restriction, including without limitation
		7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		8	* and/or sell copies of the Software, and to permit persons to whom the
		9	* Software is furnished to do so, subject to the following conditions:
		10	*
		11	* The above copyright notice and this permission notice (including the next
		12	* paragraph) shall be included in all copies or substantial portions of the
		13	* Software.
		14	*
		15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
		20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
		21	* IN THE SOFTWARE.
		22	*
		23	* Authors:
		24	* Eugeni Dodonov
		25	*
		26	*/
		27
		28	#define iowrite32(v, addr) writel((v), (addr))
		29	#define ioread32(addr) readl(addr)
		30
		31	//#include
		32	#include "i915_drv.h"
		33	#include "intel_drv.h"
		34	#include
		35	//#include "../../../platform/x86/intel_ips.h"
		36	#include
		37
		38	#define FORCEWAKE_ACK_TIMEOUT_MS 2
		39
		40	#define assert_spin_locked(x)
		41
		42	void getrawmonotonic(struct timespec *ts);
		43	void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec);
		44
		45	static inline struct timespec timespec_sub(struct timespec lhs,
		46	struct timespec rhs)
		47	{
		48	struct timespec ts_delta;
		49	set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
		50	lhs.tv_nsec - rhs.tv_nsec);
		51	return ts_delta;
		52	}
		53
		54
		55	/* FBC, or Frame Buffer Compression, is a technique employed to compress the
		56	* framebuffer contents in-memory, aiming at reducing the required bandwidth
		57	* during in-memory transfers and, therefore, reduce the power packet.
		58	*
		59	* The benefits of FBC are mostly visible with solid backgrounds and
		60	* variation-less patterns.
		61	*
		62	* FBC-related functionality can be enabled by the means of the
		63	* i915.i915_enable_fbc parameter
		64	*/
		65
		66	static void i8xx_disable_fbc(struct drm_device *dev)
		67	{
		68	struct drm_i915_private *dev_priv = dev->dev_private;
		69	u32 fbc_ctl;
		70
		71	/* Disable compression */
		72	fbc_ctl = I915_READ(FBC_CONTROL);
		73	if ((fbc_ctl & FBC_CTL_EN) == 0)
		74	return;
		75
		76	fbc_ctl &= ~FBC_CTL_EN;
		77	I915_WRITE(FBC_CONTROL, fbc_ctl);
		78
		79	/* Wait for compressing bit to clear */
		80	if (wait_for((I915_READ(FBC_STATUS) & FBC_STAT_COMPRESSING) == 0, 10)) {
		81	DRM_DEBUG_KMS("FBC idle timed out\n");
		82	return;
		83	}
		84
		85	DRM_DEBUG_KMS("disabled FBC\n");
		86	}
		87
		88	static void i8xx_enable_fbc(struct drm_crtc *crtc, unsigned long interval)
		89	{
		90	struct drm_device *dev = crtc->dev;
		91	struct drm_i915_private *dev_priv = dev->dev_private;
		92	struct drm_framebuffer *fb = crtc->fb;
		93	struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
		94	struct drm_i915_gem_object *obj = intel_fb->obj;
		95	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
		96	int cfb_pitch;
		97	int plane, i;
		98	u32 fbc_ctl, fbc_ctl2;
		99
		100	cfb_pitch = dev_priv->cfb_size / FBC_LL_SIZE;
		101	if (fb->pitches[0] < cfb_pitch)
		102	cfb_pitch = fb->pitches[0];
		103
		104	/* FBC_CTL wants 64B units */
		105	cfb_pitch = (cfb_pitch / 64) - 1;
		106	plane = intel_crtc->plane == 0 ? FBC_CTL_PLANEA : FBC_CTL_PLANEB;
		107
		108	/* Clear old tags */
		109	for (i = 0; i < (FBC_LL_SIZE / 32) + 1; i++)
		110	I915_WRITE(FBC_TAG + (i * 4), 0);
		111
		112	/* Set it up... */
		113	fbc_ctl2 = FBC_CTL_FENCE_DBL \| FBC_CTL_IDLE_IMM \| FBC_CTL_CPU_FENCE;
		114	fbc_ctl2 \|= plane;
		115	I915_WRITE(FBC_CONTROL2, fbc_ctl2);
		116	I915_WRITE(FBC_FENCE_OFF, crtc->y);
		117
		118	/* enable it... */
		119	fbc_ctl = FBC_CTL_EN \| FBC_CTL_PERIODIC;
		120	if (IS_I945GM(dev))
		121	fbc_ctl \|= FBC_CTL_C3_IDLE; /* 945 needs special SR handling */
		122	fbc_ctl \|= (cfb_pitch & 0xff) << FBC_CTL_STRIDE_SHIFT;
		123	fbc_ctl \|= (interval & 0x2fff) << FBC_CTL_INTERVAL_SHIFT;
		124	fbc_ctl \|= obj->fence_reg;
		125	I915_WRITE(FBC_CONTROL, fbc_ctl);
		126
		127	DRM_DEBUG_KMS("enabled FBC, pitch %d, yoff %d, plane %d, ",
		128	cfb_pitch, crtc->y, intel_crtc->plane);
		129	}
		130
		131	static bool i8xx_fbc_enabled(struct drm_device *dev)
		132	{
		133	struct drm_i915_private *dev_priv = dev->dev_private;
		134
		135	return I915_READ(FBC_CONTROL) & FBC_CTL_EN;
		136	}
		137
		138	static void g4x_enable_fbc(struct drm_crtc *crtc, unsigned long interval)
		139	{
		140	struct drm_device *dev = crtc->dev;
		141	struct drm_i915_private *dev_priv = dev->dev_private;
		142	struct drm_framebuffer *fb = crtc->fb;
		143	struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
		144	struct drm_i915_gem_object *obj = intel_fb->obj;
		145	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
		146	int plane = intel_crtc->plane == 0 ? DPFC_CTL_PLANEA : DPFC_CTL_PLANEB;
		147	unsigned long stall_watermark = 200;
		148	u32 dpfc_ctl;
		149
		150	dpfc_ctl = plane \| DPFC_SR_EN \| DPFC_CTL_LIMIT_1X;
		151	dpfc_ctl \|= DPFC_CTL_FENCE_EN \| obj->fence_reg;
		152	I915_WRITE(DPFC_CHICKEN, DPFC_HT_MODIFY);
		153
		154	I915_WRITE(DPFC_RECOMP_CTL, DPFC_RECOMP_STALL_EN \|
		155	(stall_watermark << DPFC_RECOMP_STALL_WM_SHIFT) \|
		156	(interval << DPFC_RECOMP_TIMER_COUNT_SHIFT));
		157	I915_WRITE(DPFC_FENCE_YOFF, crtc->y);
		158
		159	/* enable it... */
		160	I915_WRITE(DPFC_CONTROL, I915_READ(DPFC_CONTROL) \| DPFC_CTL_EN);
		161
		162	DRM_DEBUG_KMS("enabled fbc on plane %d\n", intel_crtc->plane);
		163	}
		164
		165	static void g4x_disable_fbc(struct drm_device *dev)
		166	{
		167	struct drm_i915_private *dev_priv = dev->dev_private;
		168	u32 dpfc_ctl;
		169
		170	/* Disable compression */
		171	dpfc_ctl = I915_READ(DPFC_CONTROL);
		172	if (dpfc_ctl & DPFC_CTL_EN) {
		173	dpfc_ctl &= ~DPFC_CTL_EN;
		174	I915_WRITE(DPFC_CONTROL, dpfc_ctl);
		175
		176	DRM_DEBUG_KMS("disabled FBC\n");
		177	}
		178	}
		179
		180	static bool g4x_fbc_enabled(struct drm_device *dev)
		181	{
		182	struct drm_i915_private *dev_priv = dev->dev_private;
		183
		184	return I915_READ(DPFC_CONTROL) & DPFC_CTL_EN;
		185	}
		186
		187	static void sandybridge_blit_fbc_update(struct drm_device *dev)
		188	{
		189	struct drm_i915_private *dev_priv = dev->dev_private;
		190	u32 blt_ecoskpd;
		191
		192	/* Make sure blitter notifies FBC of writes */
		193	gen6_gt_force_wake_get(dev_priv);
		194	blt_ecoskpd = I915_READ(GEN6_BLITTER_ECOSKPD);
		195	blt_ecoskpd \|= GEN6_BLITTER_FBC_NOTIFY <<
		196	GEN6_BLITTER_LOCK_SHIFT;
		197	I915_WRITE(GEN6_BLITTER_ECOSKPD, blt_ecoskpd);
		198	blt_ecoskpd \|= GEN6_BLITTER_FBC_NOTIFY;
		199	I915_WRITE(GEN6_BLITTER_ECOSKPD, blt_ecoskpd);
		200	blt_ecoskpd &= ~(GEN6_BLITTER_FBC_NOTIFY <<
		201	GEN6_BLITTER_LOCK_SHIFT);
		202	I915_WRITE(GEN6_BLITTER_ECOSKPD, blt_ecoskpd);
		203	POSTING_READ(GEN6_BLITTER_ECOSKPD);
		204	gen6_gt_force_wake_put(dev_priv);
		205	}
		206
		207	static void ironlake_enable_fbc(struct drm_crtc *crtc, unsigned long interval)
		208	{
		209	struct drm_device *dev = crtc->dev;
		210	struct drm_i915_private *dev_priv = dev->dev_private;
		211	struct drm_framebuffer *fb = crtc->fb;
		212	struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
		213	struct drm_i915_gem_object *obj = intel_fb->obj;
		214	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
		215	int plane = intel_crtc->plane == 0 ? DPFC_CTL_PLANEA : DPFC_CTL_PLANEB;
		216	unsigned long stall_watermark = 200;
		217	u32 dpfc_ctl;
		218
		219	dpfc_ctl = I915_READ(ILK_DPFC_CONTROL);
		220	dpfc_ctl &= DPFC_RESERVED;
		221	dpfc_ctl \|= (plane \| DPFC_CTL_LIMIT_1X);
		222	/* Set persistent mode for front-buffer rendering, ala X. */
		223	dpfc_ctl \|= DPFC_CTL_PERSISTENT_MODE;
		224	dpfc_ctl \|= (DPFC_CTL_FENCE_EN \| obj->fence_reg);
		225	I915_WRITE(ILK_DPFC_CHICKEN, DPFC_HT_MODIFY);
		226
		227	I915_WRITE(ILK_DPFC_RECOMP_CTL, DPFC_RECOMP_STALL_EN \|
		228	(stall_watermark << DPFC_RECOMP_STALL_WM_SHIFT) \|
		229	(interval << DPFC_RECOMP_TIMER_COUNT_SHIFT));
		230	I915_WRITE(ILK_DPFC_FENCE_YOFF, crtc->y);
		231	I915_WRITE(ILK_FBC_RT_BASE, obj->gtt_offset \| ILK_FBC_RT_VALID);
		232	/* enable it... */
		233	I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl \| DPFC_CTL_EN);
		234
		235	if (IS_GEN6(dev)) {
		236	I915_WRITE(SNB_DPFC_CTL_SA,
		237	SNB_CPU_FENCE_ENABLE \| obj->fence_reg);
		238	I915_WRITE(DPFC_CPU_FENCE_OFFSET, crtc->y);
		239	sandybridge_blit_fbc_update(dev);
		240	}
		241
		242	DRM_DEBUG_KMS("enabled fbc on plane %d\n", intel_crtc->plane);
		243	}
		244
		245	static void ironlake_disable_fbc(struct drm_device *dev)
		246	{
		247	struct drm_i915_private *dev_priv = dev->dev_private;
		248	u32 dpfc_ctl;
		249
		250	/* Disable compression */
		251	dpfc_ctl = I915_READ(ILK_DPFC_CONTROL);
		252	if (dpfc_ctl & DPFC_CTL_EN) {
		253	dpfc_ctl &= ~DPFC_CTL_EN;
		254	I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl);
		255
		256	DRM_DEBUG_KMS("disabled FBC\n");
		257	}
		258	}
		259
		260	static bool ironlake_fbc_enabled(struct drm_device *dev)
		261	{
		262	struct drm_i915_private *dev_priv = dev->dev_private;
		263
		264	return I915_READ(ILK_DPFC_CONTROL) & DPFC_CTL_EN;
		265	}
		266
		267	bool intel_fbc_enabled(struct drm_device *dev)
		268	{
		269	struct drm_i915_private *dev_priv = dev->dev_private;
		270
		271	if (!dev_priv->display.fbc_enabled)
		272	return false;
		273
		274	return dev_priv->display.fbc_enabled(dev);
		275	}
		276
		277	#if 0
		278	static void intel_fbc_work_fn(struct work_struct *__work)
		279	{
		280	struct intel_fbc_work *work =
		281	container_of(to_delayed_work(__work),
		282	struct intel_fbc_work, work);
		283	struct drm_device *dev = work->crtc->dev;
		284	struct drm_i915_private *dev_priv = dev->dev_private;
		285
		286	mutex_lock(&dev->struct_mutex);
		287	if (work == dev_priv->fbc_work) {
		288	/* Double check that we haven't switched fb without cancelling
		289	* the prior work.
		290	*/
		291	if (work->crtc->fb == work->fb) {
		292	dev_priv->display.enable_fbc(work->crtc,
		293	work->interval);
		294
		295	dev_priv->cfb_plane = to_intel_crtc(work->crtc)->plane;
		296	dev_priv->cfb_fb = work->crtc->fb->base.id;
		297	dev_priv->cfb_y = work->crtc->y;
		298	}
		299
		300	dev_priv->fbc_work = NULL;
		301	}
		302	mutex_unlock(&dev->struct_mutex);
		303
		304	kfree(work);
		305	}
		306
		307	static void intel_cancel_fbc_work(struct drm_i915_private *dev_priv)
		308	{
		309	if (dev_priv->fbc_work == NULL)
		310	return;
		311
		312	DRM_DEBUG_KMS("cancelling pending FBC enable\n");
		313
		314	/* Synchronisation is provided by struct_mutex and checking of
		315	* dev_priv->fbc_work, so we can perform the cancellation
		316	* entirely asynchronously.
		317	*/
		318	if (cancel_delayed_work(&dev_priv->fbc_work->work))
		319	/* tasklet was killed before being run, clean up */
		320	kfree(dev_priv->fbc_work);
		321
		322	/* Mark the work as no longer wanted so that if it does
		323	* wake-up (because the work was already running and waiting
		324	* for our mutex), it will discover that is no longer
		325	* necessary to run.
		326	*/
		327	dev_priv->fbc_work = NULL;
		328	}
		329	#endif
		330
		331	void intel_enable_fbc(struct drm_crtc *crtc, unsigned long interval)
		332	{
		333	struct intel_fbc_work *work;
		334	struct drm_device *dev = crtc->dev;
		335	struct drm_i915_private *dev_priv = dev->dev_private;
		336
		337	// if (!dev_priv->display.enable_fbc)
		338	return;
		339	#if 0
		340	intel_cancel_fbc_work(dev_priv);
		341
		342	work = kzalloc(sizeof *work, GFP_KERNEL);
		343	if (work == NULL) {
		344	dev_priv->display.enable_fbc(crtc, interval);
		345	return;
		346	}
		347
		348	work->crtc = crtc;
		349	work->fb = crtc->fb;
		350	work->interval = interval;
		351	INIT_DELAYED_WORK(&work->work, intel_fbc_work_fn);
		352
		353	dev_priv->fbc_work = work;
		354
		355	DRM_DEBUG_KMS("scheduling delayed FBC enable\n");
		356
		357	/* Delay the actual enabling to let pageflipping cease and the
		358	* display to settle before starting the compression. Note that
		359	* this delay also serves a second purpose: it allows for a
		360	* vblank to pass after disabling the FBC before we attempt
		361	* to modify the control registers.
		362	*
		363	* A more complicated solution would involve tracking vblanks
		364	* following the termination of the page-flipping sequence
		365	* and indeed performing the enable as a co-routine and not
		366	* waiting synchronously upon the vblank.
		367	*/
		368	schedule_delayed_work(&work->work, msecs_to_jiffies(50));
		369	#endif
		370
		371	}
		372
		373	void intel_disable_fbc(struct drm_device *dev)
		374	{
		375	struct drm_i915_private *dev_priv = dev->dev_private;
		376
		377	// intel_cancel_fbc_work(dev_priv);
		378
		379	// if (!dev_priv->display.disable_fbc)
		380	// return;
		381
		382	// dev_priv->display.disable_fbc(dev);
		383	dev_priv->cfb_plane = -1;
		384	}
		385
		386	/**
		387	* intel_update_fbc - enable/disable FBC as needed
		388	* @dev: the drm_device
		389	*
		390	* Set up the framebuffer compression hardware at mode set time. We
		391	* enable it if possible:
		392	* - plane A only (on pre-965)
		393	* - no pixel mulitply/line duplication
		394	* - no alpha buffer discard
		395	* - no dual wide
		396	* - framebuffer <= 2048 in width, 1536 in height
		397	*
		398	* We can't assume that any compression will take place (worst case),
		399	* so the compressed buffer has to be the same size as the uncompressed
		400	* one. It also must reside (along with the line length buffer) in
		401	* stolen memory.
		402	*
		403	* We need to enable/disable FBC on a global basis.
		404	*/
		405	void intel_update_fbc(struct drm_device *dev)
		406	{
		407	struct drm_i915_private *dev_priv = dev->dev_private;
		408	struct drm_crtc crtc = NULL, tmp_crtc;
		409	struct intel_crtc *intel_crtc;
		410	struct drm_framebuffer *fb;
		411	struct intel_framebuffer *intel_fb;
		412	struct drm_i915_gem_object *obj;
		413	int enable_fbc;
		414
		415	if (!i915_powersave)
		416	return;
		417
		418	if (!I915_HAS_FBC(dev))
		419	return;
		420
		421	/*
		422	* If FBC is already on, we just have to verify that we can
		423	* keep it that way...
		424	* Need to disable if:
		425	* - more than one pipe is active
		426	* - changing FBC params (stride, fence, mode)
		427	* - new fb is too large to fit in compressed buffer
		428	* - going to an unsupported config (interlace, pixel multiply, etc.)
		429	*/
		430	list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head) {
		431	if (tmp_crtc->enabled &&
		432	!to_intel_crtc(tmp_crtc)->primary_disabled &&
		433	tmp_crtc->fb) {
		434	if (crtc) {
		435	DRM_DEBUG_KMS("more than one pipe active, disabling compression\n");
		436	dev_priv->no_fbc_reason = FBC_MULTIPLE_PIPES;
		437	goto out_disable;
		438	}
		439	crtc = tmp_crtc;
		440	}
		441	}
		442
		443	if (!crtc \|\| crtc->fb == NULL) {
		444	DRM_DEBUG_KMS("no output, disabling\n");
		445	dev_priv->no_fbc_reason = FBC_NO_OUTPUT;
		446	goto out_disable;
		447	}
		448
		449	intel_crtc = to_intel_crtc(crtc);
		450	fb = crtc->fb;
		451	intel_fb = to_intel_framebuffer(fb);
		452	obj = intel_fb->obj;
		453
		454	enable_fbc = i915_enable_fbc;
		455	if (enable_fbc < 0) {
		456	DRM_DEBUG_KMS("fbc set to per-chip default\n");
		457	enable_fbc = 1;
		458	if (INTEL_INFO(dev)->gen <= 6)
		459	enable_fbc = 0;
		460	}
		461	if (!enable_fbc) {
		462	DRM_DEBUG_KMS("fbc disabled per module param\n");
		463	dev_priv->no_fbc_reason = FBC_MODULE_PARAM;
		464	goto out_disable;
		465	}
		466	if (intel_fb->obj->base.size > dev_priv->cfb_size) {
		467	DRM_DEBUG_KMS("framebuffer too large, disabling "
		468	"compression\n");
		469	dev_priv->no_fbc_reason = FBC_STOLEN_TOO_SMALL;
		470	goto out_disable;
		471	}
		472	if ((crtc->mode.flags & DRM_MODE_FLAG_INTERLACE) \|\|
		473	(crtc->mode.flags & DRM_MODE_FLAG_DBLSCAN)) {
		474	DRM_DEBUG_KMS("mode incompatible with compression, "
		475	"disabling\n");
		476	dev_priv->no_fbc_reason = FBC_UNSUPPORTED_MODE;
		477	goto out_disable;
		478	}
		479	if ((crtc->mode.hdisplay > 2048) \|\|
		480	(crtc->mode.vdisplay > 1536)) {
		481	DRM_DEBUG_KMS("mode too large for compression, disabling\n");
		482	dev_priv->no_fbc_reason = FBC_MODE_TOO_LARGE;
		483	goto out_disable;
		484	}
		485	if ((IS_I915GM(dev) \|\| IS_I945GM(dev)) && intel_crtc->plane != 0) {
		486	DRM_DEBUG_KMS("plane not 0, disabling compression\n");
		487	dev_priv->no_fbc_reason = FBC_BAD_PLANE;
		488	goto out_disable;
		489	}
		490
		491	/* The use of a CPU fence is mandatory in order to detect writes
		492	* by the CPU to the scanout and trigger updates to the FBC.
		493	*/
		494	if (obj->tiling_mode != I915_TILING_X \|\|
		495	obj->fence_reg == I915_FENCE_REG_NONE) {
		496	DRM_DEBUG_KMS("framebuffer not tiled or fenced, disabling compression\n");
		497	dev_priv->no_fbc_reason = FBC_NOT_TILED;
		498	goto out_disable;
		499	}
		500
		501	/* If the kernel debugger is active, always disable compression */
		502	if (in_dbg_master())
		503	goto out_disable;
		504
		505	/* If the scanout has not changed, don't modify the FBC settings.
		506	* Note that we make the fundamental assumption that the fb->obj
		507	* cannot be unpinned (and have its GTT offset and fence revoked)
		508	* without first being decoupled from the scanout and FBC disabled.
		509	*/
		510	if (dev_priv->cfb_plane == intel_crtc->plane &&
		511	dev_priv->cfb_fb == fb->base.id &&
		512	dev_priv->cfb_y == crtc->y)
		513	return;
		514
		515	if (intel_fbc_enabled(dev)) {
		516	/* We update FBC along two paths, after changing fb/crtc
		517	* configuration (modeswitching) and after page-flipping
		518	* finishes. For the latter, we know that not only did
		519	* we disable the FBC at the start of the page-flip
		520	* sequence, but also more than one vblank has passed.
		521	*
		522	* For the former case of modeswitching, it is possible
		523	* to switch between two FBC valid configurations
		524	* instantaneously so we do need to disable the FBC
		525	* before we can modify its control registers. We also
		526	* have to wait for the next vblank for that to take
		527	* effect. However, since we delay enabling FBC we can
		528	* assume that a vblank has passed since disabling and
		529	* that we can safely alter the registers in the deferred
		530	* callback.
		531	*
		532	* In the scenario that we go from a valid to invalid
		533	* and then back to valid FBC configuration we have
		534	* no strict enforcement that a vblank occurred since
		535	* disabling the FBC. However, along all current pipe
		536	* disabling paths we do need to wait for a vblank at
		537	* some point. And we wait before enabling FBC anyway.
		538	*/
		539	DRM_DEBUG_KMS("disabling active FBC for update\n");
		540	intel_disable_fbc(dev);
		541	}
		542
		543	intel_enable_fbc(crtc, 500);
		544	return;
		545
		546	out_disable:
		547	/* Multiple disables should be harmless */
		548	if (intel_fbc_enabled(dev)) {
		549	DRM_DEBUG_KMS("unsupported config, disabling FBC\n");
		550	intel_disable_fbc(dev);
		551	}
		552	}
		553
		554	static void i915_pineview_get_mem_freq(struct drm_device *dev)
		555	{
		556	drm_i915_private_t *dev_priv = dev->dev_private;
		557	u32 tmp;
		558
		559	tmp = I915_READ(CLKCFG);
		560
		561	switch (tmp & CLKCFG_FSB_MASK) {
		562	case CLKCFG_FSB_533:
		563	dev_priv->fsb_freq = 533; /* 1334 /
		564	break;
		565	case CLKCFG_FSB_800:
		566	dev_priv->fsb_freq = 800; /* 2004 /
		567	break;
		568	case CLKCFG_FSB_667:
		569	dev_priv->fsb_freq = 667; /* 1674 /
		570	break;
		571	case CLKCFG_FSB_400:
		572	dev_priv->fsb_freq = 400; /* 1004 /
		573	break;
		574	}
		575
		576	switch (tmp & CLKCFG_MEM_MASK) {
		577	case CLKCFG_MEM_533:
		578	dev_priv->mem_freq = 533;
		579	break;
		580	case CLKCFG_MEM_667:
		581	dev_priv->mem_freq = 667;
		582	break;
		583	case CLKCFG_MEM_800:
		584	dev_priv->mem_freq = 800;
		585	break;
		586	}
		587
		588	/* detect pineview DDR3 setting */
		589	tmp = I915_READ(CSHRDDR3CTL);
		590	dev_priv->is_ddr3 = (tmp & CSHRDDR3CTL_DDR3) ? 1 : 0;
		591	}
		592
		593	static void i915_ironlake_get_mem_freq(struct drm_device *dev)
		594	{
		595	drm_i915_private_t *dev_priv = dev->dev_private;
		596	u16 ddrpll, csipll;
		597
		598	ddrpll = I915_READ16(DDRMPLL1);
		599	csipll = I915_READ16(CSIPLL0);
		600
		601	switch (ddrpll & 0xff) {
		602	case 0xc:
		603	dev_priv->mem_freq = 800;
		604	break;
		605	case 0x10:
		606	dev_priv->mem_freq = 1066;
		607	break;
		608	case 0x14:
		609	dev_priv->mem_freq = 1333;
		610	break;
		611	case 0x18:
		612	dev_priv->mem_freq = 1600;
		613	break;
		614	default:
		615	DRM_DEBUG_DRIVER("unknown memory frequency 0x%02x\n",
		616	ddrpll & 0xff);
		617	dev_priv->mem_freq = 0;
		618	break;
		619	}
		620
		621	dev_priv->ips.r_t = dev_priv->mem_freq;
		622
		623	switch (csipll & 0x3ff) {
		624	case 0x00c:
		625	dev_priv->fsb_freq = 3200;
		626	break;
		627	case 0x00e:
		628	dev_priv->fsb_freq = 3733;
		629	break;
		630	case 0x010:
		631	dev_priv->fsb_freq = 4266;
		632	break;
		633	case 0x012:
		634	dev_priv->fsb_freq = 4800;
		635	break;
		636	case 0x014:
		637	dev_priv->fsb_freq = 5333;
		638	break;
		639	case 0x016:
		640	dev_priv->fsb_freq = 5866;
		641	break;
		642	case 0x018:
		643	dev_priv->fsb_freq = 6400;
		644	break;
		645	default:
		646	DRM_DEBUG_DRIVER("unknown fsb frequency 0x%04x\n",
		647	csipll & 0x3ff);
		648	dev_priv->fsb_freq = 0;
		649	break;
		650	}
		651
		652	if (dev_priv->fsb_freq == 3200) {
		653	dev_priv->ips.c_m = 0;
		654	} else if (dev_priv->fsb_freq > 3200 && dev_priv->fsb_freq <= 4800) {
		655	dev_priv->ips.c_m = 1;
		656	} else {
		657	dev_priv->ips.c_m = 2;
		658	}
		659	}
		660
		661	static const struct cxsr_latency cxsr_latency_table[] = {
		662	{1, 0, 800, 400, 3382, 33382, 3983, 33983}, /* DDR2-400 SC */
		663	{1, 0, 800, 667, 3354, 33354, 3807, 33807}, /* DDR2-667 SC */
		664	{1, 0, 800, 800, 3347, 33347, 3763, 33763}, /* DDR2-800 SC */
		665	{1, 1, 800, 667, 6420, 36420, 6873, 36873}, /* DDR3-667 SC */
		666	{1, 1, 800, 800, 5902, 35902, 6318, 36318}, /* DDR3-800 SC */
		667
		668	{1, 0, 667, 400, 3400, 33400, 4021, 34021}, /* DDR2-400 SC */
		669	{1, 0, 667, 667, 3372, 33372, 3845, 33845}, /* DDR2-667 SC */
		670	{1, 0, 667, 800, 3386, 33386, 3822, 33822}, /* DDR2-800 SC */
		671	{1, 1, 667, 667, 6438, 36438, 6911, 36911}, /* DDR3-667 SC */
		672	{1, 1, 667, 800, 5941, 35941, 6377, 36377}, /* DDR3-800 SC */
		673
		674	{1, 0, 400, 400, 3472, 33472, 4173, 34173}, /* DDR2-400 SC */
		675	{1, 0, 400, 667, 3443, 33443, 3996, 33996}, /* DDR2-667 SC */
		676	{1, 0, 400, 800, 3430, 33430, 3946, 33946}, /* DDR2-800 SC */
		677	{1, 1, 400, 667, 6509, 36509, 7062, 37062}, /* DDR3-667 SC */
		678	{1, 1, 400, 800, 5985, 35985, 6501, 36501}, /* DDR3-800 SC */
		679
		680	{0, 0, 800, 400, 3438, 33438, 4065, 34065}, /* DDR2-400 SC */
		681	{0, 0, 800, 667, 3410, 33410, 3889, 33889}, /* DDR2-667 SC */
		682	{0, 0, 800, 800, 3403, 33403, 3845, 33845}, /* DDR2-800 SC */
		683	{0, 1, 800, 667, 6476, 36476, 6955, 36955}, /* DDR3-667 SC */
		684	{0, 1, 800, 800, 5958, 35958, 6400, 36400}, /* DDR3-800 SC */
		685
		686	{0, 0, 667, 400, 3456, 33456, 4103, 34106}, /* DDR2-400 SC */
		687	{0, 0, 667, 667, 3428, 33428, 3927, 33927}, /* DDR2-667 SC */
		688	{0, 0, 667, 800, 3443, 33443, 3905, 33905}, /* DDR2-800 SC */
		689	{0, 1, 667, 667, 6494, 36494, 6993, 36993}, /* DDR3-667 SC */
		690	{0, 1, 667, 800, 5998, 35998, 6460, 36460}, /* DDR3-800 SC */
		691
		692	{0, 0, 400, 400, 3528, 33528, 4255, 34255}, /* DDR2-400 SC */
		693	{0, 0, 400, 667, 3500, 33500, 4079, 34079}, /* DDR2-667 SC */
		694	{0, 0, 400, 800, 3487, 33487, 4029, 34029}, /* DDR2-800 SC */
		695	{0, 1, 400, 667, 6566, 36566, 7145, 37145}, /* DDR3-667 SC */
		696	{0, 1, 400, 800, 6042, 36042, 6584, 36584}, /* DDR3-800 SC */
		697	};
		698
		699	static const struct cxsr_latency *intel_get_cxsr_latency(int is_desktop,
		700	int is_ddr3,
		701	int fsb,
		702	int mem)
		703	{
		704	const struct cxsr_latency *latency;
		705	int i;
		706
		707	if (fsb == 0 \|\| mem == 0)
		708	return NULL;
		709
		710	for (i = 0; i < ARRAY_SIZE(cxsr_latency_table); i++) {
		711	latency = &cxsr_latency_table[i];
		712	if (is_desktop == latency->is_desktop &&
		713	is_ddr3 == latency->is_ddr3 &&
		714	fsb == latency->fsb_freq && mem == latency->mem_freq)
		715	return latency;
		716	}
		717
		718	DRM_DEBUG_KMS("Unknown FSB/MEM found, disable CxSR\n");
		719
		720	return NULL;
		721	}
		722
		723	static void pineview_disable_cxsr(struct drm_device *dev)
		724	{
		725	struct drm_i915_private *dev_priv = dev->dev_private;
		726
		727	/* deactivate cxsr */
		728	I915_WRITE(DSPFW3, I915_READ(DSPFW3) & ~PINEVIEW_SELF_REFRESH_EN);
		729	}
		730
		731	/*
		732	* Latency for FIFO fetches is dependent on several factors:
		733	* - memory configuration (speed, channels)
		734	* - chipset
		735	* - current MCH state
		736	* It can be fairly high in some situations, so here we assume a fairly
		737	* pessimal value. It's a tradeoff between extra memory fetches (if we
		738	* set this value too high, the FIFO will fetch frequently to stay full)
		739	* and power consumption (set it too low to save power and we might see
		740	* FIFO underruns and display "flicker").
		741	*
		742	* A value of 5us seems to be a good balance; safe for very low end
		743	* platforms but not overly aggressive on lower latency configs.
		744	*/
		745	static const int latency_ns = 5000;
		746
		747	static int i9xx_get_fifo_size(struct drm_device *dev, int plane)
		748	{
		749	struct drm_i915_private *dev_priv = dev->dev_private;
		750	uint32_t dsparb = I915_READ(DSPARB);
		751	int size;
		752
		753	size = dsparb & 0x7f;
		754	if (plane)
		755	size = ((dsparb >> DSPARB_CSTART_SHIFT) & 0x7f) - size;
		756
		757	DRM_DEBUG_KMS("FIFO size - (0x%08x) %s: %d\n", dsparb,
		758	plane ? "B" : "A", size);
		759
		760	return size;
		761	}
		762
		763	static int i85x_get_fifo_size(struct drm_device *dev, int plane)
		764	{
		765	struct drm_i915_private *dev_priv = dev->dev_private;
		766	uint32_t dsparb = I915_READ(DSPARB);
		767	int size;
		768
		769	size = dsparb & 0x1ff;
		770	if (plane)
		771	size = ((dsparb >> DSPARB_BEND_SHIFT) & 0x1ff) - size;
		772	size >>= 1; /* Convert to cachelines */
		773
		774	DRM_DEBUG_KMS("FIFO size - (0x%08x) %s: %d\n", dsparb,
		775	plane ? "B" : "A", size);
		776
		777	return size;
		778	}
		779
		780	static int i845_get_fifo_size(struct drm_device *dev, int plane)
		781	{
		782	struct drm_i915_private *dev_priv = dev->dev_private;
		783	uint32_t dsparb = I915_READ(DSPARB);
		784	int size;
		785
		786	size = dsparb & 0x7f;
		787	size >>= 2; /* Convert to cachelines */
		788
		789	DRM_DEBUG_KMS("FIFO size - (0x%08x) %s: %d\n", dsparb,
		790	plane ? "B" : "A",
		791	size);
		792
		793	return size;
		794	}
		795
		796	static int i830_get_fifo_size(struct drm_device *dev, int plane)
		797	{
		798	struct drm_i915_private *dev_priv = dev->dev_private;
		799	uint32_t dsparb = I915_READ(DSPARB);
		800	int size;
		801
		802	size = dsparb & 0x7f;
		803	size >>= 1; /* Convert to cachelines */
		804
		805	DRM_DEBUG_KMS("FIFO size - (0x%08x) %s: %d\n", dsparb,
		806	plane ? "B" : "A", size);
		807
		808	return size;
		809	}
		810
		811	/* Pineview has different values for various configs */
		812	static const struct intel_watermark_params pineview_display_wm = {
		813	PINEVIEW_DISPLAY_FIFO,
		814	PINEVIEW_MAX_WM,
		815	PINEVIEW_DFT_WM,
		816	PINEVIEW_GUARD_WM,
		817	PINEVIEW_FIFO_LINE_SIZE
		818	};
		819	static const struct intel_watermark_params pineview_display_hplloff_wm = {
		820	PINEVIEW_DISPLAY_FIFO,
		821	PINEVIEW_MAX_WM,
		822	PINEVIEW_DFT_HPLLOFF_WM,
		823	PINEVIEW_GUARD_WM,
		824	PINEVIEW_FIFO_LINE_SIZE
		825	};
		826	static const struct intel_watermark_params pineview_cursor_wm = {
		827	PINEVIEW_CURSOR_FIFO,
		828	PINEVIEW_CURSOR_MAX_WM,
		829	PINEVIEW_CURSOR_DFT_WM,
		830	PINEVIEW_CURSOR_GUARD_WM,
		831	PINEVIEW_FIFO_LINE_SIZE,
		832	};
		833	static const struct intel_watermark_params pineview_cursor_hplloff_wm = {
		834	PINEVIEW_CURSOR_FIFO,
		835	PINEVIEW_CURSOR_MAX_WM,
		836	PINEVIEW_CURSOR_DFT_WM,
		837	PINEVIEW_CURSOR_GUARD_WM,
		838	PINEVIEW_FIFO_LINE_SIZE
		839	};
		840	static const struct intel_watermark_params g4x_wm_info = {
		841	G4X_FIFO_SIZE,
		842	G4X_MAX_WM,
		843	G4X_MAX_WM,
		844	2,
		845	G4X_FIFO_LINE_SIZE,
		846	};
		847	static const struct intel_watermark_params g4x_cursor_wm_info = {
		848	I965_CURSOR_FIFO,
		849	I965_CURSOR_MAX_WM,
		850	I965_CURSOR_DFT_WM,
		851	2,
		852	G4X_FIFO_LINE_SIZE,
		853	};
		854	static const struct intel_watermark_params valleyview_wm_info = {
		855	VALLEYVIEW_FIFO_SIZE,
		856	VALLEYVIEW_MAX_WM,
		857	VALLEYVIEW_MAX_WM,
		858	2,
		859	G4X_FIFO_LINE_SIZE,
		860	};
		861	static const struct intel_watermark_params valleyview_cursor_wm_info = {
		862	I965_CURSOR_FIFO,
		863	VALLEYVIEW_CURSOR_MAX_WM,
		864	I965_CURSOR_DFT_WM,
		865	2,
		866	G4X_FIFO_LINE_SIZE,
		867	};
		868	static const struct intel_watermark_params i965_cursor_wm_info = {
		869	I965_CURSOR_FIFO,
		870	I965_CURSOR_MAX_WM,
		871	I965_CURSOR_DFT_WM,
		872	2,
		873	I915_FIFO_LINE_SIZE,
		874	};
		875	static const struct intel_watermark_params i945_wm_info = {
		876	I945_FIFO_SIZE,
		877	I915_MAX_WM,
		878	1,
		879	2,
		880	I915_FIFO_LINE_SIZE
		881	};
		882	static const struct intel_watermark_params i915_wm_info = {
		883	I915_FIFO_SIZE,
		884	I915_MAX_WM,
		885	1,
		886	2,
		887	I915_FIFO_LINE_SIZE
		888	};
		889	static const struct intel_watermark_params i855_wm_info = {
		890	I855GM_FIFO_SIZE,
		891	I915_MAX_WM,
		892	1,
		893	2,
		894	I830_FIFO_LINE_SIZE
		895	};
		896	static const struct intel_watermark_params i830_wm_info = {
		897	I830_FIFO_SIZE,
		898	I915_MAX_WM,
		899	1,
		900	2,
		901	I830_FIFO_LINE_SIZE
		902	};
		903
		904	static const struct intel_watermark_params ironlake_display_wm_info = {
		905	ILK_DISPLAY_FIFO,
		906	ILK_DISPLAY_MAXWM,
		907	ILK_DISPLAY_DFTWM,
		908	2,
		909	ILK_FIFO_LINE_SIZE
		910	};
		911	static const struct intel_watermark_params ironlake_cursor_wm_info = {
		912	ILK_CURSOR_FIFO,
		913	ILK_CURSOR_MAXWM,
		914	ILK_CURSOR_DFTWM,
		915	2,
		916	ILK_FIFO_LINE_SIZE
		917	};
		918	static const struct intel_watermark_params ironlake_display_srwm_info = {
		919	ILK_DISPLAY_SR_FIFO,
		920	ILK_DISPLAY_MAX_SRWM,
		921	ILK_DISPLAY_DFT_SRWM,
		922	2,
		923	ILK_FIFO_LINE_SIZE
		924	};
		925	static const struct intel_watermark_params ironlake_cursor_srwm_info = {
		926	ILK_CURSOR_SR_FIFO,
		927	ILK_CURSOR_MAX_SRWM,
		928	ILK_CURSOR_DFT_SRWM,
		929	2,
		930	ILK_FIFO_LINE_SIZE
		931	};
		932
		933	static const struct intel_watermark_params sandybridge_display_wm_info = {
		934	SNB_DISPLAY_FIFO,
		935	SNB_DISPLAY_MAXWM,
		936	SNB_DISPLAY_DFTWM,
		937	2,
		938	SNB_FIFO_LINE_SIZE
		939	};
		940	static const struct intel_watermark_params sandybridge_cursor_wm_info = {
		941	SNB_CURSOR_FIFO,
		942	SNB_CURSOR_MAXWM,
		943	SNB_CURSOR_DFTWM,
		944	2,
		945	SNB_FIFO_LINE_SIZE
		946	};
		947	static const struct intel_watermark_params sandybridge_display_srwm_info = {
		948	SNB_DISPLAY_SR_FIFO,
		949	SNB_DISPLAY_MAX_SRWM,
		950	SNB_DISPLAY_DFT_SRWM,
		951	2,
		952	SNB_FIFO_LINE_SIZE
		953	};
		954	static const struct intel_watermark_params sandybridge_cursor_srwm_info = {
		955	SNB_CURSOR_SR_FIFO,
		956	SNB_CURSOR_MAX_SRWM,
		957	SNB_CURSOR_DFT_SRWM,
		958	2,
		959	SNB_FIFO_LINE_SIZE
		960	};
		961
		962
		963	/**
		964	* intel_calculate_wm - calculate watermark level
		965	* @clock_in_khz: pixel clock
		966	* @wm: chip FIFO params
		967	* @pixel_size: display pixel size
		968	* @latency_ns: memory latency for the platform
		969	*
		970	* Calculate the watermark level (the level at which the display plane will
		971	* start fetching from memory again). Each chip has a different display
		972	* FIFO size and allocation, so the caller needs to figure that out and pass
		973	* in the correct intel_watermark_params structure.
		974	*
		975	* As the pixel clock runs, the FIFO will be drained at a rate that depends
		976	* on the pixel size. When it reaches the watermark level, it'll start
		977	* fetching FIFO line sized based chunks from memory until the FIFO fills
		978	* past the watermark point. If the FIFO drains completely, a FIFO underrun
		979	* will occur, and a display engine hang could result.
		980	*/
		981	static unsigned long intel_calculate_wm(unsigned long clock_in_khz,
		982	const struct intel_watermark_params *wm,
		983	int fifo_size,
		984	int pixel_size,
		985	unsigned long latency_ns)
		986	{
		987	long entries_required, wm_size;
		988
		989	/*
		990	* Note: we need to make sure we don't overflow for various clock &
		991	* latency values.
		992	* clocks go from a few thousand to several hundred thousand.
		993	* latency is usually a few thousand
		994	*/
		995	entries_required = ((clock_in_khz / 1000) * pixel_size * latency_ns) /
		996	1000;
		997	entries_required = DIV_ROUND_UP(entries_required, wm->cacheline_size);
		998
		999	DRM_DEBUG_KMS("FIFO entries required for mode: %ld\n", entries_required);
		1000
		1001	wm_size = fifo_size - (entries_required + wm->guard_size);
		1002
		1003	DRM_DEBUG_KMS("FIFO watermark level: %ld\n", wm_size);
		1004
		1005	/* Don't promote wm_size to unsigned... */
		1006	if (wm_size > (long)wm->max_wm)
		1007	wm_size = wm->max_wm;
		1008	if (wm_size <= 0)
		1009	wm_size = wm->default_wm;
		1010	return wm_size;
		1011	}
		1012
		1013	static struct drm_crtc single_enabled_crtc(struct drm_device dev)
		1014	{
		1015	struct drm_crtc crtc, enabled = NULL;
		1016
		1017	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
		1018	if (crtc->enabled && crtc->fb) {
		1019	if (enabled)
		1020	return NULL;
		1021	enabled = crtc;
		1022	}
		1023	}
		1024
		1025	return enabled;
		1026	}
		1027
		1028	static void pineview_update_wm(struct drm_device *dev)
		1029	{
		1030	struct drm_i915_private *dev_priv = dev->dev_private;
		1031	struct drm_crtc *crtc;
		1032	const struct cxsr_latency *latency;
		1033	u32 reg;
		1034	unsigned long wm;
		1035
		1036	latency = intel_get_cxsr_latency(IS_PINEVIEW_G(dev), dev_priv->is_ddr3,
		1037	dev_priv->fsb_freq, dev_priv->mem_freq);
		1038	if (!latency) {
		1039	DRM_DEBUG_KMS("Unknown FSB/MEM found, disable CxSR\n");
		1040	pineview_disable_cxsr(dev);
		1041	return;
		1042	}
		1043
		1044	crtc = single_enabled_crtc(dev);
		1045	if (crtc) {
		1046	int clock = crtc->mode.clock;
		1047	int pixel_size = crtc->fb->bits_per_pixel / 8;
		1048
		1049	/* Display SR */
		1050	wm = intel_calculate_wm(clock, &pineview_display_wm,
		1051	pineview_display_wm.fifo_size,
		1052	pixel_size, latency->display_sr);
		1053	reg = I915_READ(DSPFW1);
		1054	reg &= ~DSPFW_SR_MASK;
		1055	reg \|= wm << DSPFW_SR_SHIFT;
		1056	I915_WRITE(DSPFW1, reg);
		1057	DRM_DEBUG_KMS("DSPFW1 register is %x\n", reg);
		1058
		1059	/* cursor SR */
		1060	wm = intel_calculate_wm(clock, &pineview_cursor_wm,
		1061	pineview_display_wm.fifo_size,
		1062	pixel_size, latency->cursor_sr);
		1063	reg = I915_READ(DSPFW3);
		1064	reg &= ~DSPFW_CURSOR_SR_MASK;
		1065	reg \|= (wm & 0x3f) << DSPFW_CURSOR_SR_SHIFT;
		1066	I915_WRITE(DSPFW3, reg);
		1067
		1068	/* Display HPLL off SR */
		1069	wm = intel_calculate_wm(clock, &pineview_display_hplloff_wm,
		1070	pineview_display_hplloff_wm.fifo_size,
		1071	pixel_size, latency->display_hpll_disable);
		1072	reg = I915_READ(DSPFW3);
		1073	reg &= ~DSPFW_HPLL_SR_MASK;
		1074	reg \|= wm & DSPFW_HPLL_SR_MASK;
		1075	I915_WRITE(DSPFW3, reg);
		1076
		1077	/* cursor HPLL off SR */
		1078	wm = intel_calculate_wm(clock, &pineview_cursor_hplloff_wm,
		1079	pineview_display_hplloff_wm.fifo_size,
		1080	pixel_size, latency->cursor_hpll_disable);
		1081	reg = I915_READ(DSPFW3);
		1082	reg &= ~DSPFW_HPLL_CURSOR_MASK;
		1083	reg \|= (wm & 0x3f) << DSPFW_HPLL_CURSOR_SHIFT;
		1084	I915_WRITE(DSPFW3, reg);
		1085	DRM_DEBUG_KMS("DSPFW3 register is %x\n", reg);
		1086
		1087	/* activate cxsr */
		1088	I915_WRITE(DSPFW3,
		1089	I915_READ(DSPFW3) \| PINEVIEW_SELF_REFRESH_EN);
		1090	DRM_DEBUG_KMS("Self-refresh is enabled\n");
		1091	} else {
		1092	pineview_disable_cxsr(dev);
		1093	DRM_DEBUG_KMS("Self-refresh is disabled\n");
		1094	}
		1095	}
		1096
		1097	static bool g4x_compute_wm0(struct drm_device *dev,
		1098	int plane,
		1099	const struct intel_watermark_params *display,
		1100	int display_latency_ns,
		1101	const struct intel_watermark_params *cursor,
		1102	int cursor_latency_ns,
		1103	int *plane_wm,
		1104	int *cursor_wm)
		1105	{
		1106	struct drm_crtc *crtc;
		1107	int htotal, hdisplay, clock, pixel_size;
		1108	int line_time_us, line_count;
		1109	int entries, tlb_miss;
		1110
		1111	crtc = intel_get_crtc_for_plane(dev, plane);
		1112	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
		1113
		1114	if (crtc->fb == NULL \|\| !crtc->enabled \|\| !intel_crtc->active) {
		1115	*cursor_wm = cursor->guard_size;
		1116	*plane_wm = display->guard_size;
		1117	return false;
		1118	}
		1119
		1120	htotal = crtc->mode.htotal;
		1121	hdisplay = crtc->mode.hdisplay;
		1122	clock = crtc->mode.clock;
		1123	pixel_size = crtc->fb->bits_per_pixel / 8;
		1124
		1125	/* Use the small buffer method to calculate plane watermark */
		1126	entries = ((clock * pixel_size / 1000) * display_latency_ns) / 1000;
		1127	tlb_miss = display->fifo_sizedisplay->cacheline_size - hdisplay 8;
		1128	if (tlb_miss > 0)
		1129	entries += tlb_miss;
		1130	entries = DIV_ROUND_UP(entries, display->cacheline_size);
		1131	*plane_wm = entries + display->guard_size;
		1132	if (*plane_wm > (int)display->max_wm)
		1133	*plane_wm = display->max_wm;
		1134
		1135	/* Use the large buffer method to calculate cursor watermark */
		1136	line_time_us = ((htotal * 1000) / clock);
		1137	line_count = (cursor_latency_ns / line_time_us + 1000) / 1000;
		1138	entries = line_count * 64 * pixel_size;
		1139	tlb_miss = cursor->fifo_sizecursor->cacheline_size - hdisplay 8;
		1140	if (tlb_miss > 0)
		1141	entries += tlb_miss;
		1142	entries = DIV_ROUND_UP(entries, cursor->cacheline_size);
		1143	*cursor_wm = entries + cursor->guard_size;
		1144	if (*cursor_wm > (int)cursor->max_wm)
		1145	*cursor_wm = (int)cursor->max_wm;
		1146
		1147	return true;
		1148	}
		1149
		1150	/*
		1151	* Check the wm result.
		1152	*
		1153	* If any calculated watermark values is larger than the maximum value that
		1154	* can be programmed into the associated watermark register, that watermark
		1155	* must be disabled.
		1156	*/
		1157	static bool g4x_check_srwm(struct drm_device *dev,
		1158	int display_wm, int cursor_wm,
		1159	const struct intel_watermark_params *display,
		1160	const struct intel_watermark_params *cursor)
		1161	{
		1162	DRM_DEBUG_KMS("SR watermark: display plane %d, cursor %d\n",
		1163	display_wm, cursor_wm);
		1164
		1165	if (display_wm > display->max_wm) {
		1166	DRM_DEBUG_KMS("display watermark is too large(%d/%ld), disabling\n",
		1167	display_wm, display->max_wm);
		1168	return false;
		1169	}
		1170
		1171	if (cursor_wm > cursor->max_wm) {
		1172	DRM_DEBUG_KMS("cursor watermark is too large(%d/%ld), disabling\n",
		1173	cursor_wm, cursor->max_wm);
		1174	return false;
		1175	}
		1176
		1177	if (!(display_wm \|\| cursor_wm)) {
		1178	DRM_DEBUG_KMS("SR latency is 0, disabling\n");
		1179	return false;
		1180	}
		1181
		1182	return true;
		1183	}
		1184
		1185	static bool g4x_compute_srwm(struct drm_device *dev,
		1186	int plane,
		1187	int latency_ns,
		1188	const struct intel_watermark_params *display,
		1189	const struct intel_watermark_params *cursor,
		1190	int display_wm, int cursor_wm)
		1191	{
		1192	struct drm_crtc *crtc;
		1193	int hdisplay, htotal, pixel_size, clock;
		1194	unsigned long line_time_us;
		1195	int line_count, line_size;
		1196	int small, large;
		1197	int entries;
		1198
		1199	if (!latency_ns) {
		1200	display_wm = cursor_wm = 0;
		1201	return false;
		1202	}
		1203
		1204	crtc = intel_get_crtc_for_plane(dev, plane);
		1205	hdisplay = crtc->mode.hdisplay;
		1206	htotal = crtc->mode.htotal;
		1207	clock = crtc->mode.clock;
		1208	pixel_size = crtc->fb->bits_per_pixel / 8;
		1209
		1210	line_time_us = (htotal * 1000) / clock;
		1211	line_count = (latency_ns / line_time_us + 1000) / 1000;
		1212	line_size = hdisplay * pixel_size;
		1213
		1214	/* Use the minimum of the small and large buffer method for primary */
		1215	small = ((clock * pixel_size / 1000) * latency_ns) / 1000;
		1216	large = line_count * line_size;
		1217
		1218	entries = DIV_ROUND_UP(min(small, large), display->cacheline_size);
		1219	*display_wm = entries + display->guard_size;
		1220
		1221	/* calculate the self-refresh watermark for display cursor */
		1222	entries = line_count * pixel_size * 64;
		1223	entries = DIV_ROUND_UP(entries, cursor->cacheline_size);
		1224	*cursor_wm = entries + cursor->guard_size;
		1225
		1226	return g4x_check_srwm(dev,
		1227	display_wm, cursor_wm,
		1228	display, cursor);
		1229	}
		1230
		1231	static bool vlv_compute_drain_latency(struct drm_device *dev,
		1232	int plane,
		1233	int *plane_prec_mult,
		1234	int *plane_dl,
		1235	int *cursor_prec_mult,
		1236	int *cursor_dl)
		1237	{
		1238	struct drm_crtc *crtc;
		1239	int clock, pixel_size;
		1240	int entries;
		1241
		1242	crtc = intel_get_crtc_for_plane(dev, plane);
		1243	if (crtc->fb == NULL \|\| !crtc->enabled)
		1244	return false;
		1245
		1246	clock = crtc->mode.clock; /* VESA DOT Clock */
		1247	pixel_size = crtc->fb->bits_per_pixel / 8; /* BPP */
		1248
		1249	entries = (clock / 1000) * pixel_size;
		1250	*plane_prec_mult = (entries > 256) ?
		1251	DRAIN_LATENCY_PRECISION_32 : DRAIN_LATENCY_PRECISION_16;
		1252	plane_dl = (64 (plane_prec_mult) 4) / ((clock / 1000) *
		1253	pixel_size);
		1254
		1255	entries = (clock / 1000) * 4; /* BPP is always 4 for cursor */
		1256	*cursor_prec_mult = (entries > 256) ?
		1257	DRAIN_LATENCY_PRECISION_32 : DRAIN_LATENCY_PRECISION_16;
		1258	cursor_dl = (64 (cursor_prec_mult) 4) / ((clock / 1000) * 4);
		1259
		1260	return true;
		1261	}
		1262
		1263	/*
		1264	* Update drain latency registers of memory arbiter
		1265	*
		1266	* Valleyview SoC has a new memory arbiter and needs drain latency registers
		1267	* to be programmed. Each plane has a drain latency multiplier and a drain
		1268	* latency value.
		1269	*/
		1270
		1271	static void vlv_update_drain_latency(struct drm_device *dev)
		1272	{
		1273	struct drm_i915_private *dev_priv = dev->dev_private;
		1274	int planea_prec, planea_dl, planeb_prec, planeb_dl;
		1275	int cursora_prec, cursora_dl, cursorb_prec, cursorb_dl;
		1276	int plane_prec_mult, cursor_prec_mult; /* Precision multiplier is
		1277	either 16 or 32 */
		1278
		1279	/* For plane A, Cursor A */
		1280	if (vlv_compute_drain_latency(dev, 0, &plane_prec_mult, &planea_dl,
		1281	&cursor_prec_mult, &cursora_dl)) {
		1282	cursora_prec = (cursor_prec_mult == DRAIN_LATENCY_PRECISION_32) ?
		1283	DDL_CURSORA_PRECISION_32 : DDL_CURSORA_PRECISION_16;
		1284	planea_prec = (plane_prec_mult == DRAIN_LATENCY_PRECISION_32) ?
		1285	DDL_PLANEA_PRECISION_32 : DDL_PLANEA_PRECISION_16;
		1286
		1287	I915_WRITE(VLV_DDL1, cursora_prec \|
		1288	(cursora_dl << DDL_CURSORA_SHIFT) \|
		1289	planea_prec \| planea_dl);
		1290	}
		1291
		1292	/* For plane B, Cursor B */
		1293	if (vlv_compute_drain_latency(dev, 1, &plane_prec_mult, &planeb_dl,
		1294	&cursor_prec_mult, &cursorb_dl)) {
		1295	cursorb_prec = (cursor_prec_mult == DRAIN_LATENCY_PRECISION_32) ?
		1296	DDL_CURSORB_PRECISION_32 : DDL_CURSORB_PRECISION_16;
		1297	planeb_prec = (plane_prec_mult == DRAIN_LATENCY_PRECISION_32) ?
		1298	DDL_PLANEB_PRECISION_32 : DDL_PLANEB_PRECISION_16;
		1299
		1300	I915_WRITE(VLV_DDL2, cursorb_prec \|
		1301	(cursorb_dl << DDL_CURSORB_SHIFT) \|
		1302	planeb_prec \| planeb_dl);
		1303	}
		1304	}
		1305
		1306	#define single_plane_enabled(mask) is_power_of_2(mask)
		1307
		1308	static void valleyview_update_wm(struct drm_device *dev)
		1309	{
		1310	static const int sr_latency_ns = 12000;
		1311	struct drm_i915_private *dev_priv = dev->dev_private;
		1312	int planea_wm, planeb_wm, cursora_wm, cursorb_wm;
		1313	int plane_sr, cursor_sr;
		1314	unsigned int enabled = 0;
		1315
		1316	vlv_update_drain_latency(dev);
		1317
		1318	if (g4x_compute_wm0(dev, 0,
		1319	&valleyview_wm_info, latency_ns,
		1320	&valleyview_cursor_wm_info, latency_ns,
		1321	&planea_wm, &cursora_wm))
		1322	enabled \|= 1;
		1323
		1324	if (g4x_compute_wm0(dev, 1,
		1325	&valleyview_wm_info, latency_ns,
		1326	&valleyview_cursor_wm_info, latency_ns,
		1327	&planeb_wm, &cursorb_wm))
		1328	enabled \|= 2;
		1329
		1330	plane_sr = cursor_sr = 0;
		1331	if (single_plane_enabled(enabled) &&
		1332	g4x_compute_srwm(dev, ffs(enabled) - 1,
		1333	sr_latency_ns,
		1334	&valleyview_wm_info,
		1335	&valleyview_cursor_wm_info,
		1336	&plane_sr, &cursor_sr))
		1337	I915_WRITE(FW_BLC_SELF_VLV, FW_CSPWRDWNEN);
		1338	else
		1339	I915_WRITE(FW_BLC_SELF_VLV,
		1340	I915_READ(FW_BLC_SELF_VLV) & ~FW_CSPWRDWNEN);
		1341
		1342	DRM_DEBUG_KMS("Setting FIFO watermarks - A: plane=%d, cursor=%d, B: plane=%d, cursor=%d, SR: plane=%d, cursor=%d\n",
		1343	planea_wm, cursora_wm,
		1344	planeb_wm, cursorb_wm,
		1345	plane_sr, cursor_sr);
		1346
		1347	I915_WRITE(DSPFW1,
		1348	(plane_sr << DSPFW_SR_SHIFT) \|
		1349	(cursorb_wm << DSPFW_CURSORB_SHIFT) \|
		1350	(planeb_wm << DSPFW_PLANEB_SHIFT) \|
		1351	planea_wm);
		1352	I915_WRITE(DSPFW2,
		1353	(I915_READ(DSPFW2) & DSPFW_CURSORA_MASK) \|
		1354	(cursora_wm << DSPFW_CURSORA_SHIFT));
		1355	I915_WRITE(DSPFW3,
		1356	(I915_READ(DSPFW3) \| (cursor_sr << DSPFW_CURSOR_SR_SHIFT)));
		1357	}
		1358
		1359	static void g4x_update_wm(struct drm_device *dev)
		1360	{
		1361	static const int sr_latency_ns = 12000;
		1362	struct drm_i915_private *dev_priv = dev->dev_private;
		1363	int planea_wm, planeb_wm, cursora_wm, cursorb_wm;
		1364	int plane_sr, cursor_sr;
		1365	unsigned int enabled = 0;
		1366
		1367	if (g4x_compute_wm0(dev, 0,
		1368	&g4x_wm_info, latency_ns,
		1369	&g4x_cursor_wm_info, latency_ns,
		1370	&planea_wm, &cursora_wm))
		1371	enabled \|= 1;
		1372
		1373	if (g4x_compute_wm0(dev, 1,
		1374	&g4x_wm_info, latency_ns,
		1375	&g4x_cursor_wm_info, latency_ns,
		1376	&planeb_wm, &cursorb_wm))
		1377	enabled \|= 2;
		1378
		1379	plane_sr = cursor_sr = 0;
		1380	if (single_plane_enabled(enabled) &&
		1381	g4x_compute_srwm(dev, ffs(enabled) - 1,
		1382	sr_latency_ns,
		1383	&g4x_wm_info,
		1384	&g4x_cursor_wm_info,
		1385	&plane_sr, &cursor_sr))
		1386	I915_WRITE(FW_BLC_SELF, FW_BLC_SELF_EN);
		1387	else
		1388	I915_WRITE(FW_BLC_SELF,
		1389	I915_READ(FW_BLC_SELF) & ~FW_BLC_SELF_EN);
		1390
		1391	DRM_DEBUG_KMS("Setting FIFO watermarks - A: plane=%d, cursor=%d, B: plane=%d, cursor=%d, SR: plane=%d, cursor=%d\n",
		1392	planea_wm, cursora_wm,
		1393	planeb_wm, cursorb_wm,
		1394	plane_sr, cursor_sr);
		1395
		1396	I915_WRITE(DSPFW1,
		1397	(plane_sr << DSPFW_SR_SHIFT) \|
		1398	(cursorb_wm << DSPFW_CURSORB_SHIFT) \|
		1399	(planeb_wm << DSPFW_PLANEB_SHIFT) \|
		1400	planea_wm);
		1401	I915_WRITE(DSPFW2,
		1402	(I915_READ(DSPFW2) & DSPFW_CURSORA_MASK) \|
		1403	(cursora_wm << DSPFW_CURSORA_SHIFT));
		1404	/* HPLL off in SR has some issues on G4x... disable it */
		1405	I915_WRITE(DSPFW3,
		1406	(I915_READ(DSPFW3) & ~DSPFW_HPLL_SR_EN) \|
		1407	(cursor_sr << DSPFW_CURSOR_SR_SHIFT));
		1408	}
		1409
		1410	static void i965_update_wm(struct drm_device *dev)
		1411	{
		1412	struct drm_i915_private *dev_priv = dev->dev_private;
		1413	struct drm_crtc *crtc;
		1414	int srwm = 1;
		1415	int cursor_sr = 16;
		1416
		1417	/* Calc sr entries for one plane configs */
		1418	crtc = single_enabled_crtc(dev);
		1419	if (crtc) {
		1420	/* self-refresh has much higher latency */
		1421	static const int sr_latency_ns = 12000;
		1422	int clock = crtc->mode.clock;
		1423	int htotal = crtc->mode.htotal;
		1424	int hdisplay = crtc->mode.hdisplay;
		1425	int pixel_size = crtc->fb->bits_per_pixel / 8;
		1426	unsigned long line_time_us;
		1427	int entries;
		1428
		1429	line_time_us = ((htotal * 1000) / clock);
		1430
		1431	/* Use ns/us then divide to preserve precision */
		1432	entries = (((sr_latency_ns / line_time_us) + 1000) / 1000) *
		1433	pixel_size * hdisplay;
		1434	entries = DIV_ROUND_UP(entries, I915_FIFO_LINE_SIZE);
		1435	srwm = I965_FIFO_SIZE - entries;
		1436	if (srwm < 0)
		1437	srwm = 1;
		1438	srwm &= 0x1ff;
		1439	DRM_DEBUG_KMS("self-refresh entries: %d, wm: %d\n",
		1440	entries, srwm);
		1441
		1442	entries = (((sr_latency_ns / line_time_us) + 1000) / 1000) *
		1443	pixel_size * 64;
		1444	entries = DIV_ROUND_UP(entries,
		1445	i965_cursor_wm_info.cacheline_size);
		1446	cursor_sr = i965_cursor_wm_info.fifo_size -
		1447	(entries + i965_cursor_wm_info.guard_size);
		1448
		1449	if (cursor_sr > i965_cursor_wm_info.max_wm)
		1450	cursor_sr = i965_cursor_wm_info.max_wm;
		1451
		1452	DRM_DEBUG_KMS("self-refresh watermark: display plane %d "
		1453	"cursor %d\n", srwm, cursor_sr);
		1454
		1455	if (IS_CRESTLINE(dev))
		1456	I915_WRITE(FW_BLC_SELF, FW_BLC_SELF_EN);
		1457	} else {
		1458	/* Turn off self refresh if both pipes are enabled */
		1459	if (IS_CRESTLINE(dev))
		1460	I915_WRITE(FW_BLC_SELF, I915_READ(FW_BLC_SELF)
		1461	& ~FW_BLC_SELF_EN);
		1462	}
		1463
		1464	DRM_DEBUG_KMS("Setting FIFO watermarks - A: 8, B: 8, C: 8, SR %d\n",
		1465	srwm);
		1466
		1467	/* 965 has limitations... */
		1468	I915_WRITE(DSPFW1, (srwm << DSPFW_SR_SHIFT) \|
		1469	(8 << 16) \| (8 << 8) \| (8 << 0));
		1470	I915_WRITE(DSPFW2, (8 << 8) \| (8 << 0));
		1471	/* update cursor SR watermark */
		1472	I915_WRITE(DSPFW3, (cursor_sr << DSPFW_CURSOR_SR_SHIFT));
		1473	}
		1474
		1475	static void i9xx_update_wm(struct drm_device *dev)
		1476	{
		1477	struct drm_i915_private *dev_priv = dev->dev_private;
		1478	const struct intel_watermark_params *wm_info;
		1479	uint32_t fwater_lo;
		1480	uint32_t fwater_hi;
		1481	int cwm, srwm = 1;
		1482	int fifo_size;
		1483	int planea_wm, planeb_wm;
		1484	struct drm_crtc crtc, enabled = NULL;
		1485
		1486	if (IS_I945GM(dev))
		1487	wm_info = &i945_wm_info;
		1488	else if (!IS_GEN2(dev))
		1489	wm_info = &i915_wm_info;
		1490	else
		1491	wm_info = &i855_wm_info;
		1492
		1493	fifo_size = dev_priv->display.get_fifo_size(dev, 0);
		1494	crtc = intel_get_crtc_for_plane(dev, 0);
		1495	if (crtc->enabled && crtc->fb) {
		1496	planea_wm = intel_calculate_wm(crtc->mode.clock,
		1497	wm_info, fifo_size,
		1498	crtc->fb->bits_per_pixel / 8,
		1499	latency_ns);
		1500	enabled = crtc;
		1501	} else
		1502	planea_wm = fifo_size - wm_info->guard_size;
		1503
		1504	fifo_size = dev_priv->display.get_fifo_size(dev, 1);
		1505	crtc = intel_get_crtc_for_plane(dev, 1);
		1506	if (crtc->enabled && crtc->fb) {
		1507	planeb_wm = intel_calculate_wm(crtc->mode.clock,
		1508	wm_info, fifo_size,
		1509	crtc->fb->bits_per_pixel / 8,
		1510	latency_ns);
		1511	if (enabled == NULL)
		1512	enabled = crtc;
		1513	else
		1514	enabled = NULL;
		1515	} else
		1516	planeb_wm = fifo_size - wm_info->guard_size;
		1517
		1518	DRM_DEBUG_KMS("FIFO watermarks - A: %d, B: %d\n", planea_wm, planeb_wm);
		1519
		1520	/*
		1521	* Overlay gets an aggressive default since video jitter is bad.
		1522	*/
		1523	cwm = 2;
		1524
		1525	/* Play safe and disable self-refresh before adjusting watermarks. */
		1526	if (IS_I945G(dev) \|\| IS_I945GM(dev))
		1527	I915_WRITE(FW_BLC_SELF, FW_BLC_SELF_EN_MASK \| 0);
		1528	else if (IS_I915GM(dev))
		1529	I915_WRITE(INSTPM, I915_READ(INSTPM) & ~INSTPM_SELF_EN);
		1530
		1531	/* Calc sr entries for one plane configs */
		1532	if (HAS_FW_BLC(dev) && enabled) {
		1533	/* self-refresh has much higher latency */
		1534	static const int sr_latency_ns = 6000;
		1535	int clock = enabled->mode.clock;
		1536	int htotal = enabled->mode.htotal;
		1537	int hdisplay = enabled->mode.hdisplay;
		1538	int pixel_size = enabled->fb->bits_per_pixel / 8;
		1539	unsigned long line_time_us;
		1540	int entries;
		1541
		1542	line_time_us = (htotal * 1000) / clock;
		1543
		1544	/* Use ns/us then divide to preserve precision */
		1545	entries = (((sr_latency_ns / line_time_us) + 1000) / 1000) *
		1546	pixel_size * hdisplay;
		1547	entries = DIV_ROUND_UP(entries, wm_info->cacheline_size);
		1548	DRM_DEBUG_KMS("self-refresh entries: %d\n", entries);
		1549	srwm = wm_info->fifo_size - entries;
		1550	if (srwm < 0)
		1551	srwm = 1;
		1552
		1553	if (IS_I945G(dev) \|\| IS_I945GM(dev))
		1554	I915_WRITE(FW_BLC_SELF,
		1555	FW_BLC_SELF_FIFO_MASK \| (srwm & 0xff));
		1556	else if (IS_I915GM(dev))
		1557	I915_WRITE(FW_BLC_SELF, srwm & 0x3f);
		1558	}
		1559
		1560	DRM_DEBUG_KMS("Setting FIFO watermarks - A: %d, B: %d, C: %d, SR %d\n",
		1561	planea_wm, planeb_wm, cwm, srwm);
		1562
		1563	fwater_lo = ((planeb_wm & 0x3f) << 16) \| (planea_wm & 0x3f);
		1564	fwater_hi = (cwm & 0x1f);
		1565
		1566	/* Set request length to 8 cachelines per fetch */
		1567	fwater_lo = fwater_lo \| (1 << 24) \| (1 << 8);
		1568	fwater_hi = fwater_hi \| (1 << 8);
		1569
		1570	I915_WRITE(FW_BLC, fwater_lo);
		1571	I915_WRITE(FW_BLC2, fwater_hi);
		1572
		1573	if (HAS_FW_BLC(dev)) {
		1574	if (enabled) {
		1575	if (IS_I945G(dev) \|\| IS_I945GM(dev))
		1576	I915_WRITE(FW_BLC_SELF,
		1577	FW_BLC_SELF_EN_MASK \| FW_BLC_SELF_EN);
		1578	else if (IS_I915GM(dev))
		1579	I915_WRITE(INSTPM, I915_READ(INSTPM) \| INSTPM_SELF_EN);
		1580	DRM_DEBUG_KMS("memory self refresh enabled\n");
		1581	} else
		1582	DRM_DEBUG_KMS("memory self refresh disabled\n");
		1583	}
		1584	}
		1585
		1586	static void i830_update_wm(struct drm_device *dev)
		1587	{
		1588	struct drm_i915_private *dev_priv = dev->dev_private;
		1589	struct drm_crtc *crtc;
		1590	uint32_t fwater_lo;
		1591	int planea_wm;
		1592
		1593	crtc = single_enabled_crtc(dev);
		1594	if (crtc == NULL)
		1595	return;
		1596
		1597	planea_wm = intel_calculate_wm(crtc->mode.clock, &i830_wm_info,
		1598	dev_priv->display.get_fifo_size(dev, 0),
		1599	crtc->fb->bits_per_pixel / 8,
		1600	latency_ns);
		1601	fwater_lo = I915_READ(FW_BLC) & ~0xfff;
		1602	fwater_lo \|= (3<<8) \| planea_wm;
		1603
		1604	DRM_DEBUG_KMS("Setting FIFO watermarks - A: %d\n", planea_wm);
		1605
		1606	I915_WRITE(FW_BLC, fwater_lo);
		1607	}
		1608
		1609	#define ILK_LP0_PLANE_LATENCY 700
		1610	#define ILK_LP0_CURSOR_LATENCY 1300
		1611
		1612	/*
		1613	* Check the wm result.
		1614	*
		1615	* If any calculated watermark values is larger than the maximum value that
		1616	* can be programmed into the associated watermark register, that watermark
		1617	* must be disabled.
		1618	*/
		1619	static bool ironlake_check_srwm(struct drm_device *dev, int level,
		1620	int fbc_wm, int display_wm, int cursor_wm,
		1621	const struct intel_watermark_params *display,
		1622	const struct intel_watermark_params *cursor)
		1623	{
		1624	struct drm_i915_private *dev_priv = dev->dev_private;
		1625
		1626	DRM_DEBUG_KMS("watermark %d: display plane %d, fbc lines %d,"
		1627	" cursor %d\n", level, display_wm, fbc_wm, cursor_wm);
		1628
		1629	if (fbc_wm > SNB_FBC_MAX_SRWM) {
		1630	DRM_DEBUG_KMS("fbc watermark(%d) is too large(%d), disabling wm%d+\n",
		1631	fbc_wm, SNB_FBC_MAX_SRWM, level);
		1632
		1633	/* fbc has it's own way to disable FBC WM */
		1634	I915_WRITE(DISP_ARB_CTL,
		1635	I915_READ(DISP_ARB_CTL) \| DISP_FBC_WM_DIS);
		1636	return false;
		1637	}
		1638
		1639	if (display_wm > display->max_wm) {
		1640	DRM_DEBUG_KMS("display watermark(%d) is too large(%d), disabling wm%d+\n",
		1641	display_wm, SNB_DISPLAY_MAX_SRWM, level);
		1642	return false;
		1643	}
		1644
		1645	if (cursor_wm > cursor->max_wm) {
		1646	DRM_DEBUG_KMS("cursor watermark(%d) is too large(%d), disabling wm%d+\n",
		1647	cursor_wm, SNB_CURSOR_MAX_SRWM, level);
		1648	return false;
		1649	}
		1650
		1651	if (!(fbc_wm \|\| display_wm \|\| cursor_wm)) {
		1652	DRM_DEBUG_KMS("latency %d is 0, disabling wm%d+\n", level, level);
		1653	return false;
		1654	}
		1655
		1656	return true;
		1657	}
		1658
		1659	/*
		1660	* Compute watermark values of WM[1-3],
		1661	*/
		1662	static bool ironlake_compute_srwm(struct drm_device *dev, int level, int plane,
		1663	int latency_ns,
		1664	const struct intel_watermark_params *display,
		1665	const struct intel_watermark_params *cursor,
		1666	int fbc_wm, int display_wm, int *cursor_wm)
		1667	{
		1668	struct drm_crtc *crtc;
		1669	unsigned long line_time_us;
		1670	int hdisplay, htotal, pixel_size, clock;
		1671	int line_count, line_size;
		1672	int small, large;
		1673	int entries;
		1674
		1675	if (!latency_ns) {
		1676	fbc_wm = display_wm = *cursor_wm = 0;
		1677	return false;
		1678	}
		1679
		1680	crtc = intel_get_crtc_for_plane(dev, plane);
		1681	hdisplay = crtc->mode.hdisplay;
		1682	htotal = crtc->mode.htotal;
		1683	clock = crtc->mode.clock;
		1684	pixel_size = crtc->fb->bits_per_pixel / 8;
		1685
		1686	line_time_us = (htotal * 1000) / clock;
		1687	line_count = (latency_ns / line_time_us + 1000) / 1000;
		1688	line_size = hdisplay * pixel_size;
		1689
		1690	/* Use the minimum of the small and large buffer method for primary */
		1691	small = ((clock * pixel_size / 1000) * latency_ns) / 1000;
		1692	large = line_count * line_size;
		1693
		1694	entries = DIV_ROUND_UP(min(small, large), display->cacheline_size);
		1695	*display_wm = entries + display->guard_size;
		1696
		1697	/*
		1698	* Spec says:
		1699	* FBC WM = ((Final Primary WM * 64) / number of bytes per line) + 2
		1700	*/
		1701	fbc_wm = DIV_ROUND_UP(display_wm * 64, line_size) + 2;
		1702
		1703	/* calculate the self-refresh watermark for display cursor */
		1704	entries = line_count * pixel_size * 64;
		1705	entries = DIV_ROUND_UP(entries, cursor->cacheline_size);
		1706	*cursor_wm = entries + cursor->guard_size;
		1707
		1708	return ironlake_check_srwm(dev, level,
		1709	fbc_wm, display_wm, *cursor_wm,
		1710	display, cursor);
		1711	}
		1712
		1713	static void ironlake_update_wm(struct drm_device *dev)
		1714	{
		1715	struct drm_i915_private *dev_priv = dev->dev_private;
		1716	int fbc_wm, plane_wm, cursor_wm;
		1717	unsigned int enabled;
		1718
		1719	enabled = 0;
		1720	if (g4x_compute_wm0(dev, 0,
		1721	&ironlake_display_wm_info,
		1722	ILK_LP0_PLANE_LATENCY,
		1723	&ironlake_cursor_wm_info,
		1724	ILK_LP0_CURSOR_LATENCY,
		1725	&plane_wm, &cursor_wm)) {
		1726	I915_WRITE(WM0_PIPEA_ILK,
		1727	(plane_wm << WM0_PIPE_PLANE_SHIFT) \| cursor_wm);
		1728	DRM_DEBUG_KMS("FIFO watermarks For pipe A -"
		1729	" plane %d, " "cursor: %d\n",
		1730	plane_wm, cursor_wm);
		1731	enabled \|= 1;
		1732	}
		1733
		1734	if (g4x_compute_wm0(dev, 1,
		1735	&ironlake_display_wm_info,
		1736	ILK_LP0_PLANE_LATENCY,
		1737	&ironlake_cursor_wm_info,
		1738	ILK_LP0_CURSOR_LATENCY,
		1739	&plane_wm, &cursor_wm)) {
		1740	I915_WRITE(WM0_PIPEB_ILK,
		1741	(plane_wm << WM0_PIPE_PLANE_SHIFT) \| cursor_wm);
		1742	DRM_DEBUG_KMS("FIFO watermarks For pipe B -"
		1743	" plane %d, cursor: %d\n",
		1744	plane_wm, cursor_wm);
		1745	enabled \|= 2;
		1746	}
		1747
		1748	/*
		1749	* Calculate and update the self-refresh watermark only when one
		1750	* display plane is used.
		1751	*/
		1752	I915_WRITE(WM3_LP_ILK, 0);
		1753	I915_WRITE(WM2_LP_ILK, 0);
		1754	I915_WRITE(WM1_LP_ILK, 0);
		1755
		1756	if (!single_plane_enabled(enabled))
		1757	return;
		1758	enabled = ffs(enabled) - 1;
		1759
		1760	/* WM1 */
		1761	if (!ironlake_compute_srwm(dev, 1, enabled,
		1762	ILK_READ_WM1_LATENCY() * 500,
		1763	&ironlake_display_srwm_info,
		1764	&ironlake_cursor_srwm_info,
		1765	&fbc_wm, &plane_wm, &cursor_wm))
		1766	return;
		1767
		1768	I915_WRITE(WM1_LP_ILK,
		1769	WM1_LP_SR_EN \|
		1770	(ILK_READ_WM1_LATENCY() << WM1_LP_LATENCY_SHIFT) \|
		1771	(fbc_wm << WM1_LP_FBC_SHIFT) \|
		1772	(plane_wm << WM1_LP_SR_SHIFT) \|
		1773	cursor_wm);
		1774
		1775	/* WM2 */
		1776	if (!ironlake_compute_srwm(dev, 2, enabled,
		1777	ILK_READ_WM2_LATENCY() * 500,
		1778	&ironlake_display_srwm_info,
		1779	&ironlake_cursor_srwm_info,
		1780	&fbc_wm, &plane_wm, &cursor_wm))
		1781	return;
		1782
		1783	I915_WRITE(WM2_LP_ILK,
		1784	WM2_LP_EN \|
		1785	(ILK_READ_WM2_LATENCY() << WM1_LP_LATENCY_SHIFT) \|
		1786	(fbc_wm << WM1_LP_FBC_SHIFT) \|
		1787	(plane_wm << WM1_LP_SR_SHIFT) \|
		1788	cursor_wm);
		1789
		1790	/*
		1791	* WM3 is unsupported on ILK, probably because we don't have latency
		1792	* data for that power state
		1793	*/
		1794	}
		1795
		1796	static void sandybridge_update_wm(struct drm_device *dev)
		1797	{
		1798	struct drm_i915_private *dev_priv = dev->dev_private;
		1799	int latency = SNB_READ_WM0_LATENCY() * 100; /* In unit 0.1us */
		1800	u32 val;
		1801	int fbc_wm, plane_wm, cursor_wm;
		1802	unsigned int enabled;
		1803
		1804	enabled = 0;
		1805	if (g4x_compute_wm0(dev, 0,
		1806	&sandybridge_display_wm_info, latency,
		1807	&sandybridge_cursor_wm_info, latency,
		1808	&plane_wm, &cursor_wm)) {
		1809	val = I915_READ(WM0_PIPEA_ILK);
		1810	val &= ~(WM0_PIPE_PLANE_MASK \| WM0_PIPE_CURSOR_MASK);
		1811	I915_WRITE(WM0_PIPEA_ILK, val \|
		1812	((plane_wm << WM0_PIPE_PLANE_SHIFT) \| cursor_wm));
		1813	DRM_DEBUG_KMS("FIFO watermarks For pipe A -"
		1814	" plane %d, " "cursor: %d\n",
		1815	plane_wm, cursor_wm);
		1816	enabled \|= 1;
		1817	}
		1818
		1819	if (g4x_compute_wm0(dev, 1,
		1820	&sandybridge_display_wm_info, latency,
		1821	&sandybridge_cursor_wm_info, latency,
		1822	&plane_wm, &cursor_wm)) {
		1823	val = I915_READ(WM0_PIPEB_ILK);
		1824	val &= ~(WM0_PIPE_PLANE_MASK \| WM0_PIPE_CURSOR_MASK);
		1825	I915_WRITE(WM0_PIPEB_ILK, val \|
		1826	((plane_wm << WM0_PIPE_PLANE_SHIFT) \| cursor_wm));
		1827	DRM_DEBUG_KMS("FIFO watermarks For pipe B -"
		1828	" plane %d, cursor: %d\n",
		1829	plane_wm, cursor_wm);
		1830	enabled \|= 2;
		1831	}
		1832
		1833	if ((dev_priv->num_pipe == 3) &&
		1834	g4x_compute_wm0(dev, 2,
		1835	&sandybridge_display_wm_info, latency,
		1836	&sandybridge_cursor_wm_info, latency,
		1837	&plane_wm, &cursor_wm)) {
		1838	val = I915_READ(WM0_PIPEC_IVB);
		1839	val &= ~(WM0_PIPE_PLANE_MASK \| WM0_PIPE_CURSOR_MASK);
		1840	I915_WRITE(WM0_PIPEC_IVB, val \|
		1841	((plane_wm << WM0_PIPE_PLANE_SHIFT) \| cursor_wm));
		1842	DRM_DEBUG_KMS("FIFO watermarks For pipe C -"
		1843	" plane %d, cursor: %d\n",
		1844	plane_wm, cursor_wm);
		1845	enabled \|= 3;
		1846	}
		1847
		1848	/*
		1849	* Calculate and update the self-refresh watermark only when one
		1850	* display plane is used.
		1851	*
		1852	* SNB support 3 levels of watermark.
		1853	*
		1854	* WM1/WM2/WM2 watermarks have to be enabled in the ascending order,
		1855	* and disabled in the descending order
		1856	*
		1857	*/
		1858	I915_WRITE(WM3_LP_ILK, 0);
		1859	I915_WRITE(WM2_LP_ILK, 0);
		1860	I915_WRITE(WM1_LP_ILK, 0);
		1861
		1862	if (!single_plane_enabled(enabled) \|\|
		1863	dev_priv->sprite_scaling_enabled)
		1864	return;
		1865	enabled = ffs(enabled) - 1;
		1866
		1867	/* WM1 */
		1868	if (!ironlake_compute_srwm(dev, 1, enabled,
		1869	SNB_READ_WM1_LATENCY() * 500,
		1870	&sandybridge_display_srwm_info,
		1871	&sandybridge_cursor_srwm_info,
		1872	&fbc_wm, &plane_wm, &cursor_wm))
		1873	return;
		1874
		1875	I915_WRITE(WM1_LP_ILK,
		1876	WM1_LP_SR_EN \|
		1877	(SNB_READ_WM1_LATENCY() << WM1_LP_LATENCY_SHIFT) \|
		1878	(fbc_wm << WM1_LP_FBC_SHIFT) \|
		1879	(plane_wm << WM1_LP_SR_SHIFT) \|
		1880	cursor_wm);
		1881
		1882	/* WM2 */
		1883	if (!ironlake_compute_srwm(dev, 2, enabled,
		1884	SNB_READ_WM2_LATENCY() * 500,
		1885	&sandybridge_display_srwm_info,
		1886	&sandybridge_cursor_srwm_info,
		1887	&fbc_wm, &plane_wm, &cursor_wm))
		1888	return;
		1889
		1890	I915_WRITE(WM2_LP_ILK,
		1891	WM2_LP_EN \|
		1892	(SNB_READ_WM2_LATENCY() << WM1_LP_LATENCY_SHIFT) \|
		1893	(fbc_wm << WM1_LP_FBC_SHIFT) \|
		1894	(plane_wm << WM1_LP_SR_SHIFT) \|
		1895	cursor_wm);
		1896
		1897	/* WM3 */
		1898	if (!ironlake_compute_srwm(dev, 3, enabled,
		1899	SNB_READ_WM3_LATENCY() * 500,
		1900	&sandybridge_display_srwm_info,
		1901	&sandybridge_cursor_srwm_info,
		1902	&fbc_wm, &plane_wm, &cursor_wm))
		1903	return;
		1904
		1905	I915_WRITE(WM3_LP_ILK,
		1906	WM3_LP_EN \|
		1907	(SNB_READ_WM3_LATENCY() << WM1_LP_LATENCY_SHIFT) \|
		1908	(fbc_wm << WM1_LP_FBC_SHIFT) \|
		1909	(plane_wm << WM1_LP_SR_SHIFT) \|
		1910	cursor_wm);
		1911	}
		1912
		1913	static void
		1914	haswell_update_linetime_wm(struct drm_device *dev, int pipe,
		1915	struct drm_display_mode *mode)
		1916	{
		1917	struct drm_i915_private *dev_priv = dev->dev_private;
		1918	u32 temp;
		1919
		1920	temp = I915_READ(PIPE_WM_LINETIME(pipe));
		1921	temp &= ~PIPE_WM_LINETIME_MASK;
		1922
		1923	/* The WM are computed with base on how long it takes to fill a single
		1924	* row at the given clock rate, multiplied by 8.
		1925	* */
		1926	temp \|= PIPE_WM_LINETIME_TIME(
		1927	((mode->crtc_hdisplay * 1000) / mode->clock) * 8);
		1928
		1929	/* IPS watermarks are only used by pipe A, and are ignored by
		1930	* pipes B and C. They are calculated similarly to the common
		1931	* linetime values, except that we are using CD clock frequency
		1932	* in MHz instead of pixel rate for the division.
		1933	*
		1934	* This is a placeholder for the IPS watermark calculation code.
		1935	*/
		1936
		1937	I915_WRITE(PIPE_WM_LINETIME(pipe), temp);
		1938	}
		1939
		1940	static bool
		1941	sandybridge_compute_sprite_wm(struct drm_device *dev, int plane,
		1942	uint32_t sprite_width, int pixel_size,
		1943	const struct intel_watermark_params *display,
		1944	int display_latency_ns, int *sprite_wm)
		1945	{
		1946	struct drm_crtc *crtc;
		1947	int clock;
		1948	int entries, tlb_miss;
		1949
		1950	crtc = intel_get_crtc_for_plane(dev, plane);
		1951	if (crtc->fb == NULL \|\| !crtc->enabled) {
		1952	*sprite_wm = display->guard_size;
		1953	return false;
		1954	}
		1955
		1956	clock = crtc->mode.clock;
		1957
		1958	/* Use the small buffer method to calculate the sprite watermark */
		1959	entries = ((clock * pixel_size / 1000) * display_latency_ns) / 1000;
		1960	tlb_miss = display->fifo_size*display->cacheline_size -
		1961	sprite_width * 8;
		1962	if (tlb_miss > 0)
		1963	entries += tlb_miss;
		1964	entries = DIV_ROUND_UP(entries, display->cacheline_size);
		1965	*sprite_wm = entries + display->guard_size;
		1966	if (*sprite_wm > (int)display->max_wm)
		1967	*sprite_wm = display->max_wm;
		1968
		1969	return true;
		1970	}
		1971
		1972	static bool
		1973	sandybridge_compute_sprite_srwm(struct drm_device *dev, int plane,
		1974	uint32_t sprite_width, int pixel_size,
		1975	const struct intel_watermark_params *display,
		1976	int latency_ns, int *sprite_wm)
		1977	{
		1978	struct drm_crtc *crtc;
		1979	unsigned long line_time_us;
		1980	int clock;
		1981	int line_count, line_size;
		1982	int small, large;
		1983	int entries;
		1984
		1985	if (!latency_ns) {
		1986	*sprite_wm = 0;
		1987	return false;
		1988	}
		1989
		1990	crtc = intel_get_crtc_for_plane(dev, plane);
		1991	clock = crtc->mode.clock;
		1992	if (!clock) {
		1993	*sprite_wm = 0;
		1994	return false;
		1995	}
		1996
		1997	line_time_us = (sprite_width * 1000) / clock;
		1998	if (!line_time_us) {
		1999	*sprite_wm = 0;
		2000	return false;
		2001	}
		2002
		2003	line_count = (latency_ns / line_time_us + 1000) / 1000;
		2004	line_size = sprite_width * pixel_size;
		2005
		2006	/* Use the minimum of the small and large buffer method for primary */
		2007	small = ((clock * pixel_size / 1000) * latency_ns) / 1000;
		2008	large = line_count * line_size;
		2009
		2010	entries = DIV_ROUND_UP(min(small, large), display->cacheline_size);
		2011	*sprite_wm = entries + display->guard_size;
		2012
		2013	return *sprite_wm > 0x3ff ? false : true;
		2014	}
		2015
		2016	static void sandybridge_update_sprite_wm(struct drm_device *dev, int pipe,
		2017	uint32_t sprite_width, int pixel_size)
		2018	{
		2019	struct drm_i915_private *dev_priv = dev->dev_private;
		2020	int latency = SNB_READ_WM0_LATENCY() * 100; /* In unit 0.1us */
		2021	u32 val;
		2022	int sprite_wm, reg;
		2023	int ret;
		2024
		2025	switch (pipe) {
		2026	case 0:
		2027	reg = WM0_PIPEA_ILK;
		2028	break;
		2029	case 1:
		2030	reg = WM0_PIPEB_ILK;
		2031	break;
		2032	case 2:
		2033	reg = WM0_PIPEC_IVB;
		2034	break;
		2035	default:
		2036	return; /* bad pipe */
		2037	}
		2038
		2039	ret = sandybridge_compute_sprite_wm(dev, pipe, sprite_width, pixel_size,
		2040	&sandybridge_display_wm_info,
		2041	latency, &sprite_wm);
		2042	if (!ret) {
		2043	DRM_DEBUG_KMS("failed to compute sprite wm for pipe %d\n",
		2044	pipe);
		2045	return;
		2046	}
		2047
		2048	val = I915_READ(reg);
		2049	val &= ~WM0_PIPE_SPRITE_MASK;
		2050	I915_WRITE(reg, val \| (sprite_wm << WM0_PIPE_SPRITE_SHIFT));
		2051	DRM_DEBUG_KMS("sprite watermarks For pipe %d - %d\n", pipe, sprite_wm);
		2052
		2053
		2054	ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width,
		2055	pixel_size,
		2056	&sandybridge_display_srwm_info,
		2057	SNB_READ_WM1_LATENCY() * 500,
		2058	&sprite_wm);
		2059	if (!ret) {
		2060	DRM_DEBUG_KMS("failed to compute sprite lp1 wm on pipe %d\n",
		2061	pipe);
		2062	return;
		2063	}
		2064	I915_WRITE(WM1S_LP_ILK, sprite_wm);
		2065
		2066	/* Only IVB has two more LP watermarks for sprite */
		2067	if (!IS_IVYBRIDGE(dev))
		2068	return;
		2069
		2070	ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width,
		2071	pixel_size,
		2072	&sandybridge_display_srwm_info,
		2073	SNB_READ_WM2_LATENCY() * 500,
		2074	&sprite_wm);
		2075	if (!ret) {
		2076	DRM_DEBUG_KMS("failed to compute sprite lp2 wm on pipe %d\n",
		2077	pipe);
		2078	return;
		2079	}
		2080	I915_WRITE(WM2S_LP_IVB, sprite_wm);
		2081
		2082	ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width,
		2083	pixel_size,
		2084	&sandybridge_display_srwm_info,
		2085	SNB_READ_WM3_LATENCY() * 500,
		2086	&sprite_wm);
		2087	if (!ret) {
		2088	DRM_DEBUG_KMS("failed to compute sprite lp3 wm on pipe %d\n",
		2089	pipe);
		2090	return;
		2091	}
		2092	I915_WRITE(WM3S_LP_IVB, sprite_wm);
		2093	}
		2094
		2095	/**
		2096	* intel_update_watermarks - update FIFO watermark values based on current modes
		2097	*
		2098	* Calculate watermark values for the various WM regs based on current mode
		2099	* and plane configuration.
		2100	*
		2101	* There are several cases to deal with here:
		2102	* - normal (i.e. non-self-refresh)
		2103	* - self-refresh (SR) mode
		2104	* - lines are large relative to FIFO size (buffer can hold up to 2)
		2105	* - lines are small relative to FIFO size (buffer can hold more than 2
		2106	* lines), so need to account for TLB latency
		2107	*
		2108	* The normal calculation is:
		2109	* watermark = dotclock * bytes per pixel * latency
		2110	* where latency is platform & configuration dependent (we assume pessimal
		2111	* values here).
		2112	*
		2113	* The SR calculation is:
		2114	* watermark = (trunc(latency/line time)+1) * surface width *
		2115	* bytes per pixel
		2116	* where
		2117	* line time = htotal / dotclock
		2118	* surface width = hdisplay for normal plane and 64 for cursor
		2119	* and latency is assumed to be high, as above.
		2120	*
		2121	* The final value programmed to the register should always be rounded up,
		2122	* and include an extra 2 entries to account for clock crossings.
		2123	*
		2124	* We don't use the sprite, so we can ignore that. And on Crestline we have
		2125	* to set the non-SR watermarks to 8.
		2126	*/
		2127	void intel_update_watermarks(struct drm_device *dev)
		2128	{
		2129	struct drm_i915_private *dev_priv = dev->dev_private;
		2130
		2131	if (dev_priv->display.update_wm)
		2132	dev_priv->display.update_wm(dev);
		2133	}
		2134
		2135	void intel_update_linetime_watermarks(struct drm_device *dev,
		2136	int pipe, struct drm_display_mode *mode)
		2137	{
		2138	struct drm_i915_private *dev_priv = dev->dev_private;
		2139
		2140	if (dev_priv->display.update_linetime_wm)
		2141	dev_priv->display.update_linetime_wm(dev, pipe, mode);
		2142	}
		2143
		2144	void intel_update_sprite_watermarks(struct drm_device *dev, int pipe,
		2145	uint32_t sprite_width, int pixel_size)
		2146	{
		2147	struct drm_i915_private *dev_priv = dev->dev_private;
		2148
		2149	if (dev_priv->display.update_sprite_wm)
		2150	dev_priv->display.update_sprite_wm(dev, pipe, sprite_width,
		2151	pixel_size);
		2152	}
		2153
		2154	static struct drm_i915_gem_object *
		2155	intel_alloc_context_page(struct drm_device *dev)
		2156	{
		2157	struct drm_i915_gem_object *ctx;
		2158	int ret;
		2159
		2160	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
		2161
		2162	ctx = i915_gem_alloc_object(dev, 4096);
		2163	if (!ctx) {
		2164	DRM_DEBUG("failed to alloc power context, RC6 disabled\n");
		2165	return NULL;
		2166	}
		2167
		2168	ret = i915_gem_object_pin(ctx, 4096, true, false);
		2169	if (ret) {
		2170	DRM_ERROR("failed to pin power context: %d\n", ret);
		2171	goto err_unref;
		2172	}
		2173
		2174	ret = i915_gem_object_set_to_gtt_domain(ctx, 1);
		2175	if (ret) {
		2176	DRM_ERROR("failed to set-domain on power context: %d\n", ret);
		2177	goto err_unpin;
		2178	}
		2179
		2180	return ctx;
		2181
		2182	err_unpin:
		2183	i915_gem_object_unpin(ctx);
		2184	err_unref:
		2185	drm_gem_object_unreference(&ctx->base);
		2186	mutex_unlock(&dev->struct_mutex);
		2187	return NULL;
		2188	}
		2189
		2190	/**
		2191	* Lock protecting IPS related data structures
		2192	*/
		2193	DEFINE_SPINLOCK(mchdev_lock);
		2194
		2195	/* Global for IPS driver to get at the current i915 device. Protected by
		2196	* mchdev_lock. */
		2197	static struct drm_i915_private *i915_mch_dev;
		2198
		2199	bool ironlake_set_drps(struct drm_device *dev, u8 val)
		2200	{
		2201	struct drm_i915_private *dev_priv = dev->dev_private;
		2202	u16 rgvswctl;
		2203
		2204	assert_spin_locked(&mchdev_lock);
		2205
		2206	rgvswctl = I915_READ16(MEMSWCTL);
		2207	if (rgvswctl & MEMCTL_CMD_STS) {
		2208	DRM_DEBUG("gpu busy, RCS change rejected\n");
		2209	return false; /* still busy with another command */
		2210	}
		2211
		2212	rgvswctl = (MEMCTL_CMD_CHFREQ << MEMCTL_CMD_SHIFT) \|
		2213	(val << MEMCTL_FREQ_SHIFT) \| MEMCTL_SFCAVM;
		2214	I915_WRITE16(MEMSWCTL, rgvswctl);
		2215	POSTING_READ16(MEMSWCTL);
		2216
		2217	rgvswctl \|= MEMCTL_CMD_STS;
		2218	I915_WRITE16(MEMSWCTL, rgvswctl);
		2219
		2220	return true;
		2221	}
		2222
		2223	static void ironlake_enable_drps(struct drm_device *dev)
		2224	{
		2225	struct drm_i915_private *dev_priv = dev->dev_private;
		2226	u32 rgvmodectl = I915_READ(MEMMODECTL);
		2227	u8 fmax, fmin, fstart, vstart;
		2228
		2229	spin_lock_irq(&mchdev_lock);
		2230
		2231	/* Enable temp reporting */
		2232	I915_WRITE16(PMMISC, I915_READ(PMMISC) \| MCPPCE_EN);
		2233	I915_WRITE16(TSC1, I915_READ(TSC1) \| TSE);
		2234
		2235	/* 100ms RC evaluation intervals */
		2236	I915_WRITE(RCUPEI, 100000);
		2237	I915_WRITE(RCDNEI, 100000);
		2238
		2239	/* Set max/min thresholds to 90ms and 80ms respectively */
		2240	I915_WRITE(RCBMAXAVG, 90000);
		2241	I915_WRITE(RCBMINAVG, 80000);
		2242
		2243	I915_WRITE(MEMIHYST, 1);
		2244
		2245	/* Set up min, max, and cur for interrupt handling */
		2246	fmax = (rgvmodectl & MEMMODE_FMAX_MASK) >> MEMMODE_FMAX_SHIFT;
		2247	fmin = (rgvmodectl & MEMMODE_FMIN_MASK);
		2248	fstart = (rgvmodectl & MEMMODE_FSTART_MASK) >>
		2249	MEMMODE_FSTART_SHIFT;
		2250
		2251	vstart = (I915_READ(PXVFREQ_BASE + (fstart * 4)) & PXVFREQ_PX_MASK) >>
		2252	PXVFREQ_PX_SHIFT;
		2253
		2254	dev_priv->ips.fmax = fmax; /* IPS callback will increase this */
		2255	dev_priv->ips.fstart = fstart;
		2256
		2257	dev_priv->ips.max_delay = fstart;
		2258	dev_priv->ips.min_delay = fmin;
		2259	dev_priv->ips.cur_delay = fstart;
		2260
		2261	DRM_DEBUG_DRIVER("fmax: %d, fmin: %d, fstart: %d\n",
		2262	fmax, fmin, fstart);
		2263
		2264	I915_WRITE(MEMINTREN, MEMINT_CX_SUPR_EN \| MEMINT_EVAL_CHG_EN);
		2265
		2266	/*
		2267	* Interrupts will be enabled in ironlake_irq_postinstall
		2268	*/
		2269
		2270	I915_WRITE(VIDSTART, vstart);
		2271	POSTING_READ(VIDSTART);
		2272
		2273	rgvmodectl \|= MEMMODE_SWMODE_EN;
		2274	I915_WRITE(MEMMODECTL, rgvmodectl);
		2275
		2276	if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10))
		2277	DRM_ERROR("stuck trying to change perf mode\n");
		2278	mdelay(1);
		2279
		2280	ironlake_set_drps(dev, fstart);
		2281
		2282	dev_priv->ips.last_count1 = I915_READ(0x112e4) + I915_READ(0x112e8) +
		2283	I915_READ(0x112e0);
		2284	dev_priv->ips.last_time1 = jiffies_to_msecs(GetTimerTicks());
		2285	dev_priv->ips.last_count2 = I915_READ(0x112f4);
		2286	// getrawmonotonic(&dev_priv->ips.last_time2);
		2287
		2288	spin_unlock_irq(&mchdev_lock);
		2289	}
		2290
		2291	static void ironlake_disable_drps(struct drm_device *dev)
		2292	{
		2293	struct drm_i915_private *dev_priv = dev->dev_private;
		2294	u16 rgvswctl;
		2295
		2296	spin_lock_irq(&mchdev_lock);
		2297
		2298	rgvswctl = I915_READ16(MEMSWCTL);
		2299
		2300	/* Ack interrupts, disable EFC interrupt */
		2301	I915_WRITE(MEMINTREN, I915_READ(MEMINTREN) & ~MEMINT_EVAL_CHG_EN);
		2302	I915_WRITE(MEMINTRSTS, MEMINT_EVAL_CHG);
		2303	I915_WRITE(DEIER, I915_READ(DEIER) & ~DE_PCU_EVENT);
		2304	I915_WRITE(DEIIR, DE_PCU_EVENT);
		2305	I915_WRITE(DEIMR, I915_READ(DEIMR) \| DE_PCU_EVENT);
		2306
		2307	/* Go back to the starting frequency */
		2308	ironlake_set_drps(dev, dev_priv->ips.fstart);
		2309	mdelay(1);
		2310	rgvswctl \|= MEMCTL_CMD_STS;
		2311	I915_WRITE(MEMSWCTL, rgvswctl);
		2312	mdelay(1);
		2313
		2314	spin_unlock_irq(&mchdev_lock);
		2315	}
		2316
		2317	/* There's a funny hw issue where the hw returns all 0 when reading from
		2318	* GEN6_RP_INTERRUPT_LIMITS. Hence we always need to compute the desired value
		2319	* ourselves, instead of doing a rmw cycle (which might result in us clearing
		2320	* all limits and the gpu stuck at whatever frequency it is at atm).
		2321	*/
		2322	static u32 gen6_rps_limits(struct drm_i915_private dev_priv, u8 val)
		2323	{
		2324	u32 limits;
		2325
		2326	limits = 0;
		2327
		2328	if (*val >= dev_priv->rps.max_delay)
		2329	*val = dev_priv->rps.max_delay;
		2330	limits \|= dev_priv->rps.max_delay << 24;
		2331
		2332	/* Only set the down limit when we've reached the lowest level to avoid
		2333	* getting more interrupts, otherwise leave this clear. This prevents a
		2334	* race in the hw when coming out of rc6: There's a tiny window where
		2335	* the hw runs at the minimal clock before selecting the desired
		2336	* frequency, if the down threshold expires in that window we will not
		2337	* receive a down interrupt. */
		2338	if (*val <= dev_priv->rps.min_delay) {
		2339	*val = dev_priv->rps.min_delay;
		2340	limits \|= dev_priv->rps.min_delay << 16;
		2341	}
		2342
		2343	return limits;
		2344	}
		2345
		2346	void gen6_set_rps(struct drm_device *dev, u8 val)
		2347	{
		2348	struct drm_i915_private *dev_priv = dev->dev_private;
		2349	u32 limits = gen6_rps_limits(dev_priv, &val);
		2350
		2351	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
		2352	WARN_ON(val > dev_priv->rps.max_delay);
		2353	WARN_ON(val < dev_priv->rps.min_delay);
		2354
		2355	if (val == dev_priv->rps.cur_delay)
		2356	return;
		2357
		2358	I915_WRITE(GEN6_RPNSWREQ,
		2359	GEN6_FREQUENCY(val) \|
		2360	GEN6_OFFSET(0) \|
		2361	GEN6_AGGRESSIVE_TURBO);
		2362
		2363	/* Make sure we continue to get interrupts
		2364	* until we hit the minimum or maximum frequencies.
		2365	*/
		2366	I915_WRITE(GEN6_RP_INTERRUPT_LIMITS, limits);
		2367
		2368	POSTING_READ(GEN6_RPNSWREQ);
		2369
		2370	dev_priv->rps.cur_delay = val;
		2371
		2372	trace_intel_gpu_freq_change(val * 50);
		2373	}
		2374
		2375	static void gen6_disable_rps(struct drm_device *dev)
		2376	{
		2377	struct drm_i915_private *dev_priv = dev->dev_private;
		2378
		2379	I915_WRITE(GEN6_RC_CONTROL, 0);
		2380	I915_WRITE(GEN6_RPNSWREQ, 1 << 31);
		2381	I915_WRITE(GEN6_PMINTRMSK, 0xffffffff);
		2382	I915_WRITE(GEN6_PMIER, 0);
		2383	/* Complete PM interrupt masking here doesn't race with the rps work
		2384	* item again unmasking PM interrupts because that is using a different
		2385	* register (PMIMR) to mask PM interrupts. The only risk is in leaving
		2386	* stale bits in PMIIR and PMIMR which gen6_enable_rps will clean up. */
		2387
		2388	spin_lock_irq(&dev_priv->rps.lock);
		2389	dev_priv->rps.pm_iir = 0;
		2390	spin_unlock_irq(&dev_priv->rps.lock);
		2391
		2392	I915_WRITE(GEN6_PMIIR, I915_READ(GEN6_PMIIR));
		2393	}
		2394
		2395	int intel_enable_rc6(const struct drm_device *dev)
		2396	{
		2397	/* Respect the kernel parameter if it is set */
		2398	if (i915_enable_rc6 >= 0)
		2399	return i915_enable_rc6;
		2400
3120	serge	2401	/* Disable RC6 on Ironlake */
		2402	if (INTEL_INFO(dev)->gen == 5)
		2403	return 0;
3031	serge	2404
		2405	if (IS_HASWELL(dev)) {
		2406	DRM_DEBUG_DRIVER("Haswell: only RC6 available\n");
		2407	return INTEL_RC6_ENABLE;
		2408	}
		2409
		2410	/* snb/ivb have more than one rc6 state. */
		2411	if (INTEL_INFO(dev)->gen == 6) {
		2412	DRM_DEBUG_DRIVER("Sandybridge: deep RC6 disabled\n");
		2413	return INTEL_RC6_ENABLE;
		2414	}
		2415
		2416	DRM_DEBUG_DRIVER("RC6 and deep RC6 enabled\n");
		2417	return (INTEL_RC6_ENABLE \| INTEL_RC6p_ENABLE);
		2418	}
		2419
		2420	static void gen6_enable_rps(struct drm_device *dev)
		2421	{
		2422	struct drm_i915_private *dev_priv = dev->dev_private;
		2423	struct intel_ring_buffer *ring;
		2424	u32 rp_state_cap;
		2425	u32 gt_perf_status;
		2426	u32 pcu_mbox, rc6_mask = 0;
		2427	u32 gtfifodbg;
		2428	int rc6_mode;
		2429	int i;
		2430
		2431	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
		2432
		2433	/* Here begins a magic sequence of register writes to enable
		2434	* auto-downclocking.
		2435	*
		2436	* Perhaps there might be some value in exposing these to
		2437	* userspace...
		2438	*/
		2439	I915_WRITE(GEN6_RC_STATE, 0);
		2440
		2441	/* Clear the DBG now so we don't confuse earlier errors */
		2442	if ((gtfifodbg = I915_READ(GTFIFODBG))) {
		2443	DRM_ERROR("GT fifo had a previous error %x\n", gtfifodbg);
		2444	I915_WRITE(GTFIFODBG, gtfifodbg);
		2445	}
		2446
		2447	gen6_gt_force_wake_get(dev_priv);
		2448
		2449	rp_state_cap = I915_READ(GEN6_RP_STATE_CAP);
		2450	gt_perf_status = I915_READ(GEN6_GT_PERF_STATUS);
		2451
		2452	/* In units of 100MHz */
		2453	dev_priv->rps.max_delay = rp_state_cap & 0xff;
		2454	dev_priv->rps.min_delay = (rp_state_cap & 0xff0000) >> 16;
		2455	dev_priv->rps.cur_delay = 0;
		2456
		2457	/* disable the counters and set deterministic thresholds */
		2458	I915_WRITE(GEN6_RC_CONTROL, 0);
		2459
		2460	I915_WRITE(GEN6_RC1_WAKE_RATE_LIMIT, 1000 << 16);
		2461	I915_WRITE(GEN6_RC6_WAKE_RATE_LIMIT, 40 << 16 \| 30);
		2462	I915_WRITE(GEN6_RC6pp_WAKE_RATE_LIMIT, 30);
		2463	I915_WRITE(GEN6_RC_EVALUATION_INTERVAL, 125000);
		2464	I915_WRITE(GEN6_RC_IDLE_HYSTERSIS, 25);
		2465
		2466	for_each_ring(ring, dev_priv, i)
		2467	I915_WRITE(RING_MAX_IDLE(ring->mmio_base), 10);
		2468
		2469	I915_WRITE(GEN6_RC_SLEEP, 0);
		2470	I915_WRITE(GEN6_RC1e_THRESHOLD, 1000);
		2471	I915_WRITE(GEN6_RC6_THRESHOLD, 50000);
		2472	I915_WRITE(GEN6_RC6p_THRESHOLD, 100000);
		2473	I915_WRITE(GEN6_RC6pp_THRESHOLD, 64000); /* unused */
		2474
		2475	/* Check if we are enabling RC6 */
		2476	rc6_mode = intel_enable_rc6(dev_priv->dev);
		2477	if (rc6_mode & INTEL_RC6_ENABLE)
		2478	rc6_mask \|= GEN6_RC_CTL_RC6_ENABLE;
		2479
		2480	/* We don't use those on Haswell */
		2481	if (!IS_HASWELL(dev)) {
		2482	if (rc6_mode & INTEL_RC6p_ENABLE)
		2483	rc6_mask \|= GEN6_RC_CTL_RC6p_ENABLE;
		2484
		2485	if (rc6_mode & INTEL_RC6pp_ENABLE)
		2486	rc6_mask \|= GEN6_RC_CTL_RC6pp_ENABLE;
		2487	}
		2488
		2489	DRM_INFO("Enabling RC6 states: RC6 %s, RC6p %s, RC6pp %s\n",
		2490	(rc6_mask & GEN6_RC_CTL_RC6_ENABLE) ? "on" : "off",
		2491	(rc6_mask & GEN6_RC_CTL_RC6p_ENABLE) ? "on" : "off",
		2492	(rc6_mask & GEN6_RC_CTL_RC6pp_ENABLE) ? "on" : "off");
		2493
		2494	I915_WRITE(GEN6_RC_CONTROL,
		2495	rc6_mask \|
		2496	GEN6_RC_CTL_EI_MODE(1) \|
		2497	GEN6_RC_CTL_HW_ENABLE);
		2498
		2499	I915_WRITE(GEN6_RPNSWREQ,
		2500	GEN6_FREQUENCY(10) \|
		2501	GEN6_OFFSET(0) \|
		2502	GEN6_AGGRESSIVE_TURBO);
		2503	I915_WRITE(GEN6_RC_VIDEO_FREQ,
		2504	GEN6_FREQUENCY(12));
		2505
		2506	I915_WRITE(GEN6_RP_DOWN_TIMEOUT, 1000000);
		2507	I915_WRITE(GEN6_RP_INTERRUPT_LIMITS,
		2508	dev_priv->rps.max_delay << 24 \|
		2509	dev_priv->rps.min_delay << 16);
		2510
		2511	I915_WRITE(GEN6_RP_UP_THRESHOLD, 59400);
		2512	I915_WRITE(GEN6_RP_DOWN_THRESHOLD, 245000);
		2513	I915_WRITE(GEN6_RP_UP_EI, 66000);
		2514	I915_WRITE(GEN6_RP_DOWN_EI, 350000);
		2515
		2516	I915_WRITE(GEN6_RP_IDLE_HYSTERSIS, 10);
		2517	I915_WRITE(GEN6_RP_CONTROL,
		2518	GEN6_RP_MEDIA_TURBO \|
		2519	GEN6_RP_MEDIA_HW_NORMAL_MODE \|
		2520	GEN6_RP_MEDIA_IS_GFX \|
		2521	GEN6_RP_ENABLE \|
		2522	GEN6_RP_UP_BUSY_AVG \|
		2523	(IS_HASWELL(dev) ? GEN7_RP_DOWN_IDLE_AVG : GEN6_RP_DOWN_IDLE_CONT));
		2524
		2525	if (wait_for((I915_READ(GEN6_PCODE_MAILBOX) & GEN6_PCODE_READY) == 0,
		2526	500))
		2527	DRM_ERROR("timeout waiting for pcode mailbox to become idle\n");
		2528
		2529	I915_WRITE(GEN6_PCODE_DATA, 0);
		2530	I915_WRITE(GEN6_PCODE_MAILBOX,
		2531	GEN6_PCODE_READY \|
		2532	GEN6_PCODE_WRITE_MIN_FREQ_TABLE);
		2533	if (wait_for((I915_READ(GEN6_PCODE_MAILBOX) & GEN6_PCODE_READY) == 0,
		2534	500))
		2535	DRM_ERROR("timeout waiting for pcode mailbox to finish\n");
		2536
		2537	/* Check for overclock support */
		2538	if (wait_for((I915_READ(GEN6_PCODE_MAILBOX) & GEN6_PCODE_READY) == 0,
		2539	500))
		2540	DRM_ERROR("timeout waiting for pcode mailbox to become idle\n");
		2541	I915_WRITE(GEN6_PCODE_MAILBOX, GEN6_READ_OC_PARAMS);
		2542	pcu_mbox = I915_READ(GEN6_PCODE_DATA);
		2543	if (wait_for((I915_READ(GEN6_PCODE_MAILBOX) & GEN6_PCODE_READY) == 0,
		2544	500))
		2545	DRM_ERROR("timeout waiting for pcode mailbox to finish\n");
		2546	if (pcu_mbox & (1<<31)) { /* OC supported */
		2547	dev_priv->rps.max_delay = pcu_mbox & 0xff;
		2548	DRM_DEBUG_DRIVER("overclocking supported, adjusting frequency max to %dMHz\n", pcu_mbox * 50);
		2549	}
		2550
		2551	gen6_set_rps(dev_priv->dev, (gt_perf_status & 0xff00) >> 8);
		2552
		2553	/* requires MSI enabled */
		2554	I915_WRITE(GEN6_PMIER, GEN6_PM_DEFERRED_EVENTS);
		2555	spin_lock_irq(&dev_priv->rps.lock);
		2556	WARN_ON(dev_priv->rps.pm_iir != 0);
		2557	I915_WRITE(GEN6_PMIMR, 0);
		2558	spin_unlock_irq(&dev_priv->rps.lock);
		2559	/* enable all PM interrupts */
		2560	I915_WRITE(GEN6_PMINTRMSK, 0);
		2561
		2562	gen6_gt_force_wake_put(dev_priv);
		2563	}
		2564
		2565	#if 0
		2566	static void gen6_update_ring_freq(struct drm_device *dev)
		2567	{
		2568	struct drm_i915_private *dev_priv = dev->dev_private;
		2569	int min_freq = 15;
		2570	int gpu_freq, ia_freq, max_ia_freq;
		2571	int scaling_factor = 180;
		2572
		2573	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
		2574
		2575	max_ia_freq = cpufreq_quick_get_max(0);
		2576	/*
		2577	* Default to measured freq if none found, PCU will ensure we don't go
		2578	* over
		2579	*/
		2580	if (!max_ia_freq)
		2581	max_ia_freq = tsc_khz;
		2582
		2583	/* Convert from kHz to MHz */
		2584	max_ia_freq /= 1000;
		2585
		2586	/*
		2587	* For each potential GPU frequency, load a ring frequency we'd like
		2588	* to use for memory access. We do this by specifying the IA frequency
		2589	* the PCU should use as a reference to determine the ring frequency.
		2590	*/
		2591	for (gpu_freq = dev_priv->rps.max_delay; gpu_freq >= dev_priv->rps.min_delay;
		2592	gpu_freq--) {
		2593	int diff = dev_priv->rps.max_delay - gpu_freq;
		2594
		2595	/*
		2596	* For GPU frequencies less than 750MHz, just use the lowest
		2597	* ring freq.
		2598	*/
		2599	if (gpu_freq < min_freq)
		2600	ia_freq = 800;
		2601	else
		2602	ia_freq = max_ia_freq - ((diff * scaling_factor) / 2);
		2603	ia_freq = DIV_ROUND_CLOSEST(ia_freq, 100);
		2604
		2605	I915_WRITE(GEN6_PCODE_DATA,
		2606	(ia_freq << GEN6_PCODE_FREQ_IA_RATIO_SHIFT) \|
		2607	gpu_freq);
		2608	I915_WRITE(GEN6_PCODE_MAILBOX, GEN6_PCODE_READY \|
		2609	GEN6_PCODE_WRITE_MIN_FREQ_TABLE);
		2610	if (wait_for((I915_READ(GEN6_PCODE_MAILBOX) &
		2611	GEN6_PCODE_READY) == 0, 10)) {
		2612	DRM_ERROR("pcode write of freq table timed out\n");
		2613	continue;
		2614	}
		2615	}
		2616	}
		2617	#endif
		2618
		2619	void ironlake_teardown_rc6(struct drm_device *dev)
		2620	{
		2621	struct drm_i915_private *dev_priv = dev->dev_private;
		2622
		2623	if (dev_priv->renderctx) {
		2624	i915_gem_object_unpin(dev_priv->renderctx);
		2625	drm_gem_object_unreference(&dev_priv->renderctx->base);
		2626	dev_priv->renderctx = NULL;
		2627	}
		2628
		2629	if (dev_priv->pwrctx) {
		2630	i915_gem_object_unpin(dev_priv->pwrctx);
		2631	drm_gem_object_unreference(&dev_priv->pwrctx->base);
		2632	dev_priv->pwrctx = NULL;
		2633	}
		2634	}
		2635
		2636	static void ironlake_disable_rc6(struct drm_device *dev)
		2637	{
		2638	struct drm_i915_private *dev_priv = dev->dev_private;
		2639
		2640	if (I915_READ(PWRCTXA)) {
		2641	/* Wake the GPU, prevent RC6, then restore RSTDBYCTL */
		2642	I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) \| RCX_SW_EXIT);
		2643	wait_for(((I915_READ(RSTDBYCTL) & RSX_STATUS_MASK) == RSX_STATUS_ON),
		2644	50);
		2645
		2646	I915_WRITE(PWRCTXA, 0);
		2647	POSTING_READ(PWRCTXA);
		2648
		2649	I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) & ~RCX_SW_EXIT);
		2650	POSTING_READ(RSTDBYCTL);
		2651	}
		2652	}
		2653
		2654	static int ironlake_setup_rc6(struct drm_device *dev)
		2655	{
		2656	struct drm_i915_private *dev_priv = dev->dev_private;
		2657
		2658	if (dev_priv->renderctx == NULL)
		2659	dev_priv->renderctx = intel_alloc_context_page(dev);
		2660	if (!dev_priv->renderctx)
		2661	return -ENOMEM;
		2662
		2663	if (dev_priv->pwrctx == NULL)
		2664	dev_priv->pwrctx = intel_alloc_context_page(dev);
		2665	if (!dev_priv->pwrctx) {
		2666	ironlake_teardown_rc6(dev);
		2667	return -ENOMEM;
		2668	}
		2669
		2670	return 0;
		2671	}
		2672
		2673	static void ironlake_enable_rc6(struct drm_device *dev)
		2674	{
		2675	struct drm_i915_private *dev_priv = dev->dev_private;
		2676	struct intel_ring_buffer *ring = &dev_priv->ring[RCS];
		2677	int ret;
		2678
		2679	/* rc6 disabled by default due to repeated reports of hanging during
		2680	* boot and resume.
		2681	*/
		2682	if (!intel_enable_rc6(dev))
		2683	return;
		2684
		2685	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
		2686
		2687	ret = ironlake_setup_rc6(dev);
		2688	if (ret)
		2689	return;
		2690
		2691	/*
		2692	* GPU can automatically power down the render unit if given a page
		2693	* to save state.
		2694	*/
		2695	ret = intel_ring_begin(ring, 6);
		2696	if (ret) {
		2697	ironlake_teardown_rc6(dev);
		2698	return;
		2699	}
		2700
		2701	intel_ring_emit(ring, MI_SUSPEND_FLUSH \| MI_SUSPEND_FLUSH_EN);
		2702	intel_ring_emit(ring, MI_SET_CONTEXT);
		2703	intel_ring_emit(ring, dev_priv->renderctx->gtt_offset \|
		2704	MI_MM_SPACE_GTT \|
		2705	MI_SAVE_EXT_STATE_EN \|
		2706	MI_RESTORE_EXT_STATE_EN \|
		2707	MI_RESTORE_INHIBIT);
		2708	intel_ring_emit(ring, MI_SUSPEND_FLUSH);
		2709	intel_ring_emit(ring, MI_NOOP);
		2710	intel_ring_emit(ring, MI_FLUSH);
		2711	intel_ring_advance(ring);
		2712
		2713	/*
		2714	* Wait for the command parser to advance past MI_SET_CONTEXT. The HW
		2715	* does an implicit flush, combined with MI_FLUSH above, it should be
		2716	* safe to assume that renderctx is valid
		2717	*/
		2718	ret = intel_wait_ring_idle(ring);
		2719	if (ret) {
		2720	DRM_ERROR("failed to enable ironlake power power savings\n");
		2721	ironlake_teardown_rc6(dev);
		2722	return;
		2723	}
		2724
		2725	I915_WRITE(PWRCTXA, dev_priv->pwrctx->gtt_offset \| PWRCTX_EN);
		2726	I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) & ~RCX_SW_EXIT);
		2727	}
		2728
		2729	static unsigned long intel_pxfreq(u32 vidfreq)
		2730	{
		2731	unsigned long freq;
		2732	int div = (vidfreq & 0x3f0000) >> 16;
		2733	int post = (vidfreq & 0x3000) >> 12;
		2734	int pre = (vidfreq & 0x7);
		2735
		2736	if (!pre)
		2737	return 0;
		2738
		2739	freq = ((div * 133333) / ((1<
		2740
		2741	return freq;
		2742	}
		2743
		2744	static const struct cparams {
		2745	u16 i;
		2746	u16 t;
		2747	u16 m;
		2748	u16 c;
		2749	} cparams[] = {
		2750	{ 1, 1333, 301, 28664 },
		2751	{ 1, 1066, 294, 24460 },
		2752	{ 1, 800, 294, 25192 },
		2753	{ 0, 1333, 276, 27605 },
		2754	{ 0, 1066, 276, 27605 },
		2755	{ 0, 800, 231, 23784 },
		2756	};
		2757
		2758	static unsigned long __i915_chipset_val(struct drm_i915_private *dev_priv)
		2759	{
		2760	u64 total_count, diff, ret;
		2761	u32 count1, count2, count3, m = 0, c = 0;
		2762	unsigned long now = jiffies_to_msecs(GetTimerTicks()), diff1;
		2763	int i;
		2764
		2765	assert_spin_locked(&mchdev_lock);
		2766
		2767	diff1 = now - dev_priv->ips.last_time1;
		2768
		2769	/* Prevent division-by-zero if we are asking too fast.
		2770	* Also, we don't get interesting results if we are polling
		2771	* faster than once in 10ms, so just return the saved value
		2772	* in such cases.
		2773	*/
		2774	if (diff1 <= 10)
		2775	return dev_priv->ips.chipset_power;
		2776
		2777	count1 = I915_READ(DMIEC);
		2778	count2 = I915_READ(DDREC);
		2779	count3 = I915_READ(CSIEC);
		2780
		2781	total_count = count1 + count2 + count3;
		2782
		2783	/* FIXME: handle per-counter overflow */
		2784	if (total_count < dev_priv->ips.last_count1) {
		2785	diff = ~0UL - dev_priv->ips.last_count1;
		2786	diff += total_count;
		2787	} else {
		2788	diff = total_count - dev_priv->ips.last_count1;
		2789	}
		2790
		2791	for (i = 0; i < ARRAY_SIZE(cparams); i++) {
		2792	if (cparams[i].i == dev_priv->ips.c_m &&
		2793	cparams[i].t == dev_priv->ips.r_t) {
		2794	m = cparams[i].m;
		2795	c = cparams[i].c;
		2796	break;
		2797	}
		2798	}
		2799
		2800	diff = div_u64(diff, diff1);
		2801	ret = ((m * diff) + c);
		2802	ret = div_u64(ret, 10);
		2803
		2804	dev_priv->ips.last_count1 = total_count;
		2805	dev_priv->ips.last_time1 = now;
		2806
		2807	dev_priv->ips.chipset_power = ret;
		2808
		2809	return ret;
		2810	}
		2811
		2812	unsigned long i915_chipset_val(struct drm_i915_private *dev_priv)
		2813	{
		2814	unsigned long val;
		2815
		2816	if (dev_priv->info->gen != 5)
		2817	return 0;
		2818
		2819	spin_lock_irq(&mchdev_lock);
		2820
		2821	val = __i915_chipset_val(dev_priv);
		2822
		2823	spin_unlock_irq(&mchdev_lock);
		2824
		2825	return val;
		2826	}
		2827
		2828	unsigned long i915_mch_val(struct drm_i915_private *dev_priv)
		2829	{
		2830	unsigned long m, x, b;
		2831	u32 tsfs;
		2832
		2833	tsfs = I915_READ(TSFS);
		2834
		2835	m = ((tsfs & TSFS_SLOPE_MASK) >> TSFS_SLOPE_SHIFT);
		2836	x = I915_READ8(TR1);
		2837
		2838	b = tsfs & TSFS_INTR_MASK;
		2839
		2840	return ((m * x) / 127) - b;
		2841	}
		2842
		2843	static u16 pvid_to_extvid(struct drm_i915_private *dev_priv, u8 pxvid)
		2844	{
		2845	static const struct v_table {
		2846	u16 vd; /* in .1 mil */
		2847	u16 vm; /* in .1 mil */
		2848	} v_table[] = {
		2849	{ 0, 0, },
		2850	{ 375, 0, },
		2851	{ 500, 0, },
		2852	{ 625, 0, },
		2853	{ 750, 0, },
		2854	{ 875, 0, },
		2855	{ 1000, 0, },
		2856	{ 1125, 0, },
		2857	{ 4125, 3000, },
		2858	{ 4125, 3000, },
		2859	{ 4125, 3000, },
		2860	{ 4125, 3000, },
		2861	{ 4125, 3000, },
		2862	{ 4125, 3000, },
		2863	{ 4125, 3000, },
		2864	{ 4125, 3000, },
		2865	{ 4125, 3000, },
		2866	{ 4125, 3000, },
		2867	{ 4125, 3000, },
		2868	{ 4125, 3000, },
		2869	{ 4125, 3000, },
		2870	{ 4125, 3000, },
		2871	{ 4125, 3000, },
		2872	{ 4125, 3000, },
		2873	{ 4125, 3000, },
		2874	{ 4125, 3000, },
		2875	{ 4125, 3000, },
		2876	{ 4125, 3000, },
		2877	{ 4125, 3000, },
		2878	{ 4125, 3000, },
		2879	{ 4125, 3000, },
		2880	{ 4125, 3000, },
		2881	{ 4250, 3125, },
		2882	{ 4375, 3250, },
		2883	{ 4500, 3375, },
		2884	{ 4625, 3500, },
		2885	{ 4750, 3625, },
		2886	{ 4875, 3750, },
		2887	{ 5000, 3875, },
		2888	{ 5125, 4000, },
		2889	{ 5250, 4125, },
		2890	{ 5375, 4250, },
		2891	{ 5500, 4375, },
		2892	{ 5625, 4500, },
		2893	{ 5750, 4625, },
		2894	{ 5875, 4750, },
		2895	{ 6000, 4875, },
		2896	{ 6125, 5000, },
		2897	{ 6250, 5125, },
		2898	{ 6375, 5250, },
		2899	{ 6500, 5375, },
		2900	{ 6625, 5500, },
		2901	{ 6750, 5625, },
		2902	{ 6875, 5750, },
		2903	{ 7000, 5875, },
		2904	{ 7125, 6000, },
		2905	{ 7250, 6125, },
		2906	{ 7375, 6250, },
		2907	{ 7500, 6375, },
		2908	{ 7625, 6500, },
		2909	{ 7750, 6625, },
		2910	{ 7875, 6750, },
		2911	{ 8000, 6875, },
		2912	{ 8125, 7000, },
		2913	{ 8250, 7125, },
		2914	{ 8375, 7250, },
		2915	{ 8500, 7375, },
		2916	{ 8625, 7500, },
		2917	{ 8750, 7625, },
		2918	{ 8875, 7750, },
		2919	{ 9000, 7875, },
		2920	{ 9125, 8000, },
		2921	{ 9250, 8125, },
		2922	{ 9375, 8250, },
		2923	{ 9500, 8375, },
		2924	{ 9625, 8500, },
		2925	{ 9750, 8625, },
		2926	{ 9875, 8750, },
		2927	{ 10000, 8875, },
		2928	{ 10125, 9000, },
		2929	{ 10250, 9125, },
		2930	{ 10375, 9250, },
		2931	{ 10500, 9375, },
		2932	{ 10625, 9500, },
		2933	{ 10750, 9625, },
		2934	{ 10875, 9750, },
		2935	{ 11000, 9875, },
		2936	{ 11125, 10000, },
		2937	{ 11250, 10125, },
		2938	{ 11375, 10250, },
		2939	{ 11500, 10375, },
		2940	{ 11625, 10500, },
		2941	{ 11750, 10625, },
		2942	{ 11875, 10750, },
		2943	{ 12000, 10875, },
		2944	{ 12125, 11000, },
		2945	{ 12250, 11125, },
		2946	{ 12375, 11250, },
		2947	{ 12500, 11375, },
		2948	{ 12625, 11500, },
		2949	{ 12750, 11625, },
		2950	{ 12875, 11750, },
		2951	{ 13000, 11875, },
		2952	{ 13125, 12000, },
		2953	{ 13250, 12125, },
		2954	{ 13375, 12250, },
		2955	{ 13500, 12375, },
		2956	{ 13625, 12500, },
		2957	{ 13750, 12625, },
		2958	{ 13875, 12750, },
		2959	{ 14000, 12875, },
		2960	{ 14125, 13000, },
		2961	{ 14250, 13125, },
		2962	{ 14375, 13250, },
		2963	{ 14500, 13375, },
		2964	{ 14625, 13500, },
		2965	{ 14750, 13625, },
		2966	{ 14875, 13750, },
		2967	{ 15000, 13875, },
		2968	{ 15125, 14000, },
		2969	{ 15250, 14125, },
		2970	{ 15375, 14250, },
		2971	{ 15500, 14375, },
		2972	{ 15625, 14500, },
		2973	{ 15750, 14625, },
		2974	{ 15875, 14750, },
		2975	{ 16000, 14875, },
		2976	{ 16125, 15000, },
		2977	};
		2978	if (dev_priv->info->is_mobile)
		2979	return v_table[pxvid].vm;
		2980	else
		2981	return v_table[pxvid].vd;
		2982	}
		2983
		2984	static void __i915_update_gfx_val(struct drm_i915_private *dev_priv)
		2985	{
		2986	struct timespec now, diff1;
		2987	u64 diff;
		2988	unsigned long diffms;
		2989	u32 count;
		2990
		2991	assert_spin_locked(&mchdev_lock);
		2992
		2993	getrawmonotonic(&now);
		2994	diff1 = timespec_sub(now, dev_priv->ips.last_time2);
		2995
		2996	/* Don't divide by 0 */
		2997	diffms = diff1.tv_sec * 1000 + diff1.tv_nsec / 1000000;
		2998	if (!diffms)
		2999	return;
		3000
		3001	count = I915_READ(GFXEC);
		3002
		3003	if (count < dev_priv->ips.last_count2) {
		3004	diff = ~0UL - dev_priv->ips.last_count2;
		3005	diff += count;
		3006	} else {
		3007	diff = count - dev_priv->ips.last_count2;
		3008	}
		3009
		3010	dev_priv->ips.last_count2 = count;
		3011	dev_priv->ips.last_time2 = now;
		3012
		3013	/* More magic constants... */
		3014	diff = diff * 1181;
		3015	diff = div_u64(diff, diffms * 10);
		3016	dev_priv->ips.gfx_power = diff;
		3017	}
		3018
		3019	void i915_update_gfx_val(struct drm_i915_private *dev_priv)
		3020	{
		3021	if (dev_priv->info->gen != 5)
		3022	return;
		3023
		3024	spin_lock_irq(&mchdev_lock);
		3025
		3026	__i915_update_gfx_val(dev_priv);
		3027
		3028	spin_unlock_irq(&mchdev_lock);
		3029	}
		3030
		3031	static unsigned long __i915_gfx_val(struct drm_i915_private *dev_priv)
		3032	{
		3033	unsigned long t, corr, state1, corr2, state2;
		3034	u32 pxvid, ext_v;
		3035
		3036	assert_spin_locked(&mchdev_lock);
		3037
		3038	pxvid = I915_READ(PXVFREQ_BASE + (dev_priv->rps.cur_delay * 4));
		3039	pxvid = (pxvid >> 24) & 0x7f;
		3040	ext_v = pvid_to_extvid(dev_priv, pxvid);
		3041
		3042	state1 = ext_v;
		3043
		3044	t = i915_mch_val(dev_priv);
		3045
		3046	/* Revel in the empirically derived constants */
		3047
		3048	/* Correction factor in 1/100000 units */
		3049	if (t > 80)
		3050	corr = ((t * 2349) + 135940);
		3051	else if (t >= 50)
		3052	corr = ((t * 964) + 29317);
		3053	else /* < 50 */
		3054	corr = ((t * 301) + 1004);
		3055
		3056	corr = corr * ((150142 * state1) / 10000 - 78642);
		3057	corr /= 100000;
		3058	corr2 = (corr * dev_priv->ips.corr);
		3059
		3060	state2 = (corr2 * state1) / 10000;
		3061	state2 /= 100; /* convert to mW */
		3062
		3063	__i915_update_gfx_val(dev_priv);
		3064
		3065	return dev_priv->ips.gfx_power + state2;
		3066	}
		3067
		3068	unsigned long i915_gfx_val(struct drm_i915_private *dev_priv)
		3069	{
		3070	unsigned long val;
		3071
		3072	if (dev_priv->info->gen != 5)
		3073	return 0;
		3074
		3075	spin_lock_irq(&mchdev_lock);
		3076
		3077	val = __i915_gfx_val(dev_priv);
		3078
		3079	spin_unlock_irq(&mchdev_lock);
		3080
		3081	return val;
		3082	}
		3083
		3084	/**
		3085	* i915_read_mch_val - return value for IPS use
		3086	*
		3087	* Calculate and return a value for the IPS driver to use when deciding whether
		3088	* we have thermal and power headroom to increase CPU or GPU power budget.
		3089	*/
		3090	unsigned long i915_read_mch_val(void)
		3091	{
		3092	struct drm_i915_private *dev_priv;
		3093	unsigned long chipset_val, graphics_val, ret = 0;
		3094
		3095	spin_lock_irq(&mchdev_lock);
		3096	if (!i915_mch_dev)
		3097	goto out_unlock;
		3098	dev_priv = i915_mch_dev;
		3099
		3100	chipset_val = __i915_chipset_val(dev_priv);
		3101	graphics_val = __i915_gfx_val(dev_priv);
		3102
		3103	ret = chipset_val + graphics_val;
		3104
		3105	out_unlock:
		3106	spin_unlock_irq(&mchdev_lock);
		3107
		3108	return ret;
		3109	}
		3110	EXPORT_SYMBOL_GPL(i915_read_mch_val);
		3111
		3112	/**
		3113	* i915_gpu_raise - raise GPU frequency limit
		3114	*
		3115	* Raise the limit; IPS indicates we have thermal headroom.
		3116	*/
		3117	bool i915_gpu_raise(void)
		3118	{
		3119	struct drm_i915_private *dev_priv;
		3120	bool ret = true;
		3121
		3122	spin_lock_irq(&mchdev_lock);
		3123	if (!i915_mch_dev) {
		3124	ret = false;
		3125	goto out_unlock;
		3126	}
		3127	dev_priv = i915_mch_dev;
		3128
		3129	if (dev_priv->ips.max_delay > dev_priv->ips.fmax)
		3130	dev_priv->ips.max_delay--;
		3131
		3132	out_unlock:
		3133	spin_unlock_irq(&mchdev_lock);
		3134
		3135	return ret;
		3136	}
		3137	EXPORT_SYMBOL_GPL(i915_gpu_raise);
		3138
		3139	/**
		3140	* i915_gpu_lower - lower GPU frequency limit
		3141	*
		3142	* IPS indicates we're close to a thermal limit, so throttle back the GPU
		3143	* frequency maximum.
		3144	*/
		3145	bool i915_gpu_lower(void)
		3146	{
		3147	struct drm_i915_private *dev_priv;
		3148	bool ret = true;
		3149
		3150	spin_lock_irq(&mchdev_lock);
		3151	if (!i915_mch_dev) {
		3152	ret = false;
		3153	goto out_unlock;
		3154	}
		3155	dev_priv = i915_mch_dev;
		3156
		3157	if (dev_priv->ips.max_delay < dev_priv->ips.min_delay)
		3158	dev_priv->ips.max_delay++;
		3159
		3160	out_unlock:
		3161	spin_unlock_irq(&mchdev_lock);
		3162
		3163	return ret;
		3164	}
		3165	EXPORT_SYMBOL_GPL(i915_gpu_lower);
		3166
		3167	/**
		3168	* i915_gpu_busy - indicate GPU business to IPS
		3169	*
		3170	* Tell the IPS driver whether or not the GPU is busy.
		3171	*/
		3172	bool i915_gpu_busy(void)
		3173	{
		3174	struct drm_i915_private *dev_priv;
		3175	struct intel_ring_buffer *ring;
		3176	bool ret = false;
		3177	int i;
		3178
		3179	spin_lock_irq(&mchdev_lock);
		3180	if (!i915_mch_dev)
		3181	goto out_unlock;
		3182	dev_priv = i915_mch_dev;
		3183
		3184	for_each_ring(ring, dev_priv, i)
		3185	ret \|= !list_empty(&ring->request_list);
		3186
		3187	out_unlock:
		3188	spin_unlock_irq(&mchdev_lock);
		3189
		3190	return ret;
		3191	}
		3192	EXPORT_SYMBOL_GPL(i915_gpu_busy);
		3193
		3194	/**
		3195	* i915_gpu_turbo_disable - disable graphics turbo
		3196	*
		3197	* Disable graphics turbo by resetting the max frequency and setting the
		3198	* current frequency to the default.
		3199	*/
		3200	bool i915_gpu_turbo_disable(void)
		3201	{
		3202	struct drm_i915_private *dev_priv;
		3203	bool ret = true;
		3204
		3205	spin_lock_irq(&mchdev_lock);
		3206	if (!i915_mch_dev) {
		3207	ret = false;
		3208	goto out_unlock;
		3209	}
		3210	dev_priv = i915_mch_dev;
		3211
		3212	dev_priv->ips.max_delay = dev_priv->ips.fstart;
		3213
		3214	if (!ironlake_set_drps(dev_priv->dev, dev_priv->ips.fstart))
		3215	ret = false;
		3216
		3217	out_unlock:
		3218	spin_unlock_irq(&mchdev_lock);
		3219
		3220	return ret;
		3221	}
		3222	EXPORT_SYMBOL_GPL(i915_gpu_turbo_disable);
		3223
		3224	/**
		3225	* Tells the intel_ips driver that the i915 driver is now loaded, if
		3226	* IPS got loaded first.
		3227	*
		3228	* This awkward dance is so that neither module has to depend on the
		3229	* other in order for IPS to do the appropriate communication of
		3230	* GPU turbo limits to i915.
		3231	*/
		3232	static void
		3233	ips_ping_for_i915_load(void)
		3234	{
		3235	void (*link)(void);
		3236
		3237	// link = symbol_get(ips_link_to_i915_driver);
		3238	// if (link) {
		3239	// link();
		3240	// symbol_put(ips_link_to_i915_driver);
		3241	// }
		3242	}
		3243
		3244	void intel_gpu_ips_init(struct drm_i915_private *dev_priv)
		3245	{
		3246	/* We only register the i915 ips part with intel-ips once everything is
		3247	* set up, to avoid intel-ips sneaking in and reading bogus values. */
		3248	spin_lock_irq(&mchdev_lock);
		3249	i915_mch_dev = dev_priv;
		3250	spin_unlock_irq(&mchdev_lock);
		3251
		3252	ips_ping_for_i915_load();
		3253	}
		3254
		3255	void intel_gpu_ips_teardown(void)
		3256	{
		3257	spin_lock_irq(&mchdev_lock);
		3258	i915_mch_dev = NULL;
		3259	spin_unlock_irq(&mchdev_lock);
		3260	}
		3261	static void intel_init_emon(struct drm_device *dev)
		3262	{
		3263	struct drm_i915_private *dev_priv = dev->dev_private;
		3264	u32 lcfuse;
		3265	u8 pxw[16];
		3266	int i;
		3267
		3268	/* Disable to program */
		3269	I915_WRITE(ECR, 0);
		3270	POSTING_READ(ECR);
		3271
		3272	/* Program energy weights for various events */
		3273	I915_WRITE(SDEW, 0x15040d00);
		3274	I915_WRITE(CSIEW0, 0x007f0000);
		3275	I915_WRITE(CSIEW1, 0x1e220004);
		3276	I915_WRITE(CSIEW2, 0x04000004);
		3277
		3278	for (i = 0; i < 5; i++)
		3279	I915_WRITE(PEW + (i * 4), 0);
		3280	for (i = 0; i < 3; i++)
		3281	I915_WRITE(DEW + (i * 4), 0);
		3282
		3283	/* Program P-state weights to account for frequency power adjustment */
		3284	for (i = 0; i < 16; i++) {
		3285	u32 pxvidfreq = I915_READ(PXVFREQ_BASE + (i * 4));
		3286	unsigned long freq = intel_pxfreq(pxvidfreq);
		3287	unsigned long vid = (pxvidfreq & PXVFREQ_PX_MASK) >>
		3288	PXVFREQ_PX_SHIFT;
		3289	unsigned long val;
		3290
		3291	val = vid * vid;
		3292	val *= (freq / 1000);
		3293	val *= 255;
		3294	val /= (127127900);
		3295	if (val > 0xff)
		3296	DRM_ERROR("bad pxval: %ld\n", val);
		3297	pxw[i] = val;
		3298	}
		3299	/* Render standby states get 0 weight */
		3300	pxw[14] = 0;
		3301	pxw[15] = 0;
		3302
		3303	for (i = 0; i < 4; i++) {
		3304	u32 val = (pxw[i4] << 24) \| (pxw[(i4)+1] << 16) \|
		3305	(pxw[(i4)+2] << 8) \| (pxw[(i4)+3]);
		3306	I915_WRITE(PXW + (i * 4), val);
		3307	}
		3308
		3309	/* Adjust magic regs to magic values (more experimental results) */
		3310	I915_WRITE(OGW0, 0);
		3311	I915_WRITE(OGW1, 0);
		3312	I915_WRITE(EG0, 0x00007f00);
		3313	I915_WRITE(EG1, 0x0000000e);
		3314	I915_WRITE(EG2, 0x000e0000);
		3315	I915_WRITE(EG3, 0x68000300);
		3316	I915_WRITE(EG4, 0x42000000);
		3317	I915_WRITE(EG5, 0x00140031);
		3318	I915_WRITE(EG6, 0);
		3319	I915_WRITE(EG7, 0);
		3320
		3321	for (i = 0; i < 8; i++)
		3322	I915_WRITE(PXWL + (i * 4), 0);
		3323
		3324	/* Enable PMON + select events */
		3325	I915_WRITE(ECR, 0x80000019);
		3326
		3327	lcfuse = I915_READ(LCFUSE02);
		3328
		3329	dev_priv->ips.corr = (lcfuse & LCFUSE_HIV_MASK);
		3330	}
		3331
		3332	void intel_disable_gt_powersave(struct drm_device *dev)
		3333	{
		3334	if (IS_IRONLAKE_M(dev)) {
		3335	ironlake_disable_drps(dev);
		3336	ironlake_disable_rc6(dev);
		3337	} else if (INTEL_INFO(dev)->gen >= 6 && !IS_VALLEYVIEW(dev)) {
		3338	gen6_disable_rps(dev);
		3339	}
		3340	}
		3341
		3342	void intel_enable_gt_powersave(struct drm_device *dev)
		3343	{
		3344	if (IS_IRONLAKE_M(dev)) {
		3345	ironlake_enable_drps(dev);
		3346	ironlake_enable_rc6(dev);
		3347	intel_init_emon(dev);
		3348	} else if ((IS_GEN6(dev) \|\| IS_GEN7(dev)) && !IS_VALLEYVIEW(dev)) {
		3349	// gen6_enable_rps(dev);
		3350	// gen6_update_ring_freq(dev);
		3351	}
		3352	}
		3353
		3354	static void ironlake_init_clock_gating(struct drm_device *dev)
		3355	{
		3356	struct drm_i915_private *dev_priv = dev->dev_private;
		3357	uint32_t dspclk_gate = VRHUNIT_CLOCK_GATE_DISABLE;
		3358
		3359	/* Required for FBC */
		3360	dspclk_gate \|= DPFCUNIT_CLOCK_GATE_DISABLE \|
		3361	DPFCRUNIT_CLOCK_GATE_DISABLE \|
		3362	DPFDUNIT_CLOCK_GATE_DISABLE;
		3363	/* Required for CxSR */
		3364	dspclk_gate \|= DPARBUNIT_CLOCK_GATE_DISABLE;
		3365
		3366	I915_WRITE(PCH_3DCGDIS0,
		3367	MARIUNIT_CLOCK_GATE_DISABLE \|
		3368	SVSMUNIT_CLOCK_GATE_DISABLE);
		3369	I915_WRITE(PCH_3DCGDIS1,
		3370	VFMUNIT_CLOCK_GATE_DISABLE);
		3371
		3372	I915_WRITE(PCH_DSPCLK_GATE_D, dspclk_gate);
		3373
		3374	/*
		3375	* According to the spec the following bits should be set in
		3376	* order to enable memory self-refresh
		3377	* The bit 22/21 of 0x42004
		3378	* The bit 5 of 0x42020
		3379	* The bit 15 of 0x45000
		3380	*/
		3381	I915_WRITE(ILK_DISPLAY_CHICKEN2,
		3382	(I915_READ(ILK_DISPLAY_CHICKEN2) \|
		3383	ILK_DPARB_GATE \| ILK_VSDPFD_FULL));
		3384	I915_WRITE(ILK_DSPCLK_GATE,
		3385	(I915_READ(ILK_DSPCLK_GATE) \|
		3386	ILK_DPARB_CLK_GATE));
		3387	I915_WRITE(DISP_ARB_CTL,
		3388	(I915_READ(DISP_ARB_CTL) \|
		3389	DISP_FBC_WM_DIS));
		3390	I915_WRITE(WM3_LP_ILK, 0);
		3391	I915_WRITE(WM2_LP_ILK, 0);
		3392	I915_WRITE(WM1_LP_ILK, 0);
		3393
		3394	/*
		3395	* Based on the document from hardware guys the following bits
		3396	* should be set unconditionally in order to enable FBC.
		3397	* The bit 22 of 0x42000
		3398	* The bit 22 of 0x42004
		3399	* The bit 7,8,9 of 0x42020.
		3400	*/
		3401	if (IS_IRONLAKE_M(dev)) {
		3402	I915_WRITE(ILK_DISPLAY_CHICKEN1,
		3403	I915_READ(ILK_DISPLAY_CHICKEN1) \|
		3404	ILK_FBCQ_DIS);
		3405	I915_WRITE(ILK_DISPLAY_CHICKEN2,
		3406	I915_READ(ILK_DISPLAY_CHICKEN2) \|
		3407	ILK_DPARB_GATE);
		3408	I915_WRITE(ILK_DSPCLK_GATE,
		3409	I915_READ(ILK_DSPCLK_GATE) \|
		3410	ILK_DPFC_DIS1 \|
		3411	ILK_DPFC_DIS2 \|
		3412	ILK_CLK_FBC);
		3413	}
		3414
		3415	I915_WRITE(ILK_DISPLAY_CHICKEN2,
		3416	I915_READ(ILK_DISPLAY_CHICKEN2) \|
		3417	ILK_ELPIN_409_SELECT);
		3418	I915_WRITE(_3D_CHICKEN2,
		3419	_3D_CHICKEN2_WM_READ_PIPELINED << 16 \|
		3420	_3D_CHICKEN2_WM_READ_PIPELINED);
		3421	}
		3422
		3423	static void gen6_init_clock_gating(struct drm_device *dev)
		3424	{
		3425	struct drm_i915_private *dev_priv = dev->dev_private;
		3426	int pipe;
		3427	uint32_t dspclk_gate = VRHUNIT_CLOCK_GATE_DISABLE;
		3428
		3429	I915_WRITE(PCH_DSPCLK_GATE_D, dspclk_gate);
		3430
		3431	I915_WRITE(ILK_DISPLAY_CHICKEN2,
		3432	I915_READ(ILK_DISPLAY_CHICKEN2) \|
		3433	ILK_ELPIN_409_SELECT);
		3434
		3435	I915_WRITE(WM3_LP_ILK, 0);
		3436	I915_WRITE(WM2_LP_ILK, 0);
		3437	I915_WRITE(WM1_LP_ILK, 0);
		3438
		3439	I915_WRITE(CACHE_MODE_0,
		3440	_MASKED_BIT_DISABLE(CM0_STC_EVICT_DISABLE_LRA_SNB));
		3441
		3442	I915_WRITE(GEN6_UCGCTL1,
		3443	I915_READ(GEN6_UCGCTL1) \|
		3444	GEN6_BLBUNIT_CLOCK_GATE_DISABLE \|
		3445	GEN6_CSUNIT_CLOCK_GATE_DISABLE);
		3446
		3447	/* According to the BSpec vol1g, bit 12 (RCPBUNIT) clock
		3448	* gating disable must be set. Failure to set it results in
		3449	* flickering pixels due to Z write ordering failures after
		3450	* some amount of runtime in the Mesa "fire" demo, and Unigine
		3451	* Sanctuary and Tropics, and apparently anything else with
		3452	* alpha test or pixel discard.
		3453	*
		3454	* According to the spec, bit 11 (RCCUNIT) must also be set,
		3455	* but we didn't debug actual testcases to find it out.
		3456	*
		3457	* Also apply WaDisableVDSUnitClockGating and
		3458	* WaDisableRCPBUnitClockGating.
		3459	*/
		3460	I915_WRITE(GEN6_UCGCTL2,
		3461	GEN7_VDSUNIT_CLOCK_GATE_DISABLE \|
		3462	GEN6_RCPBUNIT_CLOCK_GATE_DISABLE \|
		3463	GEN6_RCCUNIT_CLOCK_GATE_DISABLE);
		3464
		3465	/* Bspec says we need to always set all mask bits. */
		3466	I915_WRITE(_3D_CHICKEN3, (0xFFFF << 16) \|
		3467	_3D_CHICKEN3_SF_DISABLE_FASTCLIP_CULL);
		3468
		3469	/*
		3470	* According to the spec the following bits should be
		3471	* set in order to enable memory self-refresh and fbc:
		3472	* The bit21 and bit22 of 0x42000
		3473	* The bit21 and bit22 of 0x42004
		3474	* The bit5 and bit7 of 0x42020
		3475	* The bit14 of 0x70180
		3476	* The bit14 of 0x71180
		3477	*/
		3478	I915_WRITE(ILK_DISPLAY_CHICKEN1,
		3479	I915_READ(ILK_DISPLAY_CHICKEN1) \|
		3480	ILK_FBCQ_DIS \| ILK_PABSTRETCH_DIS);
		3481	I915_WRITE(ILK_DISPLAY_CHICKEN2,
		3482	I915_READ(ILK_DISPLAY_CHICKEN2) \|
		3483	ILK_DPARB_GATE \| ILK_VSDPFD_FULL);
		3484	I915_WRITE(ILK_DSPCLK_GATE,
		3485	I915_READ(ILK_DSPCLK_GATE) \|
		3486	ILK_DPARB_CLK_GATE \|
		3487	ILK_DPFD_CLK_GATE);
		3488
		3489	I915_WRITE(GEN6_MBCTL, I915_READ(GEN6_MBCTL) \|
		3490	GEN6_MBCTL_ENABLE_BOOT_FETCH);
		3491
		3492	for_each_pipe(pipe) {
		3493	I915_WRITE(DSPCNTR(pipe),
		3494	I915_READ(DSPCNTR(pipe)) \|
		3495	DISPPLANE_TRICKLE_FEED_DISABLE);
		3496	intel_flush_display_plane(dev_priv, pipe);
		3497	}
		3498
		3499	/* The default value should be 0x200 according to docs, but the two
		3500	* platforms I checked have a 0 for this. (Maybe BIOS overrides?) */
		3501	I915_WRITE(GEN6_GT_MODE, _MASKED_BIT_DISABLE(0xffff));
		3502	I915_WRITE(GEN6_GT_MODE, _MASKED_BIT_ENABLE(GEN6_GT_MODE_HI));
		3503	}
		3504
		3505	static void gen7_setup_fixed_func_scheduler(struct drm_i915_private *dev_priv)
		3506	{
		3507	uint32_t reg = I915_READ(GEN7_FF_THREAD_MODE);
		3508
		3509	reg &= ~GEN7_FF_SCHED_MASK;
		3510	reg \|= GEN7_FF_TS_SCHED_HW;
		3511	reg \|= GEN7_FF_VS_SCHED_HW;
		3512	reg \|= GEN7_FF_DS_SCHED_HW;
		3513
		3514	I915_WRITE(GEN7_FF_THREAD_MODE, reg);
		3515	}
		3516
		3517	static void haswell_init_clock_gating(struct drm_device *dev)
		3518	{
		3519	struct drm_i915_private *dev_priv = dev->dev_private;
		3520	int pipe;
		3521	uint32_t dspclk_gate = VRHUNIT_CLOCK_GATE_DISABLE;
		3522
		3523	I915_WRITE(PCH_DSPCLK_GATE_D, dspclk_gate);
		3524
		3525	I915_WRITE(WM3_LP_ILK, 0);
		3526	I915_WRITE(WM2_LP_ILK, 0);
		3527	I915_WRITE(WM1_LP_ILK, 0);
		3528
		3529	/* According to the spec, bit 13 (RCZUNIT) must be set on IVB.
		3530	* This implements the WaDisableRCZUnitClockGating workaround.
		3531	*/
		3532	I915_WRITE(GEN6_UCGCTL2, GEN6_RCZUNIT_CLOCK_GATE_DISABLE);
		3533
		3534	I915_WRITE(ILK_DSPCLK_GATE, IVB_VRHUNIT_CLK_GATE);
		3535
		3536	I915_WRITE(IVB_CHICKEN3,
		3537	CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE \|
		3538	CHICKEN3_DGMG_DONE_FIX_DISABLE);
		3539
		3540	/* Apply the WaDisableRHWOOptimizationForRenderHang workaround. */
		3541	I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1,
		3542	GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC);
		3543
		3544	/* WaApplyL3ControlAndL3ChickenMode requires those two on Ivy Bridge */
		3545	I915_WRITE(GEN7_L3CNTLREG1,
		3546	GEN7_WA_FOR_GEN7_L3_CONTROL);
		3547	I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER,
		3548	GEN7_WA_L3_CHICKEN_MODE);
		3549
		3550	/* This is required by WaCatErrorRejectionIssue */
		3551	I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG,
		3552	I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) \|
		3553	GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB);
		3554
		3555	for_each_pipe(pipe) {
		3556	I915_WRITE(DSPCNTR(pipe),
		3557	I915_READ(DSPCNTR(pipe)) \|
		3558	DISPPLANE_TRICKLE_FEED_DISABLE);
		3559	intel_flush_display_plane(dev_priv, pipe);
		3560	}
		3561
		3562	gen7_setup_fixed_func_scheduler(dev_priv);
		3563
		3564	/* WaDisable4x2SubspanOptimization */
		3565	I915_WRITE(CACHE_MODE_1,
		3566	_MASKED_BIT_ENABLE(PIXEL_SUBSPAN_COLLECT_OPT_DISABLE));
		3567
		3568	/* XXX: This is a workaround for early silicon revisions and should be
		3569	* removed later.
		3570	*/
		3571	I915_WRITE(WM_DBG,
		3572	I915_READ(WM_DBG) \|
		3573	WM_DBG_DISALLOW_MULTIPLE_LP \|
		3574	WM_DBG_DISALLOW_SPRITE \|
		3575	WM_DBG_DISALLOW_MAXFIFO);
		3576
		3577	}
		3578
		3579	static void ivybridge_init_clock_gating(struct drm_device *dev)
		3580	{
		3581	struct drm_i915_private *dev_priv = dev->dev_private;
		3582	int pipe;
		3583	uint32_t dspclk_gate = VRHUNIT_CLOCK_GATE_DISABLE;
		3584	uint32_t snpcr;
		3585
		3586	I915_WRITE(PCH_DSPCLK_GATE_D, dspclk_gate);
		3587
		3588	I915_WRITE(WM3_LP_ILK, 0);
		3589	I915_WRITE(WM2_LP_ILK, 0);
		3590	I915_WRITE(WM1_LP_ILK, 0);
		3591
		3592	I915_WRITE(ILK_DSPCLK_GATE, IVB_VRHUNIT_CLK_GATE);
		3593
		3594	I915_WRITE(IVB_CHICKEN3,
		3595	CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE \|
		3596	CHICKEN3_DGMG_DONE_FIX_DISABLE);
		3597
		3598	/* Apply the WaDisableRHWOOptimizationForRenderHang workaround. */
		3599	I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1,
		3600	GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC);
		3601
		3602	/* WaApplyL3ControlAndL3ChickenMode requires those two on Ivy Bridge */
		3603	I915_WRITE(GEN7_L3CNTLREG1,
		3604	GEN7_WA_FOR_GEN7_L3_CONTROL);
		3605	I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER,
		3606	GEN7_WA_L3_CHICKEN_MODE);
		3607
		3608	/* According to the BSpec vol1g, bit 12 (RCPBUNIT) clock
		3609	* gating disable must be set. Failure to set it results in
		3610	* flickering pixels due to Z write ordering failures after
		3611	* some amount of runtime in the Mesa "fire" demo, and Unigine
		3612	* Sanctuary and Tropics, and apparently anything else with
		3613	* alpha test or pixel discard.
		3614	*
		3615	* According to the spec, bit 11 (RCCUNIT) must also be set,
		3616	* but we didn't debug actual testcases to find it out.
		3617	*
		3618	* According to the spec, bit 13 (RCZUNIT) must be set on IVB.
		3619	* This implements the WaDisableRCZUnitClockGating workaround.
		3620	*/
		3621	I915_WRITE(GEN6_UCGCTL2,
		3622	GEN6_RCZUNIT_CLOCK_GATE_DISABLE \|
		3623	GEN6_RCCUNIT_CLOCK_GATE_DISABLE);
		3624
		3625	/* This is required by WaCatErrorRejectionIssue */
		3626	I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG,
		3627	I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) \|
		3628	GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB);
		3629
		3630	for_each_pipe(pipe) {
		3631	I915_WRITE(DSPCNTR(pipe),
		3632	I915_READ(DSPCNTR(pipe)) \|
		3633	DISPPLANE_TRICKLE_FEED_DISABLE);
		3634	intel_flush_display_plane(dev_priv, pipe);
		3635	}
		3636
		3637	I915_WRITE(GEN6_MBCTL, I915_READ(GEN6_MBCTL) \|
		3638	GEN6_MBCTL_ENABLE_BOOT_FETCH);
		3639
		3640	gen7_setup_fixed_func_scheduler(dev_priv);
		3641
		3642	/* WaDisable4x2SubspanOptimization */
		3643	I915_WRITE(CACHE_MODE_1,
		3644	_MASKED_BIT_ENABLE(PIXEL_SUBSPAN_COLLECT_OPT_DISABLE));
		3645
		3646	snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
		3647	snpcr &= ~GEN6_MBC_SNPCR_MASK;
		3648	snpcr \|= GEN6_MBC_SNPCR_MED;
		3649	I915_WRITE(GEN6_MBCUNIT_SNPCR, snpcr);
		3650	}
		3651
		3652	static void valleyview_init_clock_gating(struct drm_device *dev)
		3653	{
		3654	struct drm_i915_private *dev_priv = dev->dev_private;
		3655	int pipe;
		3656	uint32_t dspclk_gate = VRHUNIT_CLOCK_GATE_DISABLE;
		3657
		3658	I915_WRITE(PCH_DSPCLK_GATE_D, dspclk_gate);
		3659
		3660	I915_WRITE(WM3_LP_ILK, 0);
		3661	I915_WRITE(WM2_LP_ILK, 0);
		3662	I915_WRITE(WM1_LP_ILK, 0);
		3663
		3664	I915_WRITE(ILK_DSPCLK_GATE, IVB_VRHUNIT_CLK_GATE);
		3665
		3666	I915_WRITE(IVB_CHICKEN3,
		3667	CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE \|
		3668	CHICKEN3_DGMG_DONE_FIX_DISABLE);
		3669
		3670	/* Apply the WaDisableRHWOOptimizationForRenderHang workaround. */
		3671	I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1,
		3672	GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC);
		3673
		3674	/* WaApplyL3ControlAndL3ChickenMode requires those two on Ivy Bridge */
		3675	I915_WRITE(GEN7_L3CNTLREG1, GEN7_WA_FOR_GEN7_L3_CONTROL);
		3676	I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER, GEN7_WA_L3_CHICKEN_MODE);
		3677
		3678	/* This is required by WaCatErrorRejectionIssue */
		3679	I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG,
		3680	I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) \|
		3681	GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB);
		3682
		3683	I915_WRITE(GEN6_MBCTL, I915_READ(GEN6_MBCTL) \|
		3684	GEN6_MBCTL_ENABLE_BOOT_FETCH);
		3685
		3686
		3687	/* According to the BSpec vol1g, bit 12 (RCPBUNIT) clock
		3688	* gating disable must be set. Failure to set it results in
		3689	* flickering pixels due to Z write ordering failures after
		3690	* some amount of runtime in the Mesa "fire" demo, and Unigine
		3691	* Sanctuary and Tropics, and apparently anything else with
		3692	* alpha test or pixel discard.
		3693	*
		3694	* According to the spec, bit 11 (RCCUNIT) must also be set,
		3695	* but we didn't debug actual testcases to find it out.
		3696	*
		3697	* According to the spec, bit 13 (RCZUNIT) must be set on IVB.
		3698	* This implements the WaDisableRCZUnitClockGating workaround.
		3699	*
		3700	* Also apply WaDisableVDSUnitClockGating and
		3701	* WaDisableRCPBUnitClockGating.
		3702	*/
		3703	I915_WRITE(GEN6_UCGCTL2,
		3704	GEN7_VDSUNIT_CLOCK_GATE_DISABLE \|
		3705	GEN7_TDLUNIT_CLOCK_GATE_DISABLE \|
		3706	GEN6_RCZUNIT_CLOCK_GATE_DISABLE \|
		3707	GEN6_RCPBUNIT_CLOCK_GATE_DISABLE \|
		3708	GEN6_RCCUNIT_CLOCK_GATE_DISABLE);
		3709
		3710	I915_WRITE(GEN7_UCGCTL4, GEN7_L3BANK2X_CLOCK_GATE_DISABLE);
		3711
		3712	for_each_pipe(pipe) {
		3713	I915_WRITE(DSPCNTR(pipe),
		3714	I915_READ(DSPCNTR(pipe)) \|
		3715	DISPPLANE_TRICKLE_FEED_DISABLE);
		3716	intel_flush_display_plane(dev_priv, pipe);
		3717	}
		3718
		3719	I915_WRITE(CACHE_MODE_1,
		3720	_MASKED_BIT_ENABLE(PIXEL_SUBSPAN_COLLECT_OPT_DISABLE));
		3721
		3722	/*
		3723	* On ValleyView, the GUnit needs to signal the GT
		3724	* when flip and other events complete. So enable
		3725	* all the GUnit->GT interrupts here
		3726	*/
		3727	I915_WRITE(VLV_DPFLIPSTAT, PIPEB_LINE_COMPARE_INT_EN \|
		3728	PIPEB_HLINE_INT_EN \| PIPEB_VBLANK_INT_EN \|
		3729	SPRITED_FLIPDONE_INT_EN \| SPRITEC_FLIPDONE_INT_EN \|
		3730	PLANEB_FLIPDONE_INT_EN \| PIPEA_LINE_COMPARE_INT_EN \|
		3731	PIPEA_HLINE_INT_EN \| PIPEA_VBLANK_INT_EN \|
		3732	SPRITEB_FLIPDONE_INT_EN \| SPRITEA_FLIPDONE_INT_EN \|
		3733	PLANEA_FLIPDONE_INT_EN);
		3734	}
		3735
		3736	static void g4x_init_clock_gating(struct drm_device *dev)
		3737	{
		3738	struct drm_i915_private *dev_priv = dev->dev_private;
		3739	uint32_t dspclk_gate;
		3740
		3741	I915_WRITE(RENCLK_GATE_D1, 0);
		3742	I915_WRITE(RENCLK_GATE_D2, VF_UNIT_CLOCK_GATE_DISABLE \|
		3743	GS_UNIT_CLOCK_GATE_DISABLE \|
		3744	CL_UNIT_CLOCK_GATE_DISABLE);
		3745	I915_WRITE(RAMCLK_GATE_D, 0);
		3746	dspclk_gate = VRHUNIT_CLOCK_GATE_DISABLE \|
		3747	OVRUNIT_CLOCK_GATE_DISABLE \|
		3748	OVCUNIT_CLOCK_GATE_DISABLE;
		3749	if (IS_GM45(dev))
		3750	dspclk_gate \|= DSSUNIT_CLOCK_GATE_DISABLE;
		3751	I915_WRITE(DSPCLK_GATE_D, dspclk_gate);
		3752	}
		3753
		3754	static void crestline_init_clock_gating(struct drm_device *dev)
		3755	{
		3756	struct drm_i915_private *dev_priv = dev->dev_private;
		3757
		3758	I915_WRITE(RENCLK_GATE_D1, I965_RCC_CLOCK_GATE_DISABLE);
		3759	I915_WRITE(RENCLK_GATE_D2, 0);
		3760	I915_WRITE(DSPCLK_GATE_D, 0);
		3761	I915_WRITE(RAMCLK_GATE_D, 0);
		3762	I915_WRITE16(DEUC, 0);
		3763	}
		3764
		3765	static void broadwater_init_clock_gating(struct drm_device *dev)
		3766	{
		3767	struct drm_i915_private *dev_priv = dev->dev_private;
		3768
		3769	I915_WRITE(RENCLK_GATE_D1, I965_RCZ_CLOCK_GATE_DISABLE \|
		3770	I965_RCC_CLOCK_GATE_DISABLE \|
		3771	I965_RCPB_CLOCK_GATE_DISABLE \|
		3772	I965_ISC_CLOCK_GATE_DISABLE \|
		3773	I965_FBC_CLOCK_GATE_DISABLE);
		3774	I915_WRITE(RENCLK_GATE_D2, 0);
		3775	}
		3776
		3777	static void gen3_init_clock_gating(struct drm_device *dev)
		3778	{
		3779	struct drm_i915_private *dev_priv = dev->dev_private;
		3780	u32 dstate = I915_READ(D_STATE);
		3781
		3782	dstate \|= DSTATE_PLL_D3_OFF \| DSTATE_GFX_CLOCK_GATING \|
		3783	DSTATE_DOT_CLOCK_GATING;
		3784	I915_WRITE(D_STATE, dstate);
		3785
		3786	if (IS_PINEVIEW(dev))
		3787	I915_WRITE(ECOSKPD, _MASKED_BIT_ENABLE(ECO_GATING_CX_ONLY));
		3788
		3789	/* IIR "flip pending" means done if this bit is set */
		3790	I915_WRITE(ECOSKPD, _MASKED_BIT_DISABLE(ECO_FLIP_DONE));
		3791	}
		3792
		3793	static void i85x_init_clock_gating(struct drm_device *dev)
		3794	{
		3795	struct drm_i915_private *dev_priv = dev->dev_private;
		3796
		3797	I915_WRITE(RENCLK_GATE_D1, SV_CLOCK_GATE_DISABLE);
		3798	}
		3799
		3800	static void i830_init_clock_gating(struct drm_device *dev)
		3801	{
		3802	struct drm_i915_private *dev_priv = dev->dev_private;
		3803
		3804	I915_WRITE(DSPCLK_GATE_D, OVRUNIT_CLOCK_GATE_DISABLE);
		3805	}
		3806
		3807	static void ibx_init_clock_gating(struct drm_device *dev)
		3808	{
		3809	struct drm_i915_private *dev_priv = dev->dev_private;
		3810
		3811	/*
		3812	* On Ibex Peak and Cougar Point, we need to disable clock
		3813	* gating for the panel power sequencer or it will fail to
		3814	* start up when no ports are active.
		3815	*/
		3816	I915_WRITE(SOUTH_DSPCLK_GATE_D, PCH_DPLSUNIT_CLOCK_GATE_DISABLE);
		3817	}
		3818
		3819	static void cpt_init_clock_gating(struct drm_device *dev)
		3820	{
		3821	struct drm_i915_private *dev_priv = dev->dev_private;
		3822	int pipe;
		3823
		3824	/*
		3825	* On Ibex Peak and Cougar Point, we need to disable clock
		3826	* gating for the panel power sequencer or it will fail to
		3827	* start up when no ports are active.
		3828	*/
		3829	I915_WRITE(SOUTH_DSPCLK_GATE_D, PCH_DPLSUNIT_CLOCK_GATE_DISABLE);
		3830	I915_WRITE(SOUTH_CHICKEN2, I915_READ(SOUTH_CHICKEN2) \|
		3831	DPLS_EDP_PPS_FIX_DIS);
		3832	/* Without this, mode sets may fail silently on FDI */
		3833	for_each_pipe(pipe)
		3834	I915_WRITE(TRANS_CHICKEN2(pipe), TRANS_AUTOTRAIN_GEN_STALL_DIS);
		3835	}
		3836
		3837	void intel_init_clock_gating(struct drm_device *dev)
		3838	{
		3839	struct drm_i915_private *dev_priv = dev->dev_private;
		3840
		3841	dev_priv->display.init_clock_gating(dev);
		3842
		3843	if (dev_priv->display.init_pch_clock_gating)
		3844	dev_priv->display.init_pch_clock_gating(dev);
		3845	}
		3846
		3847	/* Starting with Haswell, we have different power wells for
		3848	* different parts of the GPU. This attempts to enable them all.
		3849	*/
		3850	void intel_init_power_wells(struct drm_device *dev)
		3851	{
		3852	struct drm_i915_private *dev_priv = dev->dev_private;
		3853	unsigned long power_wells[] = {
		3854	HSW_PWR_WELL_CTL1,
		3855	HSW_PWR_WELL_CTL2,
		3856	HSW_PWR_WELL_CTL4
		3857	};
		3858	int i;
		3859
		3860	if (!IS_HASWELL(dev))
		3861	return;
		3862
		3863	mutex_lock(&dev->struct_mutex);
		3864
		3865	for (i = 0; i < ARRAY_SIZE(power_wells); i++) {
		3866	int well = I915_READ(power_wells[i]);
		3867
		3868	if ((well & HSW_PWR_WELL_STATE) == 0) {
		3869	I915_WRITE(power_wells[i], well & HSW_PWR_WELL_ENABLE);
		3870	if (wait_for(I915_READ(power_wells[i] & HSW_PWR_WELL_STATE), 20))
		3871	DRM_ERROR("Error enabling power well %lx\n", power_wells[i]);
		3872	}
		3873	}
		3874
		3875	mutex_unlock(&dev->struct_mutex);
		3876	}
		3877
		3878	/* Set up chip specific power management-related functions */
		3879	void intel_init_pm(struct drm_device *dev)
		3880	{
		3881	struct drm_i915_private *dev_priv = dev->dev_private;
		3882
		3883	if (I915_HAS_FBC(dev)) {
		3884	if (HAS_PCH_SPLIT(dev)) {
		3885	dev_priv->display.fbc_enabled = ironlake_fbc_enabled;
		3886	dev_priv->display.enable_fbc = ironlake_enable_fbc;
		3887	dev_priv->display.disable_fbc = ironlake_disable_fbc;
		3888	} else if (IS_GM45(dev)) {
		3889	dev_priv->display.fbc_enabled = g4x_fbc_enabled;
		3890	dev_priv->display.enable_fbc = g4x_enable_fbc;
		3891	dev_priv->display.disable_fbc = g4x_disable_fbc;
		3892	} else if (IS_CRESTLINE(dev)) {
		3893	dev_priv->display.fbc_enabled = i8xx_fbc_enabled;
		3894	dev_priv->display.enable_fbc = i8xx_enable_fbc;
		3895	dev_priv->display.disable_fbc = i8xx_disable_fbc;
		3896	}
		3897	/* 855GM needs testing */
		3898	}
		3899
		3900	/* For cxsr */
		3901	if (IS_PINEVIEW(dev))
		3902	i915_pineview_get_mem_freq(dev);
		3903	else if (IS_GEN5(dev))
		3904	i915_ironlake_get_mem_freq(dev);
		3905
		3906	/* For FIFO watermark updates */
		3907	if (HAS_PCH_SPLIT(dev)) {
		3908	if (HAS_PCH_IBX(dev))
		3909	dev_priv->display.init_pch_clock_gating = ibx_init_clock_gating;
		3910	else if (HAS_PCH_CPT(dev))
		3911	dev_priv->display.init_pch_clock_gating = cpt_init_clock_gating;
		3912
		3913	if (IS_GEN5(dev)) {
		3914	if (I915_READ(MLTR_ILK) & ILK_SRLT_MASK)
		3915	dev_priv->display.update_wm = ironlake_update_wm;
		3916	else {
		3917	DRM_DEBUG_KMS("Failed to get proper latency. "
		3918	"Disable CxSR\n");
		3919	dev_priv->display.update_wm = NULL;
		3920	}
		3921	dev_priv->display.init_clock_gating = ironlake_init_clock_gating;
		3922	} else if (IS_GEN6(dev)) {
		3923	if (SNB_READ_WM0_LATENCY()) {
		3924	dev_priv->display.update_wm = sandybridge_update_wm;
		3925	dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm;
		3926	} else {
		3927	DRM_DEBUG_KMS("Failed to read display plane latency. "
		3928	"Disable CxSR\n");
		3929	dev_priv->display.update_wm = NULL;
		3930	}
		3931	dev_priv->display.init_clock_gating = gen6_init_clock_gating;
		3932	} else if (IS_IVYBRIDGE(dev)) {
		3933	/* FIXME: detect B0+ stepping and use auto training */
		3934	if (SNB_READ_WM0_LATENCY()) {
		3935	dev_priv->display.update_wm = sandybridge_update_wm;
		3936	dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm;
		3937	} else {
		3938	DRM_DEBUG_KMS("Failed to read display plane latency. "
		3939	"Disable CxSR\n");
		3940	dev_priv->display.update_wm = NULL;
		3941	}
		3942	dev_priv->display.init_clock_gating = ivybridge_init_clock_gating;
		3943	} else if (IS_HASWELL(dev)) {
		3944	if (SNB_READ_WM0_LATENCY()) {
		3945	dev_priv->display.update_wm = sandybridge_update_wm;
		3946	dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm;
		3947	dev_priv->display.update_linetime_wm = haswell_update_linetime_wm;
		3948	} else {
		3949	DRM_DEBUG_KMS("Failed to read display plane latency. "
		3950	"Disable CxSR\n");
		3951	dev_priv->display.update_wm = NULL;
		3952	}
		3953	dev_priv->display.init_clock_gating = haswell_init_clock_gating;
		3954	} else
		3955	dev_priv->display.update_wm = NULL;
		3956	} else if (IS_VALLEYVIEW(dev)) {
		3957	dev_priv->display.update_wm = valleyview_update_wm;
		3958	dev_priv->display.init_clock_gating =
		3959	valleyview_init_clock_gating;
		3960	} else if (IS_PINEVIEW(dev)) {
		3961	if (!intel_get_cxsr_latency(IS_PINEVIEW_G(dev),
		3962	dev_priv->is_ddr3,
		3963	dev_priv->fsb_freq,
		3964	dev_priv->mem_freq)) {
		3965	DRM_INFO("failed to find known CxSR latency "
		3966	"(found ddr%s fsb freq %d, mem freq %d), "
		3967	"disabling CxSR\n",
		3968	(dev_priv->is_ddr3 == 1) ? "3" : "2",
		3969	dev_priv->fsb_freq, dev_priv->mem_freq);
		3970	/* Disable CxSR and never update its watermark again */
		3971	pineview_disable_cxsr(dev);
		3972	dev_priv->display.update_wm = NULL;
		3973	} else
		3974	dev_priv->display.update_wm = pineview_update_wm;
		3975	dev_priv->display.init_clock_gating = gen3_init_clock_gating;
		3976	} else if (IS_G4X(dev)) {
		3977	dev_priv->display.update_wm = g4x_update_wm;
		3978	dev_priv->display.init_clock_gating = g4x_init_clock_gating;
		3979	} else if (IS_GEN4(dev)) {
		3980	dev_priv->display.update_wm = i965_update_wm;
		3981	if (IS_CRESTLINE(dev))
		3982	dev_priv->display.init_clock_gating = crestline_init_clock_gating;
		3983	else if (IS_BROADWATER(dev))
		3984	dev_priv->display.init_clock_gating = broadwater_init_clock_gating;
		3985	} else if (IS_GEN3(dev)) {
		3986	dev_priv->display.update_wm = i9xx_update_wm;
		3987	dev_priv->display.get_fifo_size = i9xx_get_fifo_size;
		3988	dev_priv->display.init_clock_gating = gen3_init_clock_gating;
		3989	} else if (IS_I865G(dev)) {
		3990	dev_priv->display.update_wm = i830_update_wm;
		3991	dev_priv->display.init_clock_gating = i85x_init_clock_gating;
		3992	dev_priv->display.get_fifo_size = i830_get_fifo_size;
		3993	} else if (IS_I85X(dev)) {
		3994	dev_priv->display.update_wm = i9xx_update_wm;
		3995	dev_priv->display.get_fifo_size = i85x_get_fifo_size;
		3996	dev_priv->display.init_clock_gating = i85x_init_clock_gating;
		3997	} else {
		3998	dev_priv->display.update_wm = i830_update_wm;
		3999	dev_priv->display.init_clock_gating = i830_init_clock_gating;
		4000	if (IS_845G(dev))
		4001	dev_priv->display.get_fifo_size = i845_get_fifo_size;
		4002	else
		4003	dev_priv->display.get_fifo_size = i830_get_fifo_size;
		4004	}
		4005	}
		4006
		4007	static void __gen6_gt_wait_for_thread_c0(struct drm_i915_private *dev_priv)
		4008	{
		4009	u32 gt_thread_status_mask;
		4010
		4011	if (IS_HASWELL(dev_priv->dev))
		4012	gt_thread_status_mask = GEN6_GT_THREAD_STATUS_CORE_MASK_HSW;
		4013	else
		4014	gt_thread_status_mask = GEN6_GT_THREAD_STATUS_CORE_MASK;
		4015
		4016	/* w/a for a sporadic read returning 0 by waiting for the GT
		4017	* thread to wake up.
		4018	*/
		4019	if (wait_for_atomic_us((I915_READ_NOTRACE(GEN6_GT_THREAD_STATUS_REG) & gt_thread_status_mask) == 0, 500))
		4020	DRM_ERROR("GT thread status wait timed out\n");
		4021	}
		4022
		4023	static void __gen6_gt_force_wake_get(struct drm_i915_private *dev_priv)
		4024	{
		4025	u32 forcewake_ack;
		4026
		4027	if (IS_HASWELL(dev_priv->dev))
		4028	forcewake_ack = FORCEWAKE_ACK_HSW;
		4029	else
		4030	forcewake_ack = FORCEWAKE_ACK;
		4031
		4032	if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1) == 0,
		4033	FORCEWAKE_ACK_TIMEOUT_MS))
		4034	DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n");
		4035
		4036	I915_WRITE_NOTRACE(FORCEWAKE, 1);
		4037	POSTING_READ(ECOBUS); /* something from same cacheline, but !FORCEWAKE */
		4038
		4039	if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1),
		4040	FORCEWAKE_ACK_TIMEOUT_MS))
		4041	DRM_ERROR("Timed out waiting for forcewake to ack request.\n");
		4042
		4043	__gen6_gt_wait_for_thread_c0(dev_priv);
		4044	}
		4045
		4046	static void __gen6_gt_force_wake_mt_get(struct drm_i915_private *dev_priv)
		4047	{
		4048	u32 forcewake_ack;
		4049
		4050	if (IS_HASWELL(dev_priv->dev))
		4051	forcewake_ack = FORCEWAKE_ACK_HSW;
		4052	else
		4053	forcewake_ack = FORCEWAKE_MT_ACK;
		4054
		4055	if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1) == 0,
		4056	FORCEWAKE_ACK_TIMEOUT_MS))
		4057	DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n");
		4058
		4059	I915_WRITE_NOTRACE(FORCEWAKE_MT, _MASKED_BIT_ENABLE(1));
		4060	POSTING_READ(ECOBUS); /* something from same cacheline, but !FORCEWAKE */
		4061
		4062	if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & 1),
		4063	FORCEWAKE_ACK_TIMEOUT_MS))
		4064	DRM_ERROR("Timed out waiting for forcewake to ack request.\n");
		4065
		4066	__gen6_gt_wait_for_thread_c0(dev_priv);
		4067	}
		4068
		4069	/*
		4070	* Generally this is called implicitly by the register read function. However,
		4071	* if some sequence requires the GT to not power down then this function should
		4072	* be called at the beginning of the sequence followed by a call to
		4073	* gen6_gt_force_wake_put() at the end of the sequence.
		4074	*/
		4075	void gen6_gt_force_wake_get(struct drm_i915_private *dev_priv)
		4076	{
		4077	unsigned long irqflags;
		4078
		4079	spin_lock_irqsave(&dev_priv->gt_lock, irqflags);
		4080	if (dev_priv->forcewake_count++ == 0)
		4081	dev_priv->gt.force_wake_get(dev_priv);
		4082	spin_unlock_irqrestore(&dev_priv->gt_lock, irqflags);
		4083	}
		4084
		4085	void gen6_gt_check_fifodbg(struct drm_i915_private *dev_priv)
		4086	{
		4087	u32 gtfifodbg;
		4088	gtfifodbg = I915_READ_NOTRACE(GTFIFODBG);
		4089	if (WARN(gtfifodbg & GT_FIFO_CPU_ERROR_MASK,
		4090	"MMIO read or write has been dropped %x\n", gtfifodbg))
		4091	I915_WRITE_NOTRACE(GTFIFODBG, GT_FIFO_CPU_ERROR_MASK);
		4092	}
		4093
		4094	static void __gen6_gt_force_wake_put(struct drm_i915_private *dev_priv)
		4095	{
		4096	I915_WRITE_NOTRACE(FORCEWAKE, 0);
		4097	/* gen6_gt_check_fifodbg doubles as the POSTING_READ */
		4098	gen6_gt_check_fifodbg(dev_priv);
		4099	}
		4100
		4101	static void __gen6_gt_force_wake_mt_put(struct drm_i915_private *dev_priv)
		4102	{
		4103	I915_WRITE_NOTRACE(FORCEWAKE_MT, _MASKED_BIT_DISABLE(1));
		4104	/* gen6_gt_check_fifodbg doubles as the POSTING_READ */
		4105	gen6_gt_check_fifodbg(dev_priv);
		4106	}
		4107
		4108	/*
		4109	* see gen6_gt_force_wake_get()
		4110	*/
		4111	void gen6_gt_force_wake_put(struct drm_i915_private *dev_priv)
		4112	{
		4113	unsigned long irqflags;
		4114
		4115	spin_lock_irqsave(&dev_priv->gt_lock, irqflags);
		4116	if (--dev_priv->forcewake_count == 0)
		4117	dev_priv->gt.force_wake_put(dev_priv);
		4118	spin_unlock_irqrestore(&dev_priv->gt_lock, irqflags);
		4119	}
		4120
		4121	int __gen6_gt_wait_for_fifo(struct drm_i915_private *dev_priv)
		4122	{
		4123	int ret = 0;
		4124
		4125	if (dev_priv->gt_fifo_count < GT_FIFO_NUM_RESERVED_ENTRIES) {
		4126	int loop = 500;
		4127	u32 fifo = I915_READ_NOTRACE(GT_FIFO_FREE_ENTRIES);
		4128	while (fifo <= GT_FIFO_NUM_RESERVED_ENTRIES && loop--) {
		4129	udelay(10);
		4130	fifo = I915_READ_NOTRACE(GT_FIFO_FREE_ENTRIES);
		4131	}
		4132	if (WARN_ON(loop < 0 && fifo <= GT_FIFO_NUM_RESERVED_ENTRIES))
		4133	++ret;
		4134	dev_priv->gt_fifo_count = fifo;
		4135	}
		4136	dev_priv->gt_fifo_count--;
		4137
		4138	return ret;
		4139	}
		4140
		4141	static void vlv_force_wake_get(struct drm_i915_private *dev_priv)
		4142	{
		4143	if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK_VLV) & 1) == 0,
		4144	FORCEWAKE_ACK_TIMEOUT_MS))
		4145	DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n");
		4146
		4147	I915_WRITE_NOTRACE(FORCEWAKE_VLV, _MASKED_BIT_ENABLE(1));
		4148
		4149	if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK_VLV) & 1),
		4150	FORCEWAKE_ACK_TIMEOUT_MS))
		4151	DRM_ERROR("Timed out waiting for forcewake to ack request.\n");
		4152
		4153	__gen6_gt_wait_for_thread_c0(dev_priv);
		4154	}
		4155
		4156	static void vlv_force_wake_put(struct drm_i915_private *dev_priv)
		4157	{
		4158	I915_WRITE_NOTRACE(FORCEWAKE_VLV, _MASKED_BIT_DISABLE(1));
		4159	/* The below doubles as a POSTING_READ */
		4160	gen6_gt_check_fifodbg(dev_priv);
		4161	}
		4162
		4163	void intel_gt_init(struct drm_device *dev)
		4164	{
		4165	struct drm_i915_private *dev_priv = dev->dev_private;
		4166
		4167	spin_lock_init(&dev_priv->gt_lock);
		4168
		4169	if (IS_VALLEYVIEW(dev)) {
		4170	dev_priv->gt.force_wake_get = vlv_force_wake_get;
		4171	dev_priv->gt.force_wake_put = vlv_force_wake_put;
		4172	} else if (INTEL_INFO(dev)->gen >= 6) {
		4173	dev_priv->gt.force_wake_get = __gen6_gt_force_wake_get;
		4174	dev_priv->gt.force_wake_put = __gen6_gt_force_wake_put;
		4175
		4176	/* IVB configs may use multi-threaded forcewake */
		4177	if (IS_IVYBRIDGE(dev) \|\| IS_HASWELL(dev)) {
		4178	u32 ecobus;
		4179
		4180	/* A small trick here - if the bios hasn't configured
		4181	* MT forcewake, and if the device is in RC6, then
		4182	* force_wake_mt_get will not wake the device and the
		4183	* ECOBUS read will return zero. Which will be
		4184	* (correctly) interpreted by the test below as MT
		4185	* forcewake being disabled.
		4186	*/
		4187	mutex_lock(&dev->struct_mutex);
		4188	__gen6_gt_force_wake_mt_get(dev_priv);
		4189	ecobus = I915_READ_NOTRACE(ECOBUS);
		4190	__gen6_gt_force_wake_mt_put(dev_priv);
		4191	mutex_unlock(&dev->struct_mutex);
		4192
		4193	if (ecobus & FORCEWAKE_MT_ENABLE) {
		4194	DRM_DEBUG_KMS("Using MT version of forcewake\n");
		4195	dev_priv->gt.force_wake_get =
		4196	__gen6_gt_force_wake_mt_get;
		4197	dev_priv->gt.force_wake_put =
		4198	__gen6_gt_force_wake_mt_put;
		4199	}
		4200	}
		4201	}
		4202	}
		4203

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_pm.c – Rev 3120