intel_drv.h 58.8 KB
Newer Older
J
Jesse Barnes 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/*
 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
 * Copyright (c) 2007-2008 Intel Corporation
 *   Jesse Barnes <jesse.barnes@intel.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
#ifndef __INTEL_DRV_H__
#define __INTEL_DRV_H__

28
#include <linux/async.h>
J
Jesse Barnes 已提交
29
#include <linux/i2c.h>
30
#include <linux/hdmi.h>
31
#include <drm/i915_drm.h>
32
#include "i915_drv.h"
33 34 35
#include <drm/drm_crtc.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_fb_helper.h>
36
#include <drm/drm_dp_dual_mode_helper.h>
37
#include <drm/drm_dp_mst_helper.h>
38
#include <drm/drm_rect.h>
39
#include <drm/drm_atomic.h>
40

D
Daniel Vetter 已提交
41 42 43 44 45 46 47
/**
 * _wait_for - magic (register) wait macro
 *
 * Does the right thing for modeset paths when run under kdgb or similar atomic
 * contexts. Note that it's important that we check the condition again after
 * having timed out, since the timeout could be due to preemption or similar and
 * we've never had a chance to check the condition before the timeout.
48 49 50 51
 *
 * TODO: When modesetting has fully transitioned to atomic, the below
 * drm_can_sleep() can be removed and in_atomic()/!in_atomic() asserts
 * added.
D
Daniel Vetter 已提交
52
 */
T
Tvrtko Ursulin 已提交
53 54
#define _wait_for(COND, US, W) ({ \
	unsigned long timeout__ = jiffies + usecs_to_jiffies(US) + 1;	\
55
	int ret__ = 0;							\
56
	while (!(COND)) {						\
57
		if (time_after(jiffies, timeout__)) {			\
D
Daniel Vetter 已提交
58 59
			if (!(COND))					\
				ret__ = -ETIMEDOUT;			\
60 61
			break;						\
		}							\
62
		if ((W) && drm_can_sleep()) {				\
T
Tvrtko Ursulin 已提交
63
			usleep_range((W), (W)*2);			\
64 65 66
		} else {						\
			cpu_relax();					\
		}							\
67 68 69 70
	}								\
	ret__;								\
})

T
Tvrtko Ursulin 已提交
71 72
#define wait_for(COND, MS)	  	_wait_for((COND), (MS) * 1000, 1000)

73 74
/* If CONFIG_PREEMPT_COUNT is disabled, in_atomic() always reports false. */
#if defined(CONFIG_DRM_I915_DEBUG) && defined(CONFIG_PREEMPT_COUNT)
75
# define _WAIT_FOR_ATOMIC_CHECK(ATOMIC) WARN_ON_ONCE((ATOMIC) && !in_atomic())
76
#else
77
# define _WAIT_FOR_ATOMIC_CHECK(ATOMIC) do { } while (0)
78 79
#endif

80 81 82 83 84
#define _wait_for_atomic(COND, US, ATOMIC) \
({ \
	int cpu, ret, timeout = (US) * 1000; \
	u64 base; \
	_WAIT_FOR_ATOMIC_CHECK(ATOMIC); \
85
	BUILD_BUG_ON((US) > 50000); \
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
	if (!(ATOMIC)) { \
		preempt_disable(); \
		cpu = smp_processor_id(); \
	} \
	base = local_clock(); \
	for (;;) { \
		u64 now = local_clock(); \
		if (!(ATOMIC)) \
			preempt_enable(); \
		if (COND) { \
			ret = 0; \
			break; \
		} \
		if (now - base >= timeout) { \
			ret = -ETIMEDOUT; \
101 102 103
			break; \
		} \
		cpu_relax(); \
104 105 106 107 108 109 110 111
		if (!(ATOMIC)) { \
			preempt_disable(); \
			if (unlikely(cpu != smp_processor_id())) { \
				timeout -= now - base; \
				cpu = smp_processor_id(); \
				base = local_clock(); \
			} \
		} \
112
	} \
113 114 115 116 117 118 119 120 121 122 123
	ret; \
})

#define wait_for_us(COND, US) \
({ \
	int ret__; \
	BUILD_BUG_ON(!__builtin_constant_p(US)); \
	if ((US) > 10) \
		ret__ = _wait_for((COND), (US), 10); \
	else \
		ret__ = _wait_for_atomic((COND), (US), 0); \
124 125 126
	ret__; \
})

127 128
#define wait_for_atomic(COND, MS)	_wait_for_atomic((COND), (MS) * 1000, 1)
#define wait_for_atomic_us(COND, US)	_wait_for_atomic((COND), (US), 1)
129

130 131
#define KHz(x) (1000 * (x))
#define MHz(x) KHz(1000 * (x))
132

J
Jesse Barnes 已提交
133 134 135 136 137 138 139 140 141 142
/*
 * Display related stuff
 */

/* store information about an Ixxx DVO */
/* The i830->i865 use multiple DVOs with multiple i2cs */
/* the i915, i945 have a single sDVO i2c bus - which is different */
#define MAX_OUTPUTS 6
/* maximum connectors per crtcs in the mode set */

143 144 145
/* Maximum cursor sizes */
#define GEN2_CURSOR_WIDTH 64
#define GEN2_CURSOR_HEIGHT 64
146 147
#define MAX_CURSOR_WIDTH 256
#define MAX_CURSOR_HEIGHT 256
148

J
Jesse Barnes 已提交
149 150 151 152 153
#define INTEL_I2C_BUS_DVO 1
#define INTEL_I2C_BUS_SDVO 2

/* these are outputs from the chip - integrated only
   external chips are via DVO or SDVO output */
154 155 156 157 158 159 160 161
enum intel_output_type {
	INTEL_OUTPUT_UNUSED = 0,
	INTEL_OUTPUT_ANALOG = 1,
	INTEL_OUTPUT_DVO = 2,
	INTEL_OUTPUT_SDVO = 3,
	INTEL_OUTPUT_LVDS = 4,
	INTEL_OUTPUT_TVOUT = 5,
	INTEL_OUTPUT_HDMI = 6,
162
	INTEL_OUTPUT_DP = 7,
163 164 165 166 167
	INTEL_OUTPUT_EDP = 8,
	INTEL_OUTPUT_DSI = 9,
	INTEL_OUTPUT_UNKNOWN = 10,
	INTEL_OUTPUT_DP_MST = 11,
};
J
Jesse Barnes 已提交
168 169 170 171 172 173

#define INTEL_DVO_CHIP_NONE 0
#define INTEL_DVO_CHIP_LVDS 1
#define INTEL_DVO_CHIP_TMDS 2
#define INTEL_DVO_CHIP_TVOUT 4

174 175
#define INTEL_DSI_VIDEO_MODE	0
#define INTEL_DSI_COMMAND_MODE	1
176

J
Jesse Barnes 已提交
177 178
struct intel_framebuffer {
	struct drm_framebuffer base;
179
	struct drm_i915_gem_object *obj;
180
	struct intel_rotation_info rot_info;
J
Jesse Barnes 已提交
181 182
};

183 184
struct intel_fbdev {
	struct drm_fb_helper helper;
185
	struct intel_framebuffer *fb;
186
	async_cookie_t cookie;
187
	int preferred_bpp;
188
};
J
Jesse Barnes 已提交
189

190
struct intel_encoder {
191
	struct drm_encoder base;
192

193
	enum intel_output_type type;
194
	unsigned int cloneable;
195
	void (*hot_plug)(struct intel_encoder *);
196
	bool (*compute_config)(struct intel_encoder *,
197
			       struct intel_crtc_state *);
198
	void (*pre_pll_enable)(struct intel_encoder *);
199
	void (*pre_enable)(struct intel_encoder *);
200
	void (*enable)(struct intel_encoder *);
201
	void (*mode_set)(struct intel_encoder *intel_encoder);
202
	void (*disable)(struct intel_encoder *);
203
	void (*post_disable)(struct intel_encoder *);
204
	void (*post_pll_disable)(struct intel_encoder *);
205 206 207 208
	/* Read out the current hw state of this connector, returning true if
	 * the encoder is active. If the encoder is enabled it also set the pipe
	 * it is connected to in the pipe parameter. */
	bool (*get_hw_state)(struct intel_encoder *, enum pipe *pipe);
209
	/* Reconstructs the equivalent mode flags for the current hardware
210
	 * state. This must be called _after_ display->get_pipe_config has
211 212
	 * pre-filled the pipe config. Note that intel_encoder->base.crtc must
	 * be set correctly before calling this function. */
213
	void (*get_config)(struct intel_encoder *,
214
			   struct intel_crtc_state *pipe_config);
215 216 217 218 219 220
	/*
	 * Called during system suspend after all pending requests for the
	 * encoder are flushed (for example for DP AUX transactions) and
	 * device interrupts are disabled.
	 */
	void (*suspend)(struct intel_encoder *);
221
	int crtc_mask;
222
	enum hpd_pin hpd_pin;
J
Jesse Barnes 已提交
223 224
};

225
struct intel_panel {
226
	struct drm_display_mode *fixed_mode;
227
	struct drm_display_mode *downclock_mode;
228
	int fitting_mode;
229 230 231

	/* backlight */
	struct {
232
		bool present;
233
		u32 level;
234
		u32 min;
235
		u32 max;
236
		bool enabled;
237 238
		bool combination_mode;	/* gen 2/4 only */
		bool active_low_pwm;
239 240

		/* PWM chip */
241 242
		bool util_pin_active_low;	/* bxt+ */
		u8 controller;		/* bxt+ only */
243 244
		struct pwm_device *pwm;

245
		struct backlight_device *device;
246

247 248 249 250 251 252 253 254 255 256
		/* Connector and platform specific backlight functions */
		int (*setup)(struct intel_connector *connector, enum pipe pipe);
		uint32_t (*get)(struct intel_connector *connector);
		void (*set)(struct intel_connector *connector, uint32_t level);
		void (*disable)(struct intel_connector *connector);
		void (*enable)(struct intel_connector *connector);
		uint32_t (*hz_to_pwm)(struct intel_connector *connector,
				      uint32_t hz);
		void (*power)(struct intel_connector *, bool enable);
	} backlight;
257 258
};

259 260
struct intel_connector {
	struct drm_connector base;
261 262 263
	/*
	 * The fixed encoder this connector is connected to.
	 */
264
	struct intel_encoder *encoder;
265

266 267 268
	/* Reads out the current hw, returning true if the connector is enabled
	 * and active (i.e. dpms ON state). */
	bool (*get_hw_state)(struct intel_connector *);
269 270 271

	/* Panel info for eDP and LVDS */
	struct intel_panel panel;
272 273 274

	/* Cached EDID for eDP and LVDS. May hold ERR_PTR for invalid EDID. */
	struct edid *edid;
275
	struct edid *detect_edid;
276 277 278 279

	/* since POLL and HPD connectors may use the same HPD line keep the native
	   state of connector->polled in case hotplug storm detection changes it */
	u8 polled;
280 281 282 283

	void *port; /* store this opaque as its illegal to dereference it */

	struct intel_dp *mst_port;
284 285
};

286
struct dpll {
287 288 289 290 291 292 293 294 295
	/* given values */
	int n;
	int m1, m2;
	int p1, p2;
	/* derived values */
	int	dot;
	int	vco;
	int	m;
	int	p;
296
};
297

298 299 300
struct intel_atomic_state {
	struct drm_atomic_state base;

301
	unsigned int cdclk;
302

303 304 305 306 307 308
	/*
	 * Calculated device cdclk, can be different from cdclk
	 * only when all crtc's are DPMS off.
	 */
	unsigned int dev_cdclk;

309 310
	bool dpll_set, modeset;

311 312 313 314 315 316 317 318 319 320
	/*
	 * Does this transaction change the pipes that are active?  This mask
	 * tracks which CRTC's have changed their active state at the end of
	 * the transaction (not counting the temporary disable during modesets).
	 * This mask should only be non-zero when intel_state->modeset is true,
	 * but the converse is not necessarily true; simply changing a mode may
	 * not flip the final active status of any CRTC's
	 */
	unsigned int active_pipe_changes;

321 322 323
	unsigned int active_crtcs;
	unsigned int min_pixclk[I915_MAX_PIPES];

324 325 326
	/* SKL/KBL Only */
	unsigned int cdclk_pll_vco;

327
	struct intel_shared_dpll_config shared_dpll[I915_NUM_PLLS];
328 329 330 331 332 333

	/*
	 * Current watermarks can't be trusted during hardware readout, so
	 * don't bother calculating intermediate watermarks.
	 */
	bool skip_intermediate_wm;
334 335

	/* Gen9+ only */
336
	struct skl_wm_values wm_results;
337 338
};

339
struct intel_plane_state {
340
	struct drm_plane_state base;
341
	struct drm_rect clip;
342

343 344 345 346 347 348 349 350
	/*
	 * scaler_id
	 *    = -1 : not using a scaler
	 *    >=  0 : using a scalers
	 *
	 * plane requiring a scaler:
	 *   - During check_plane, its bit is set in
	 *     crtc_state->scaler_state.scaler_users by calling helper function
351
	 *     update_scaler_plane.
352 353 354 355 356 357 358
	 *   - scaler_id indicates the scaler it got assigned.
	 *
	 * plane doesn't require a scaler:
	 *   - this can happen when scaling is no more required or plane simply
	 *     got disabled.
	 *   - During check_plane, corresponding bit is reset in
	 *     crtc_state->scaler_state.scaler_users by calling helper function
359
	 *     update_scaler_plane.
360 361
	 */
	int scaler_id;
362 363

	struct drm_intel_sprite_colorkey ckey;
364 365 366

	/* async flip related structures */
	struct drm_i915_gem_request *wait_req;
367 368
};

369
struct intel_initial_plane_config {
370
	struct intel_framebuffer *fb;
371
	unsigned int tiling;
372 373 374 375
	int size;
	u32 base;
};

376 377 378
#define SKL_MIN_SRC_W 8
#define SKL_MAX_SRC_W 4096
#define SKL_MIN_SRC_H 8
379
#define SKL_MAX_SRC_H 4096
380 381 382
#define SKL_MIN_DST_W 8
#define SKL_MAX_DST_W 4096
#define SKL_MIN_DST_H 8
383
#define SKL_MAX_DST_H 4096
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417

struct intel_scaler {
	int in_use;
	uint32_t mode;
};

struct intel_crtc_scaler_state {
#define SKL_NUM_SCALERS 2
	struct intel_scaler scalers[SKL_NUM_SCALERS];

	/*
	 * scaler_users: keeps track of users requesting scalers on this crtc.
	 *
	 *     If a bit is set, a user is using a scaler.
	 *     Here user can be a plane or crtc as defined below:
	 *       bits 0-30 - plane (bit position is index from drm_plane_index)
	 *       bit 31    - crtc
	 *
	 * Instead of creating a new index to cover planes and crtc, using
	 * existing drm_plane_index for planes which is well less than 31
	 * planes and bit 31 for crtc. This should be fine to cover all
	 * our platforms.
	 *
	 * intel_atomic_setup_scalers will setup available scalers to users
	 * requesting scalers. It will gracefully fail if request exceeds
	 * avilability.
	 */
#define SKL_CRTC_INDEX 31
	unsigned scaler_users;

	/* scaler used by crtc for panel fitting purpose */
	int scaler_id;
};

418 419 420
/* drm_mode->private_flags */
#define I915_MODE_FLAG_INHERITED 1

421 422
struct intel_pipe_wm {
	struct intel_wm_level wm[5];
423
	struct intel_wm_level raw_wm[5];
424 425 426 427 428 429 430 431 432 433 434 435 436
	uint32_t linetime;
	bool fbc_wm_enabled;
	bool pipe_enabled;
	bool sprites_enabled;
	bool sprites_scaled;
};

struct skl_pipe_wm {
	struct skl_wm_level wm[8];
	struct skl_wm_level trans_wm;
	uint32_t linetime;
};

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
struct intel_crtc_wm_state {
	union {
		struct {
			/*
			 * Intermediate watermarks; these can be
			 * programmed immediately since they satisfy
			 * both the current configuration we're
			 * switching away from and the new
			 * configuration we're switching to.
			 */
			struct intel_pipe_wm intermediate;

			/*
			 * Optimal watermarks, programmed post-vblank
			 * when this state is committed.
			 */
			struct intel_pipe_wm optimal;
		} ilk;

		struct {
			/* gen9+ only needs 1-step wm programming */
			struct skl_pipe_wm optimal;
459 460 461 462

			/* cached plane data rate */
			unsigned plane_data_rate[I915_MAX_PLANES];
			unsigned plane_y_data_rate[I915_MAX_PLANES];
463 464 465 466

			/* minimum block allocation */
			uint16_t minimum_blocks[I915_MAX_PLANES];
			uint16_t minimum_y_blocks[I915_MAX_PLANES];
467 468 469 470 471 472 473 474 475 476 477 478
		} skl;
	};

	/*
	 * Platforms with two-step watermark programming will need to
	 * update watermark programming post-vblank to switch from the
	 * safe intermediate watermarks to the optimal final
	 * watermarks.
	 */
	bool need_postvbl_update;
};

479
struct intel_crtc_state {
480 481
	struct drm_crtc_state base;

482 483 484 485 486 487 488 489
	/**
	 * quirks - bitfield with hw state readout quirks
	 *
	 * For various reasons the hw state readout code might not be able to
	 * completely faithfully read out the current state. These cases are
	 * tracked with quirk flags so that fastboot and state checker can act
	 * accordingly.
	 */
490
#define PIPE_CONFIG_QUIRK_MODE_SYNC_FLAGS	(1<<0) /* unreliable sync mode.flags */
491 492
	unsigned long quirks;

493
	unsigned fb_bits; /* framebuffers to flip */
494 495
	bool update_pipe; /* can a fast modeset be performed? */
	bool disable_cxsr;
496
	bool update_wm_pre, update_wm_post; /* watermarks are updated */
497
	bool fb_changed; /* fb on any of the planes is changed */
498

499 500 501 502 503
	/* Pipe source size (ie. panel fitter input size)
	 * All planes will be positioned inside this space,
	 * and get clipped at the edges. */
	int pipe_src_w, pipe_src_h;

504 505 506
	/* Whether to set up the PCH/FDI. Note that we never allow sharing
	 * between pch encoders and cpu encoders. */
	bool has_pch_encoder;
507

508 509 510
	/* Are we sending infoframes on the attached port */
	bool has_infoframe;

511
	/* CPU Transcoder for the pipe. Currently this can only differ from the
J
Jani Nikula 已提交
512 513
	 * pipe on Haswell and later (where we have a special eDP transcoder)
	 * and Broxton (where we have special DSI transcoders). */
514 515
	enum transcoder cpu_transcoder;

516 517 518 519 520 521
	/*
	 * Use reduced/limited/broadcast rbg range, compressing from the full
	 * range fed into the crtcs.
	 */
	bool limited_color_range;

522 523 524 525 526
	/* Bitmask of encoder types (enum intel_output_type)
	 * driven by the pipe.
	 */
	unsigned int output_types;

527 528 529
	/* Whether we should send NULL infoframes. Required for audio. */
	bool has_hdmi_sink;

530 531 532 533
	/* Audio enabled on this pipe. Only valid if either has_hdmi_sink or
	 * has_dp_encoder is set. */
	bool has_audio;

534 535 536 537
	/*
	 * Enable dithering, used when the selected pipe bpp doesn't match the
	 * plane bpp.
	 */
538
	bool dither;
539 540 541 542

	/* Controls for the clock computation, to override various stages. */
	bool clock_set;

543 544 545 546
	/* SDVO TV has a bunch of special case. To make multifunction encoders
	 * work correctly, we need to track this at runtime.*/
	bool sdvo_tv_clock;

547 548 549 550 551 552 553
	/*
	 * crtc bandwidth limit, don't increase pipe bpp or clock if not really
	 * required. This is set in the 2nd loop of calling encoder's
	 * ->compute_config if the first pick doesn't work out.
	 */
	bool bw_constrained;

554 555
	/* Settings for the intel dpll used on pretty much everything but
	 * haswell. */
556
	struct dpll dpll;
557

558 559
	/* Selected dpll when shared or NULL. */
	struct intel_shared_dpll *shared_dpll;
560

561 562 563 564
	/*
	 * - PORT_CLK_SEL for DDI ports on HSW/BDW.
	 * - enum skl_dpll on SKL
	 */
565 566
	uint32_t ddi_pll_sel;

567 568 569
	/* Actual register state of the dpll, for shared dpll cross-checking. */
	struct intel_dpll_hw_state dpll_hw_state;

570 571 572 573 574
	/* DSI PLL registers */
	struct {
		u32 ctrl, div;
	} dsi_pll;

575
	int pipe_bpp;
576
	struct intel_link_m_n dp_m_n;
577

578 579
	/* m2_n2 for eDP downclock */
	struct intel_link_m_n dp_m2_n2;
580
	bool has_drrs;
581

582 583
	/*
	 * Frequence the dpll for the port should run at. Differs from the
584 585
	 * adjusted dotclock e.g. for DP or 12bpc hdmi mode. This is also
	 * already multiplied by pixel_multiplier.
586
	 */
587 588
	int port_clock;

589 590
	/* Used by SDVO (and if we ever fix it, HDMI). */
	unsigned pixel_multiplier;
591

592 593
	uint8_t lane_count;

594 595 596 597 598 599
	/*
	 * Used by platforms having DP/HDMI PHY with programmable lane
	 * latency optimization.
	 */
	uint8_t lane_lat_optim_mask;

600
	/* Panel fitter controls for gen2-gen4 + VLV */
601 602 603
	struct {
		u32 control;
		u32 pgm_ratios;
604
		u32 lvds_border_bits;
605 606 607 608 609 610
	} gmch_pfit;

	/* Panel fitter placement and size for Ironlake+ */
	struct {
		u32 pos;
		u32 size;
611
		bool enabled;
612
		bool force_thru;
613
	} pch_pfit;
614

615
	/* FDI configuration, only valid if has_pch_encoder is set. */
616
	int fdi_lanes;
617
	struct intel_link_m_n fdi_m_n;
P
Paulo Zanoni 已提交
618 619

	bool ips_enabled;
620

621 622
	bool enable_fbc;

623
	bool double_wide;
624 625 626

	bool dp_encoder_is_mst;
	int pbn;
627 628

	struct intel_crtc_scaler_state scaler_state;
629 630 631

	/* w/a for waiting 2 vblanks during crtc enable */
	enum pipe hsw_workaround_pipe;
632 633 634

	/* IVB sprite scaling w/a (WaCxSRDisabledForSpriteScaling:ivb) */
	bool disable_lp_wm;
635

636
	struct intel_crtc_wm_state wm;
637 638 639

	/* Gamma mode programmed on the pipe */
	uint32_t gamma_mode;
640 641
};

642 643 644 645 646 647 648 649 650
struct vlv_wm_state {
	struct vlv_pipe_wm wm[3];
	struct vlv_sr_wm sr[3];
	uint8_t num_active_planes;
	uint8_t num_levels;
	uint8_t level;
	bool cxsr;
};

J
Jesse Barnes 已提交
651 652
struct intel_crtc {
	struct drm_crtc base;
653 654
	enum pipe pipe;
	enum plane plane;
J
Jesse Barnes 已提交
655
	u8 lut_r[256], lut_g[256], lut_b[256];
656 657 658 659 660 661
	/*
	 * Whether the crtc and the connected output pipeline is active. Implies
	 * that crtc->enabled is set, i.e. the current mode configuration has
	 * some outputs connected to this crtc.
	 */
	bool active;
662
	unsigned long enabled_power_domains;
663
	bool lowfreq_avail;
664
	struct intel_overlay *overlay;
665
	struct intel_flip_work *flip_work;
666

667 668
	atomic_t unpin_work_count;

669 670 671
	/* Display surface base address adjustement for pageflips. Note that on
	 * gen4+ this only adjusts up to a tile, offsets within a tile are
	 * handled in the hw itself (with the TILEOFF register). */
672
	u32 dspaddr_offset;
673 674
	int adjusted_x;
	int adjusted_y;
675

676
	uint32_t cursor_addr;
677
	uint32_t cursor_cntl;
678
	uint32_t cursor_size;
679
	uint32_t cursor_base;
680

681
	struct intel_crtc_state *config;
682

683 684 685
	/* reset counter value when the last flip was submitted */
	unsigned int reset_counter;

686 687 688
	/* Access to these should be protected by dev_priv->irq_lock. */
	bool cpu_fifo_underrun_disabled;
	bool pch_fifo_underrun_disabled;
689 690 691 692

	/* per-pipe watermark state */
	struct {
		/* watermarks currently being used  */
693 694 695 696
		union {
			struct intel_pipe_wm ilk;
			struct skl_pipe_wm skl;
		} active;
697

698 699
		/* allow CxSR on this pipe */
		bool cxsr_allowed;
700
	} wm;
701

702
	int scanline_offset;
703

704 705 706 707 708 709
	struct {
		unsigned start_vbl_count;
		ktime_t start_vbl_time;
		int min_vbl, max_vbl;
		int scanline_start;
	} debug;
710

711 712
	/* scalers available on this crtc */
	int num_scalers;
713 714

	struct vlv_wm_state wm_state;
J
Jesse Barnes 已提交
715 716
};

717 718
struct intel_plane_wm_parameters {
	uint32_t horiz_pixels;
719
	uint32_t vert_pixels;
720 721 722 723 724 725 726
	/*
	 *   For packed pixel formats:
	 *     bytes_per_pixel - holds bytes per pixel
	 *   For planar pixel formats:
	 *     bytes_per_pixel - holds bytes per pixel for uv-plane
	 *     y_bytes_per_pixel - holds bytes per pixel for y-plane
	 */
727
	uint8_t bytes_per_pixel;
728
	uint8_t y_bytes_per_pixel;
729 730
	bool enabled;
	bool scaled;
731
	u64 tiling;
732
	unsigned int rotation;
733
	uint16_t fifo_size;
734 735
};

736 737
struct intel_plane {
	struct drm_plane base;
738
	int plane;
739
	enum pipe pipe;
740
	bool can_scale;
741
	int max_downscale;
742
	uint32_t frontbuffer_bit;
743 744 745 746 747 748

	/* Since we need to change the watermarks before/after
	 * enabling/disabling the planes, we need to store the parameters here
	 * as the other pieces of the struct may not reflect the values we want
	 * for the watermark calculations. Currently only Haswell uses this.
	 */
749
	struct intel_plane_wm_parameters wm;
750

751 752 753
	/*
	 * NOTE: Do not place new plane state fields here (e.g., when adding
	 * new plane properties).  New runtime state should now be placed in
754
	 * the intel_plane_state structure and accessed via plane_state.
755 756
	 */

757
	void (*update_plane)(struct drm_plane *plane,
758 759
			     const struct intel_crtc_state *crtc_state,
			     const struct intel_plane_state *plane_state);
760
	void (*disable_plane)(struct drm_plane *plane,
761
			      struct drm_crtc *crtc);
762
	int (*check_plane)(struct drm_plane *plane,
763
			   struct intel_crtc_state *crtc_state,
764
			   struct intel_plane_state *state);
765 766
};

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
struct intel_watermark_params {
	unsigned long fifo_size;
	unsigned long max_wm;
	unsigned long default_wm;
	unsigned long guard_size;
	unsigned long cacheline_size;
};

struct cxsr_latency {
	int is_desktop;
	int is_ddr3;
	unsigned long fsb_freq;
	unsigned long mem_freq;
	unsigned long display_sr;
	unsigned long display_hpll_disable;
	unsigned long cursor_sr;
	unsigned long cursor_hpll_disable;
};

786
#define to_intel_atomic_state(x) container_of(x, struct intel_atomic_state, base)
J
Jesse Barnes 已提交
787
#define to_intel_crtc(x) container_of(x, struct intel_crtc, base)
788
#define to_intel_crtc_state(x) container_of(x, struct intel_crtc_state, base)
789
#define to_intel_connector(x) container_of(x, struct intel_connector, base)
790
#define to_intel_encoder(x) container_of(x, struct intel_encoder, base)
J
Jesse Barnes 已提交
791
#define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base)
792
#define to_intel_plane(x) container_of(x, struct intel_plane, base)
793
#define to_intel_plane_state(x) container_of(x, struct intel_plane_state, base)
794
#define intel_fb_obj(x) (x ? to_intel_framebuffer(x)->obj : NULL)
J
Jesse Barnes 已提交
795

796
struct intel_hdmi {
797
	i915_reg_t hdmi_reg;
798
	int ddc_bus;
799 800 801 802
	struct {
		enum drm_dp_dual_mode_type type;
		int max_tmds_clock;
	} dp_dual_mode;
803
	bool limited_color_range;
804
	bool color_range_auto;
805 806 807
	bool has_hdmi_sink;
	bool has_audio;
	enum hdmi_force_audio force_audio;
808
	bool rgb_quant_range_selectable;
809
	enum hdmi_picture_aspect aspect_ratio;
810
	struct intel_connector *attached_connector;
811
	void (*write_infoframe)(struct drm_encoder *encoder,
812
				enum hdmi_infoframe_type type,
813
				const void *frame, ssize_t len);
814
	void (*set_infoframes)(struct drm_encoder *encoder,
815
			       bool enable,
816
			       const struct drm_display_mode *adjusted_mode);
817 818
	bool (*infoframe_enabled)(struct drm_encoder *encoder,
				  const struct intel_crtc_state *pipe_config);
819 820
};

821
struct intel_dp_mst_encoder;
822
#define DP_MAX_DOWNSTREAM_PORTS		0x10
823

824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
/*
 * enum link_m_n_set:
 *	When platform provides two set of M_N registers for dp, we can
 *	program them and switch between them incase of DRRS.
 *	But When only one such register is provided, we have to program the
 *	required divider value on that registers itself based on the DRRS state.
 *
 * M1_N1	: Program dp_m_n on M1_N1 registers
 *			  dp_m2_n2 on M2_N2 registers (If supported)
 *
 * M2_N2	: Program dp_m2_n2 on M1_N1 registers
 *			  M2_N2 registers are not supported
 */

enum link_m_n_set {
	/* Sets the m1_n1 and m2_n2 */
	M1_N1 = 0,
	M2_N2
};

844
struct intel_dp {
845 846 847
	i915_reg_t output_reg;
	i915_reg_t aux_ch_ctl_reg;
	i915_reg_t aux_ch_data_reg[5];
848
	uint32_t DP;
849 850
	int link_rate;
	uint8_t lane_count;
851
	uint8_t sink_count;
852
	bool has_audio;
853
	bool detect_done;
854
	enum hdmi_force_audio force_audio;
855
	bool limited_color_range;
856
	bool color_range_auto;
857
	uint8_t dpcd[DP_RECEIVER_CAP_SIZE];
858
	uint8_t psr_dpcd[EDP_PSR_RECEIVER_CAP_SIZE];
859
	uint8_t downstream_ports[DP_MAX_DOWNSTREAM_PORTS];
860
	uint8_t edp_dpcd[EDP_DISPLAY_CTL_CAP_SIZE];
861 862 863
	/* sink rates as reported by DP_SUPPORTED_LINK_RATES */
	uint8_t num_sink_rates;
	int sink_rates[DP_MAX_SUPPORTED_RATES];
864
	struct drm_dp_aux aux;
865 866 867 868 869 870 871 872
	uint8_t train_set[4];
	int panel_power_up_delay;
	int panel_power_down_delay;
	int panel_power_cycle_delay;
	int backlight_on_delay;
	int backlight_off_delay;
	struct delayed_work panel_vdd_work;
	bool want_panel_vdd;
873 874
	unsigned long last_power_on;
	unsigned long last_backlight_off;
875
	ktime_t panel_power_off_time;
D
Dave Airlie 已提交
876

877 878
	struct notifier_block edp_notifier;

879 880 881 882 883
	/*
	 * Pipe whose power sequencer is currently locked into
	 * this port. Only relevant on VLV/CHV.
	 */
	enum pipe pps_pipe;
884 885 886 887 888
	/*
	 * Set if the sequencer may be reset due to a power transition,
	 * requiring a reinitialization. Only relevant on BXT.
	 */
	bool pps_reset;
889
	struct edp_power_seq pps_delays;
890

891 892 893 894
	bool can_mst; /* this port supports mst */
	bool is_mst;
	int active_mst_links;
	/* connector directly attached - won't be use for modeset in mst world */
895
	struct intel_connector *attached_connector;
896

897 898 899 900
	/* mst connector list */
	struct intel_dp_mst_encoder *mst_encoders[I915_MAX_PIPES];
	struct drm_dp_mst_topology_mgr mst_mgr;

901
	uint32_t (*get_aux_clock_divider)(struct intel_dp *dp, int index);
902 903 904 905 906 907 908 909
	/*
	 * This function returns the value we have to program the AUX_CTL
	 * register with to kick off an AUX transaction.
	 */
	uint32_t (*get_aux_send_ctl)(struct intel_dp *dp,
				     bool has_aux_irq,
				     int send_bytes,
				     uint32_t aux_clock_divider);
910 911 912 913

	/* This is called before a link training is starterd */
	void (*prepare_link_retrain)(struct intel_dp *intel_dp);

914 915
	/* Displayport compliance testing */
	unsigned long compliance_test_type;
916 917
	unsigned long compliance_test_data;
	bool compliance_test_active;
918 919
};

920 921
struct intel_digital_port {
	struct intel_encoder base;
922
	enum port port;
923
	u32 saved_port_bits;
924 925
	struct intel_dp dp;
	struct intel_hdmi hdmi;
926
	enum irqreturn (*hpd_pulse)(struct intel_digital_port *, bool);
927
	bool release_cl2_override;
928
	uint8_t max_lanes;
929 930
	/* for communication with audio component; protected by av_mutex */
	const struct drm_connector *audio_connector;
931 932
};

933 934 935 936
struct intel_dp_mst_encoder {
	struct intel_encoder base;
	enum pipe pipe;
	struct intel_digital_port *primary;
937
	struct intel_connector *connector;
938 939
};

940
static inline enum dpio_channel
941 942 943 944
vlv_dport_to_channel(struct intel_digital_port *dport)
{
	switch (dport->port) {
	case PORT_B:
945
	case PORT_D:
946
		return DPIO_CH0;
947
	case PORT_C:
948
		return DPIO_CH1;
949 950 951 952 953
	default:
		BUG();
	}
}

954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
static inline enum dpio_phy
vlv_dport_to_phy(struct intel_digital_port *dport)
{
	switch (dport->port) {
	case PORT_B:
	case PORT_C:
		return DPIO_PHY0;
	case PORT_D:
		return DPIO_PHY1;
	default:
		BUG();
	}
}

static inline enum dpio_channel
969 970 971 972 973 974 975 976 977 978 979 980 981
vlv_pipe_to_channel(enum pipe pipe)
{
	switch (pipe) {
	case PIPE_A:
	case PIPE_C:
		return DPIO_CH0;
	case PIPE_B:
		return DPIO_CH1;
	default:
		BUG();
	}
}

982 983 984
static inline struct drm_crtc *
intel_get_crtc_for_pipe(struct drm_device *dev, int pipe)
{
985
	struct drm_i915_private *dev_priv = to_i915(dev);
986 987 988
	return dev_priv->pipe_to_crtc_mapping[pipe];
}

989 990 991
static inline struct drm_crtc *
intel_get_crtc_for_plane(struct drm_device *dev, int plane)
{
992
	struct drm_i915_private *dev_priv = to_i915(dev);
993 994 995
	return dev_priv->plane_to_crtc_mapping[plane];
}

996 997 998 999
struct intel_flip_work {
	struct work_struct unpin_work;
	struct work_struct mmio_work;

1000 1001 1002
	struct drm_crtc *crtc;
	struct drm_framebuffer *old_fb;
	struct drm_i915_gem_object *pending_flip_obj;
1003
	struct drm_pending_vblank_event *event;
1004
	atomic_t pending;
1005 1006 1007
	u32 flip_count;
	u32 gtt_offset;
	struct drm_i915_gem_request *flip_queued_req;
1008
	u32 flip_queued_vblank;
1009 1010
	u32 flip_ready_vblank;
	unsigned int rotation;
1011 1012
};

P
Paulo Zanoni 已提交
1013
struct intel_load_detect_pipe {
1014
	struct drm_atomic_state *restore_state;
P
Paulo Zanoni 已提交
1015
};
J
Jesse Barnes 已提交
1016

P
Paulo Zanoni 已提交
1017 1018
static inline struct intel_encoder *
intel_attached_encoder(struct drm_connector *connector)
1019 1020 1021 1022
{
	return to_intel_connector(connector)->encoder;
}

1023 1024 1025 1026
static inline struct intel_digital_port *
enc_to_dig_port(struct drm_encoder *encoder)
{
	return container_of(encoder, struct intel_digital_port, base.base);
1027 1028
}

1029 1030 1031 1032 1033 1034
static inline struct intel_dp_mst_encoder *
enc_to_mst(struct drm_encoder *encoder)
{
	return container_of(encoder, struct intel_dp_mst_encoder, base.base);
}

1035 1036 1037
static inline struct intel_dp *enc_to_intel_dp(struct drm_encoder *encoder)
{
	return &enc_to_dig_port(encoder)->dp;
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
}

static inline struct intel_digital_port *
dp_to_dig_port(struct intel_dp *intel_dp)
{
	return container_of(intel_dp, struct intel_digital_port, dp);
}

static inline struct intel_digital_port *
hdmi_to_dig_port(struct intel_hdmi *intel_hdmi)
{
	return container_of(intel_hdmi, struct intel_digital_port, hdmi);
1050 1051
}

1052 1053 1054 1055 1056 1057 1058 1059
/*
 * Returns the number of planes for this pipe, ie the number of sprites + 1
 * (primary plane). This doesn't count the cursor plane then.
 */
static inline unsigned int intel_num_planes(struct intel_crtc *crtc)
{
	return INTEL_INFO(crtc->base.dev)->num_sprites[crtc->pipe] + 1;
}
P
Paulo Zanoni 已提交
1060

1061
/* intel_fifo_underrun.c */
1062
bool intel_set_cpu_fifo_underrun_reporting(struct drm_i915_private *dev_priv,
1063
					   enum pipe pipe, bool enable);
1064
bool intel_set_pch_fifo_underrun_reporting(struct drm_i915_private *dev_priv,
1065 1066
					   enum transcoder pch_transcoder,
					   bool enable);
1067 1068 1069 1070
void intel_cpu_fifo_underrun_irq_handler(struct drm_i915_private *dev_priv,
					 enum pipe pipe);
void intel_pch_fifo_underrun_irq_handler(struct drm_i915_private *dev_priv,
					 enum transcoder pch_transcoder);
1071 1072
void intel_check_cpu_fifo_underruns(struct drm_i915_private *dev_priv);
void intel_check_pch_fifo_underruns(struct drm_i915_private *dev_priv);
1073 1074

/* i915_irq.c */
1075 1076 1077 1078
void gen5_enable_gt_irq(struct drm_i915_private *dev_priv, uint32_t mask);
void gen5_disable_gt_irq(struct drm_i915_private *dev_priv, uint32_t mask);
void gen6_enable_pm_irq(struct drm_i915_private *dev_priv, uint32_t mask);
void gen6_disable_pm_irq(struct drm_i915_private *dev_priv, uint32_t mask);
1079
void gen6_reset_rps_interrupts(struct drm_i915_private *dev_priv);
1080 1081
void gen6_enable_rps_interrupts(struct drm_i915_private *dev_priv);
void gen6_disable_rps_interrupts(struct drm_i915_private *dev_priv);
1082
u32 gen6_sanitize_rps_pm_mask(struct drm_i915_private *dev_priv, u32 mask);
1083 1084
void intel_runtime_pm_disable_interrupts(struct drm_i915_private *dev_priv);
void intel_runtime_pm_enable_interrupts(struct drm_i915_private *dev_priv);
1085 1086 1087 1088 1089 1090
static inline bool intel_irqs_enabled(struct drm_i915_private *dev_priv)
{
	/*
	 * We only use drm_irq_uninstall() at unload and VT switch, so
	 * this is the only thing we need to check.
	 */
1091
	return dev_priv->pm.irqs_enabled;
1092 1093
}

1094
int intel_get_crtc_scanline(struct intel_crtc *crtc);
1095 1096
void gen8_irq_power_well_post_enable(struct drm_i915_private *dev_priv,
				     unsigned int pipe_mask);
1097 1098
void gen8_irq_power_well_pre_disable(struct drm_i915_private *dev_priv,
				     unsigned int pipe_mask);
P
Paulo Zanoni 已提交
1099 1100

/* intel_crt.c */
1101
void intel_crt_init(struct drm_device *dev);
1102
void intel_crt_reset(struct drm_encoder *encoder);
P
Paulo Zanoni 已提交
1103 1104

/* intel_ddi.c */
1105 1106
void intel_ddi_clk_select(struct intel_encoder *encoder,
			  const struct intel_crtc_state *pipe_config);
1107
void intel_prepare_ddi_buffer(struct intel_encoder *encoder);
1108 1109 1110 1111 1112 1113 1114 1115 1116
void hsw_fdi_link_train(struct drm_crtc *crtc);
void intel_ddi_init(struct drm_device *dev, enum port port);
enum port intel_ddi_get_encoder_port(struct intel_encoder *intel_encoder);
bool intel_ddi_get_hw_state(struct intel_encoder *encoder, enum pipe *pipe);
void intel_ddi_enable_transcoder_func(struct drm_crtc *crtc);
void intel_ddi_disable_transcoder_func(struct drm_i915_private *dev_priv,
				       enum transcoder cpu_transcoder);
void intel_ddi_enable_pipe_clock(struct intel_crtc *intel_crtc);
void intel_ddi_disable_pipe_clock(struct intel_crtc *intel_crtc);
1117 1118
bool intel_ddi_pll_select(struct intel_crtc *crtc,
			  struct intel_crtc_state *crtc_state);
1119
void intel_ddi_set_pipe_settings(struct drm_crtc *crtc);
1120
void intel_ddi_prepare_link_retrain(struct intel_dp *intel_dp);
1121 1122 1123
bool intel_ddi_connector_get_hw_state(struct intel_connector *intel_connector);
void intel_ddi_fdi_disable(struct drm_crtc *crtc);
void intel_ddi_get_config(struct intel_encoder *encoder,
1124
			  struct intel_crtc_state *pipe_config);
1125 1126
struct intel_encoder *
intel_ddi_get_crtc_new_encoder(struct intel_crtc_state *crtc_state);
P
Paulo Zanoni 已提交
1127

1128
void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder);
1129
void intel_ddi_clock_get(struct intel_encoder *encoder,
1130
			 struct intel_crtc_state *pipe_config);
1131
void intel_ddi_set_vc_payload_alloc(struct drm_crtc *crtc, bool state);
1132
uint32_t ddi_signal_levels(struct intel_dp *intel_dp);
P
Paulo Zanoni 已提交
1133

1134
/* intel_frontbuffer.c */
1135
void intel_fb_obj_invalidate(struct drm_i915_gem_object *obj,
1136
			     enum fb_op_origin origin);
1137 1138 1139 1140 1141
void intel_frontbuffer_flip_prepare(struct drm_device *dev,
				    unsigned frontbuffer_bits);
void intel_frontbuffer_flip_complete(struct drm_device *dev,
				     unsigned frontbuffer_bits);
void intel_frontbuffer_flip(struct drm_device *dev,
1142
			    unsigned frontbuffer_bits);
1143 1144 1145 1146
unsigned int intel_fb_align_height(struct drm_device *dev,
				   unsigned int height,
				   uint32_t pixel_format,
				   uint64_t fb_format_modifier);
1147 1148
void intel_fb_obj_flush(struct drm_i915_gem_object *obj, bool retire,
			enum fb_op_origin origin);
1149 1150
u32 intel_fb_stride_alignment(const struct drm_i915_private *dev_priv,
			      uint64_t fb_modifier, uint32_t pixel_format);
1151

1152
/* intel_audio.c */
1153
void intel_init_audio_hooks(struct drm_i915_private *dev_priv);
1154 1155
void intel_audio_codec_enable(struct intel_encoder *encoder);
void intel_audio_codec_disable(struct intel_encoder *encoder);
I
Imre Deak 已提交
1156 1157
void i915_audio_component_init(struct drm_i915_private *dev_priv);
void i915_audio_component_cleanup(struct drm_i915_private *dev_priv);
1158

1159
/* intel_display.c */
1160
void skl_set_preferred_cdclk_vco(struct drm_i915_private *dev_priv, int vco);
1161
void intel_update_rawclk(struct drm_i915_private *dev_priv);
1162 1163
int vlv_get_cck_clock(struct drm_i915_private *dev_priv,
		      const char *name, u32 reg, int ref_freq);
1164
extern const struct drm_plane_funcs intel_plane_funcs;
1165
void intel_init_display_hooks(struct drm_i915_private *dev_priv);
1166
unsigned int intel_rotation_info_size(const struct intel_rotation_info *rot_info);
1167
bool intel_has_pending_fb_unpin(struct drm_device *dev);
1168 1169
void intel_mark_busy(struct drm_i915_private *dev_priv);
void intel_mark_idle(struct drm_i915_private *dev_priv);
1170
void intel_crtc_restore_mode(struct drm_crtc *crtc);
1171
int intel_display_suspend(struct drm_device *dev);
1172
void intel_encoder_destroy(struct drm_encoder *encoder);
1173 1174
int intel_connector_init(struct intel_connector *);
struct intel_connector *intel_connector_alloc(void);
1175 1176 1177 1178 1179
bool intel_connector_get_hw_state(struct intel_connector *connector);
void intel_connector_attach_encoder(struct intel_connector *connector,
				    struct intel_encoder *encoder);
struct drm_display_mode *intel_crtc_mode_get(struct drm_device *dev,
					     struct drm_crtc *crtc);
1180
enum pipe intel_get_pipe_from_connector(struct intel_connector *connector);
1181 1182
int intel_get_pipe_from_crtc_id(struct drm_device *dev, void *data,
				struct drm_file *file_priv);
1183 1184
enum transcoder intel_pipe_to_cpu_transcoder(struct drm_i915_private *dev_priv,
					     enum pipe pipe);
1185 1186 1187 1188 1189 1190
static inline bool
intel_crtc_has_type(const struct intel_crtc_state *crtc_state,
		    enum intel_output_type type)
{
	return crtc_state->output_types & (1 << type);
}
1191 1192 1193 1194
static inline bool
intel_crtc_has_dp_encoder(const struct intel_crtc_state *crtc_state)
{
	return crtc_state->output_types &
1195
		((1 << INTEL_OUTPUT_DP) |
1196 1197 1198
		 (1 << INTEL_OUTPUT_DP_MST) |
		 (1 << INTEL_OUTPUT_EDP));
}
1199 1200 1201 1202 1203
static inline void
intel_wait_for_vblank(struct drm_device *dev, int pipe)
{
	drm_wait_one_vblank(dev, pipe);
}
1204 1205 1206 1207 1208 1209 1210 1211 1212
static inline void
intel_wait_for_vblank_if_active(struct drm_device *dev, int pipe)
{
	const struct intel_crtc *crtc =
		to_intel_crtc(intel_get_crtc_for_pipe(dev, pipe));

	if (crtc->active)
		intel_wait_for_vblank(dev, pipe);
}
1213 1214 1215

u32 intel_crtc_get_vblank_counter(struct intel_crtc *crtc);

1216
int ironlake_get_lanes_required(int target_clock, int link_bw, int bpp);
1217
void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
1218 1219
			 struct intel_digital_port *dport,
			 unsigned int expected_mask);
1220 1221
bool intel_get_load_detect_pipe(struct drm_connector *connector,
				struct drm_display_mode *mode,
1222 1223
				struct intel_load_detect_pipe *old,
				struct drm_modeset_acquire_ctx *ctx);
1224
void intel_release_load_detect_pipe(struct drm_connector *connector,
1225 1226
				    struct intel_load_detect_pipe *old,
				    struct drm_modeset_acquire_ctx *ctx);
1227 1228
int intel_pin_and_fence_fb_obj(struct drm_framebuffer *fb,
			       unsigned int rotation);
1229
void intel_unpin_fb_obj(struct drm_framebuffer *fb, unsigned int rotation);
1230 1231
struct drm_framebuffer *
__intel_framebuffer_create(struct drm_device *dev,
1232 1233
			   struct drm_mode_fb_cmd2 *mode_cmd,
			   struct drm_i915_gem_object *obj);
1234
void intel_finish_page_flip_cs(struct drm_i915_private *dev_priv, int pipe);
1235
void intel_finish_page_flip_mmio(struct drm_i915_private *dev_priv, int pipe);
1236
void intel_check_page_flip(struct drm_i915_private *dev_priv, int pipe);
1237
int intel_prepare_plane_fb(struct drm_plane *plane,
1238
			   const struct drm_plane_state *new_state);
1239
void intel_cleanup_plane_fb(struct drm_plane *plane,
1240
			    const struct drm_plane_state *old_state);
1241 1242 1243 1244 1245 1246 1247 1248
int intel_plane_atomic_get_property(struct drm_plane *plane,
				    const struct drm_plane_state *state,
				    struct drm_property *property,
				    uint64_t *val);
int intel_plane_atomic_set_property(struct drm_plane *plane,
				    struct drm_plane_state *state,
				    struct drm_property *property,
				    uint64_t val);
1249 1250
int intel_plane_atomic_calc_changes(struct drm_crtc_state *crtc_state,
				    struct drm_plane_state *plane_state);
1251

1252 1253
unsigned int intel_tile_height(const struct drm_i915_private *dev_priv,
			       uint64_t fb_modifier, unsigned int cpp);
1254

1255 1256 1257
static inline bool
intel_rotation_90_or_270(unsigned int rotation)
{
1258
	return rotation & (DRM_ROTATE_90 | DRM_ROTATE_270);
1259 1260
}

1261 1262 1263
void intel_create_rotation_property(struct drm_device *dev,
					struct intel_plane *plane);

1264 1265 1266
void assert_pch_transcoder_disabled(struct drm_i915_private *dev_priv,
				    enum pipe pipe);

1267 1268
int vlv_force_pll_on(struct drm_device *dev, enum pipe pipe,
		     const struct dpll *dpll);
1269
void vlv_force_pll_off(struct drm_device *dev, enum pipe pipe);
1270
int lpt_get_iclkip(struct drm_i915_private *dev_priv);
1271

1272
/* modesetting asserts */
1273 1274
void assert_panel_unlocked(struct drm_i915_private *dev_priv,
			   enum pipe pipe);
1275 1276 1277 1278
void assert_pll(struct drm_i915_private *dev_priv,
		enum pipe pipe, bool state);
#define assert_pll_enabled(d, p) assert_pll(d, p, true)
#define assert_pll_disabled(d, p) assert_pll(d, p, false)
1279 1280 1281
void assert_dsi_pll(struct drm_i915_private *dev_priv, bool state);
#define assert_dsi_pll_enabled(d) assert_dsi_pll(d, true)
#define assert_dsi_pll_disabled(d) assert_dsi_pll(d, false)
1282 1283 1284 1285
void assert_fdi_rx_pll(struct drm_i915_private *dev_priv,
		       enum pipe pipe, bool state);
#define assert_fdi_rx_pll_enabled(d, p) assert_fdi_rx_pll(d, p, true)
#define assert_fdi_rx_pll_disabled(d, p) assert_fdi_rx_pll(d, p, false)
1286
void assert_pipe(struct drm_i915_private *dev_priv, enum pipe pipe, bool state);
1287 1288
#define assert_pipe_enabled(d, p) assert_pipe(d, p, true)
#define assert_pipe_disabled(d, p) assert_pipe(d, p, false)
1289 1290
u32 intel_compute_tile_offset(int *x, int *y,
			      const struct drm_framebuffer *fb, int plane,
1291 1292
			      unsigned int pitch,
			      unsigned int rotation);
1293 1294
void intel_prepare_reset(struct drm_i915_private *dev_priv);
void intel_finish_reset(struct drm_i915_private *dev_priv);
1295 1296
void hsw_enable_pc8(struct drm_i915_private *dev_priv);
void hsw_disable_pc8(struct drm_i915_private *dev_priv);
1297 1298
void bxt_init_cdclk(struct drm_i915_private *dev_priv);
void bxt_uninit_cdclk(struct drm_i915_private *dev_priv);
1299 1300 1301 1302 1303 1304
void bxt_ddi_phy_init(struct drm_i915_private *dev_priv, enum dpio_phy phy);
void bxt_ddi_phy_uninit(struct drm_i915_private *dev_priv, enum dpio_phy phy);
bool bxt_ddi_phy_is_enabled(struct drm_i915_private *dev_priv,
			    enum dpio_phy phy);
bool bxt_ddi_phy_verify_state(struct drm_i915_private *dev_priv,
			      enum dpio_phy phy);
1305
void gen9_sanitize_dc_state(struct drm_i915_private *dev_priv);
1306 1307
void bxt_enable_dc9(struct drm_i915_private *dev_priv);
void bxt_disable_dc9(struct drm_i915_private *dev_priv);
1308
void gen9_enable_dc5(struct drm_i915_private *dev_priv);
1309 1310
void skl_init_cdclk(struct drm_i915_private *dev_priv);
void skl_uninit_cdclk(struct drm_i915_private *dev_priv);
1311
unsigned int skl_cdclk_get_vco(unsigned int freq);
1312 1313
void skl_enable_dc6(struct drm_i915_private *dev_priv);
void skl_disable_dc6(struct drm_i915_private *dev_priv);
1314
void intel_dp_get_m_n(struct intel_crtc *crtc,
1315
		      struct intel_crtc_state *pipe_config);
1316
void intel_dp_set_m_n(struct intel_crtc *crtc, enum link_m_n_set m_n);
1317
int intel_dotclock_calculate(int link_freq, const struct intel_link_m_n *m_n);
I
Imre Deak 已提交
1318
bool bxt_find_best_dpll(struct intel_crtc_state *crtc_state, int target_clock,
1319 1320
			struct dpll *best_clock);
int chv_calc_dpll_params(int refclk, struct dpll *pll_clock);
1321

1322
bool intel_crtc_active(struct drm_crtc *crtc);
1323 1324
void hsw_enable_ips(struct intel_crtc *crtc);
void hsw_disable_ips(struct intel_crtc *crtc);
I
Imre Deak 已提交
1325 1326
enum intel_display_power_domain
intel_display_port_power_domain(struct intel_encoder *intel_encoder);
1327 1328
enum intel_display_power_domain
intel_display_port_aux_power_domain(struct intel_encoder *intel_encoder);
1329
void intel_mode_from_pipe_config(struct drm_display_mode *mode,
1330
				 struct intel_crtc_state *pipe_config);
1331

1332
int skl_update_scaler_crtc(struct intel_crtc_state *crtc_state);
1333
int skl_max_scale(struct intel_crtc *crtc, struct intel_crtc_state *crtc_state);
1334

1335 1336 1337
u32 intel_plane_obj_offset(struct intel_plane *intel_plane,
			   struct drm_i915_gem_object *obj,
			   unsigned int plane);
1338

1339 1340 1341
u32 skl_plane_ctl_format(uint32_t pixel_format);
u32 skl_plane_ctl_tiling(uint64_t fb_modifier);
u32 skl_plane_ctl_rotation(unsigned int rotation);
1342

1343
/* intel_csr.c */
1344
void intel_csr_ucode_init(struct drm_i915_private *);
1345
void intel_csr_load_program(struct drm_i915_private *);
1346
void intel_csr_ucode_fini(struct drm_i915_private *);
1347 1348
void intel_csr_ucode_suspend(struct drm_i915_private *);
void intel_csr_ucode_resume(struct drm_i915_private *);
1349

P
Paulo Zanoni 已提交
1350
/* intel_dp.c */
1351
bool intel_dp_init(struct drm_device *dev, i915_reg_t output_reg, enum port port);
1352 1353
bool intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
			     struct intel_connector *intel_connector);
1354 1355
void intel_dp_set_link_params(struct intel_dp *intel_dp,
			      const struct intel_crtc_state *pipe_config);
1356 1357 1358
void intel_dp_start_link_train(struct intel_dp *intel_dp);
void intel_dp_stop_link_train(struct intel_dp *intel_dp);
void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode);
1359 1360
void intel_dp_encoder_reset(struct drm_encoder *encoder);
void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder);
1361
void intel_dp_encoder_destroy(struct drm_encoder *encoder);
1362
int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc);
1363
bool intel_dp_compute_config(struct intel_encoder *encoder,
1364
			     struct intel_crtc_state *pipe_config);
1365
bool intel_dp_is_edp(struct drm_device *dev, enum port port);
1366 1367
enum irqreturn intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port,
				  bool long_hpd);
1368 1369
void intel_edp_backlight_on(struct intel_dp *intel_dp);
void intel_edp_backlight_off(struct intel_dp *intel_dp);
1370
void intel_edp_panel_vdd_on(struct intel_dp *intel_dp);
1371 1372
void intel_edp_panel_on(struct intel_dp *intel_dp);
void intel_edp_panel_off(struct intel_dp *intel_dp);
1373 1374 1375
void intel_dp_add_properties(struct intel_dp *intel_dp, struct drm_connector *connector);
void intel_dp_mst_suspend(struct drm_device *dev);
void intel_dp_mst_resume(struct drm_device *dev);
1376
int intel_dp_max_link_rate(struct intel_dp *intel_dp);
1377
int intel_dp_rate_select(struct intel_dp *intel_dp, int rate);
1378
void intel_dp_hot_plug(struct intel_encoder *intel_encoder);
1379
void intel_power_sequencer_reset(struct drm_i915_private *dev_priv);
R
Rodrigo Vivi 已提交
1380
uint32_t intel_dp_pack_aux(const uint8_t *src, int src_bytes);
1381
void intel_plane_destroy(struct drm_plane *plane);
V
Vandana Kannan 已提交
1382 1383
void intel_edp_drrs_enable(struct intel_dp *intel_dp);
void intel_edp_drrs_disable(struct intel_dp *intel_dp);
1384 1385 1386
void intel_edp_drrs_invalidate(struct drm_device *dev,
		unsigned frontbuffer_bits);
void intel_edp_drrs_flush(struct drm_device *dev, unsigned frontbuffer_bits);
1387 1388
bool intel_digital_port_connected(struct drm_i915_private *dev_priv,
					 struct intel_digital_port *port);
R
Rodrigo Vivi 已提交
1389

1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
void
intel_dp_program_link_training_pattern(struct intel_dp *intel_dp,
				       uint8_t dp_train_pat);
void
intel_dp_set_signal_levels(struct intel_dp *intel_dp);
void intel_dp_set_idle_link_train(struct intel_dp *intel_dp);
uint8_t
intel_dp_voltage_max(struct intel_dp *intel_dp);
uint8_t
intel_dp_pre_emphasis_max(struct intel_dp *intel_dp, uint8_t voltage_swing);
void intel_dp_compute_rate(struct intel_dp *intel_dp, int port_clock,
			   uint8_t *link_bw, uint8_t *rate_select);
1402
bool intel_dp_source_supports_hbr2(struct intel_dp *intel_dp);
1403 1404 1405
bool
intel_dp_get_link_status(struct intel_dp *intel_dp, uint8_t link_status[DP_LINK_STATUS_SIZE]);

1406 1407 1408 1409 1410
static inline unsigned int intel_dp_unused_lane_mask(int lane_count)
{
	return ~((1 << lane_count) - 1) & 0xf;
}

1411 1412 1413
/* intel_dp_aux_backlight.c */
int intel_dp_aux_init_backlight_funcs(struct intel_connector *intel_connector);

1414 1415 1416
/* intel_dp_mst.c */
int intel_dp_mst_encoder_init(struct intel_digital_port *intel_dig_port, int conn_id);
void intel_dp_mst_encoder_cleanup(struct intel_digital_port *intel_dig_port);
P
Paulo Zanoni 已提交
1417
/* intel_dsi.c */
1418
void intel_dsi_init(struct drm_device *dev);
P
Paulo Zanoni 已提交
1419

1420 1421
/* intel_dsi_dcs_backlight.c */
int intel_dsi_dcs_init_backlight_funcs(struct intel_connector *intel_connector);
P
Paulo Zanoni 已提交
1422 1423

/* intel_dvo.c */
1424
void intel_dvo_init(struct drm_device *dev);
1425 1426
/* intel_hotplug.c */
void intel_hpd_poll_init(struct drm_i915_private *dev_priv);
P
Paulo Zanoni 已提交
1427 1428


1429
/* legacy fbdev emulation in intel_fbdev.c */
1430
#ifdef CONFIG_DRM_FBDEV_EMULATION
1431
extern int intel_fbdev_init(struct drm_device *dev);
1432
extern void intel_fbdev_initial_config_async(struct drm_device *dev);
1433
extern void intel_fbdev_fini(struct drm_device *dev);
1434
extern void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous);
1435 1436
extern void intel_fbdev_output_poll_changed(struct drm_device *dev);
extern void intel_fbdev_restore_mode(struct drm_device *dev);
1437 1438 1439 1440 1441
#else
static inline int intel_fbdev_init(struct drm_device *dev)
{
	return 0;
}
P
Paulo Zanoni 已提交
1442

1443
static inline void intel_fbdev_initial_config_async(struct drm_device *dev)
1444 1445 1446 1447 1448 1449 1450
{
}

static inline void intel_fbdev_fini(struct drm_device *dev)
{
}

1451
static inline void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous)
1452 1453 1454
{
}

1455
static inline void intel_fbdev_restore_mode(struct drm_device *dev)
1456 1457 1458
{
}
#endif
P
Paulo Zanoni 已提交
1459

1460
/* intel_fbc.c */
1461 1462
void intel_fbc_choose_crtc(struct drm_i915_private *dev_priv,
			   struct drm_atomic_state *state);
1463
bool intel_fbc_is_active(struct drm_i915_private *dev_priv);
1464 1465 1466
void intel_fbc_pre_update(struct intel_crtc *crtc,
			  struct intel_crtc_state *crtc_state,
			  struct intel_plane_state *plane_state);
1467
void intel_fbc_post_update(struct intel_crtc *crtc);
1468
void intel_fbc_init(struct drm_i915_private *dev_priv);
1469
void intel_fbc_init_pipe_state(struct drm_i915_private *dev_priv);
1470 1471 1472
void intel_fbc_enable(struct intel_crtc *crtc,
		      struct intel_crtc_state *crtc_state,
		      struct intel_plane_state *plane_state);
1473 1474
void intel_fbc_disable(struct intel_crtc *crtc);
void intel_fbc_global_disable(struct drm_i915_private *dev_priv);
1475 1476 1477 1478
void intel_fbc_invalidate(struct drm_i915_private *dev_priv,
			  unsigned int frontbuffer_bits,
			  enum fb_op_origin origin);
void intel_fbc_flush(struct drm_i915_private *dev_priv,
1479
		     unsigned int frontbuffer_bits, enum fb_op_origin origin);
1480
void intel_fbc_cleanup_cfb(struct drm_i915_private *dev_priv);
1481

P
Paulo Zanoni 已提交
1482
/* intel_hdmi.c */
1483
void intel_hdmi_init(struct drm_device *dev, i915_reg_t hdmi_reg, enum port port);
1484 1485 1486 1487
void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
			       struct intel_connector *intel_connector);
struct intel_hdmi *enc_to_intel_hdmi(struct drm_encoder *encoder);
bool intel_hdmi_compute_config(struct intel_encoder *encoder,
1488
			       struct intel_crtc_state *pipe_config);
1489
void intel_dp_dual_mode_set_tmds_output(struct intel_hdmi *hdmi, bool enable);
P
Paulo Zanoni 已提交
1490 1491 1492


/* intel_lvds.c */
1493
void intel_lvds_init(struct drm_device *dev);
1494
struct intel_encoder *intel_get_lvds_encoder(struct drm_device *dev);
1495
bool intel_is_dual_link_lvds(struct drm_device *dev);
P
Paulo Zanoni 已提交
1496 1497 1498 1499


/* intel_modes.c */
int intel_connector_update_modes(struct drm_connector *connector,
1500
				 struct edid *edid);
P
Paulo Zanoni 已提交
1501
int intel_ddc_get_modes(struct drm_connector *c, struct i2c_adapter *adapter);
1502 1503
void intel_attach_force_audio_property(struct drm_connector *connector);
void intel_attach_broadcast_rgb_property(struct drm_connector *connector);
1504
void intel_attach_aspect_ratio_property(struct drm_connector *connector);
P
Paulo Zanoni 已提交
1505 1506 1507


/* intel_overlay.c */
1508 1509
void intel_setup_overlay(struct drm_i915_private *dev_priv);
void intel_cleanup_overlay(struct drm_i915_private *dev_priv);
1510
int intel_overlay_switch_off(struct intel_overlay *overlay);
1511 1512 1513 1514
int intel_overlay_put_image_ioctl(struct drm_device *dev, void *data,
				  struct drm_file *file_priv);
int intel_overlay_attrs_ioctl(struct drm_device *dev, void *data,
			      struct drm_file *file_priv);
1515
void intel_overlay_reset(struct drm_i915_private *dev_priv);
P
Paulo Zanoni 已提交
1516 1517 1518


/* intel_panel.c */
1519
int intel_panel_init(struct intel_panel *panel,
1520 1521
		     struct drm_display_mode *fixed_mode,
		     struct drm_display_mode *downclock_mode);
1522 1523 1524 1525
void intel_panel_fini(struct intel_panel *panel);
void intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode,
			    struct drm_display_mode *adjusted_mode);
void intel_pch_panel_fitting(struct intel_crtc *crtc,
1526
			     struct intel_crtc_state *pipe_config,
1527 1528
			     int fitting_mode);
void intel_gmch_panel_fitting(struct intel_crtc *crtc,
1529
			      struct intel_crtc_state *pipe_config,
1530
			      int fitting_mode);
1531 1532
void intel_panel_set_backlight_acpi(struct intel_connector *connector,
				    u32 level, u32 max);
1533 1534
int intel_panel_setup_backlight(struct drm_connector *connector,
				enum pipe pipe);
1535 1536
void intel_panel_enable_backlight(struct intel_connector *connector);
void intel_panel_disable_backlight(struct intel_connector *connector);
1537
void intel_panel_destroy_backlight(struct drm_connector *connector);
1538
enum drm_connector_status intel_panel_detect(struct drm_device *dev);
1539 1540 1541 1542
extern struct drm_display_mode *intel_find_panel_downclock(
				struct drm_device *dev,
				struct drm_display_mode *fixed_mode,
				struct drm_connector *connector);
1543 1544

#if IS_ENABLED(CONFIG_BACKLIGHT_CLASS_DEVICE)
1545
int intel_backlight_device_register(struct intel_connector *connector);
1546 1547
void intel_backlight_device_unregister(struct intel_connector *connector);
#else /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1548 1549 1550 1551
static int intel_backlight_device_register(struct intel_connector *connector)
{
	return 0;
}
1552 1553 1554 1555
static inline void intel_backlight_device_unregister(struct intel_connector *connector)
{
}
#endif /* CONFIG_BACKLIGHT_CLASS_DEVICE */
1556

P
Paulo Zanoni 已提交
1557

R
Rodrigo Vivi 已提交
1558 1559 1560 1561
/* intel_psr.c */
void intel_psr_enable(struct intel_dp *intel_dp);
void intel_psr_disable(struct intel_dp *intel_dp);
void intel_psr_invalidate(struct drm_device *dev,
1562
			  unsigned frontbuffer_bits);
R
Rodrigo Vivi 已提交
1563
void intel_psr_flush(struct drm_device *dev,
1564 1565
		     unsigned frontbuffer_bits,
		     enum fb_op_origin origin);
R
Rodrigo Vivi 已提交
1566
void intel_psr_init(struct drm_device *dev);
1567 1568
void intel_psr_single_frame_update(struct drm_device *dev,
				   unsigned frontbuffer_bits);
R
Rodrigo Vivi 已提交
1569

1570 1571
/* intel_runtime_pm.c */
int intel_power_domains_init(struct drm_i915_private *);
1572
void intel_power_domains_fini(struct drm_i915_private *);
1573 1574
void intel_power_domains_init_hw(struct drm_i915_private *dev_priv, bool resume);
void intel_power_domains_suspend(struct drm_i915_private *dev_priv);
1575 1576
void bxt_display_core_init(struct drm_i915_private *dev_priv, bool resume);
void bxt_display_core_uninit(struct drm_i915_private *dev_priv);
1577
void intel_runtime_pm_enable(struct drm_i915_private *dev_priv);
1578 1579
const char *
intel_display_power_domain_str(enum intel_display_power_domain domain);
1580

1581 1582 1583 1584
bool intel_display_power_is_enabled(struct drm_i915_private *dev_priv,
				    enum intel_display_power_domain domain);
bool __intel_display_power_is_enabled(struct drm_i915_private *dev_priv,
				      enum intel_display_power_domain domain);
1585 1586
void intel_display_power_get(struct drm_i915_private *dev_priv,
			     enum intel_display_power_domain domain);
1587 1588
bool intel_display_power_get_if_enabled(struct drm_i915_private *dev_priv,
					enum intel_display_power_domain domain);
1589 1590
void intel_display_power_put(struct drm_i915_private *dev_priv,
			     enum intel_display_power_domain domain);
1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602

static inline void
assert_rpm_device_not_suspended(struct drm_i915_private *dev_priv)
{
	WARN_ONCE(dev_priv->pm.suspended,
		  "Device suspended during HW access\n");
}

static inline void
assert_rpm_wakelock_held(struct drm_i915_private *dev_priv)
{
	assert_rpm_device_not_suspended(dev_priv);
1603 1604 1605 1606
	/* FIXME: Needs to be converted back to WARN_ONCE, but currently causes
	 * too much noise. */
	if (!atomic_read(&dev_priv->pm.wakeref_count))
		DRM_DEBUG_DRIVER("RPM wakelock ref not held during HW access");
1607 1608
}

1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
static inline int
assert_rpm_atomic_begin(struct drm_i915_private *dev_priv)
{
	int seq = atomic_read(&dev_priv->pm.atomic_seq);

	assert_rpm_wakelock_held(dev_priv);

	return seq;
}

static inline void
assert_rpm_atomic_end(struct drm_i915_private *dev_priv, int begin_seq)
{
	WARN_ONCE(atomic_read(&dev_priv->pm.atomic_seq) != begin_seq,
		  "HW access outside of RPM atomic section\n");
}

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
/**
 * disable_rpm_wakeref_asserts - disable the RPM assert checks
 * @dev_priv: i915 device instance
 *
 * This function disable asserts that check if we hold an RPM wakelock
 * reference, while keeping the device-not-suspended checks still enabled.
 * It's meant to be used only in special circumstances where our rule about
 * the wakelock refcount wrt. the device power state doesn't hold. According
 * to this rule at any point where we access the HW or want to keep the HW in
 * an active state we must hold an RPM wakelock reference acquired via one of
 * the intel_runtime_pm_get() helpers. Currently there are a few special spots
 * where this rule doesn't hold: the IRQ and suspend/resume handlers, the
 * forcewake release timer, and the GPU RPS and hangcheck works. All other
 * users should avoid using this function.
 *
 * Any calls to this function must have a symmetric call to
 * enable_rpm_wakeref_asserts().
 */
static inline void
disable_rpm_wakeref_asserts(struct drm_i915_private *dev_priv)
{
	atomic_inc(&dev_priv->pm.wakeref_count);
}

/**
 * enable_rpm_wakeref_asserts - re-enable the RPM assert checks
 * @dev_priv: i915 device instance
 *
 * This function re-enables the RPM assert checks after disabling them with
 * disable_rpm_wakeref_asserts. It's meant to be used only in special
 * circumstances otherwise its use should be avoided.
 *
 * Any calls to this function must have a symmetric call to
 * disable_rpm_wakeref_asserts().
 */
static inline void
enable_rpm_wakeref_asserts(struct drm_i915_private *dev_priv)
{
	atomic_dec(&dev_priv->pm.wakeref_count);
}

/* TODO: convert users of these to rely instead on proper RPM refcounting */
#define DISABLE_RPM_WAKEREF_ASSERTS(dev_priv)	\
	disable_rpm_wakeref_asserts(dev_priv)

#define ENABLE_RPM_WAKEREF_ASSERTS(dev_priv)	\
	enable_rpm_wakeref_asserts(dev_priv)

1674
void intel_runtime_pm_get(struct drm_i915_private *dev_priv);
1675
bool intel_runtime_pm_get_if_in_use(struct drm_i915_private *dev_priv);
1676 1677 1678
void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv);
void intel_runtime_pm_put(struct drm_i915_private *dev_priv);

1679 1680
void intel_display_set_init_power(struct drm_i915_private *dev, bool enable);

1681 1682
void chv_phy_powergate_lanes(struct intel_encoder *encoder,
			     bool override, unsigned int mask);
1683 1684
bool chv_phy_powergate_ch(struct drm_i915_private *dev_priv, enum dpio_phy phy,
			  enum dpio_channel ch, bool override);
1685 1686


P
Paulo Zanoni 已提交
1687
/* intel_pm.c */
1688 1689
void intel_init_clock_gating(struct drm_device *dev);
void intel_suspend_hw(struct drm_device *dev);
1690
int ilk_wm_max_level(const struct drm_device *dev);
1691 1692
void intel_update_watermarks(struct drm_crtc *crtc);
void intel_init_pm(struct drm_device *dev);
1693
void intel_init_clock_gating_hooks(struct drm_i915_private *dev_priv);
D
Daniel Vetter 已提交
1694
void intel_pm_setup(struct drm_device *dev);
1695 1696
void intel_gpu_ips_init(struct drm_i915_private *dev_priv);
void intel_gpu_ips_teardown(void);
1697 1698 1699 1700 1701 1702 1703
void intel_init_gt_powersave(struct drm_i915_private *dev_priv);
void intel_cleanup_gt_powersave(struct drm_i915_private *dev_priv);
void intel_enable_gt_powersave(struct drm_i915_private *dev_priv);
void intel_disable_gt_powersave(struct drm_i915_private *dev_priv);
void intel_suspend_gt_powersave(struct drm_i915_private *dev_priv);
void intel_reset_gt_powersave(struct drm_i915_private *dev_priv);
void gen6_update_ring_freq(struct drm_i915_private *dev_priv);
1704 1705
void gen6_rps_busy(struct drm_i915_private *dev_priv);
void gen6_rps_reset_ei(struct drm_i915_private *dev_priv);
D
Daniel Vetter 已提交
1706
void gen6_rps_idle(struct drm_i915_private *dev_priv);
1707
void gen6_rps_boost(struct drm_i915_private *dev_priv,
1708 1709
		    struct intel_rps_client *rps,
		    unsigned long submitted);
1710
void intel_queue_rps_boost_for_request(struct drm_i915_gem_request *req);
1711
void vlv_wm_get_hw_state(struct drm_device *dev);
1712
void ilk_wm_get_hw_state(struct drm_device *dev);
1713
void skl_wm_get_hw_state(struct drm_device *dev);
1714 1715
void skl_ddb_get_hw_state(struct drm_i915_private *dev_priv,
			  struct skl_ddb_allocation *ddb /* out */);
1716
uint32_t ilk_pipe_pixel_rate(const struct intel_crtc_state *pipe_config);
1717
bool ilk_disable_lp_wm(struct drm_device *dev);
1718 1719 1720 1721 1722
int sanitize_rc6_option(struct drm_i915_private *dev_priv, int enable_rc6);
static inline int intel_enable_rc6(void)
{
	return i915.enable_rc6;
}
1723

P
Paulo Zanoni 已提交
1724
/* intel_sdvo.c */
1725 1726
bool intel_sdvo_init(struct drm_device *dev,
		     i915_reg_t reg, enum port port);
1727

R
Rodrigo Vivi 已提交
1728

P
Paulo Zanoni 已提交
1729
/* intel_sprite.c */
1730 1731
int intel_usecs_to_scanlines(const struct drm_display_mode *adjusted_mode,
			     int usecs);
1732 1733 1734
int intel_plane_init(struct drm_device *dev, enum pipe pipe, int plane);
int intel_sprite_set_colorkey(struct drm_device *dev, void *data,
			      struct drm_file *file_priv);
1735
void intel_pipe_update_start(struct intel_crtc *crtc);
1736
void intel_pipe_update_end(struct intel_crtc *crtc, struct intel_flip_work *work);
P
Paulo Zanoni 已提交
1737 1738

/* intel_tv.c */
1739
void intel_tv_init(struct drm_device *dev);
1740

1741
/* intel_atomic.c */
1742 1743 1744 1745
int intel_connector_atomic_get_property(struct drm_connector *connector,
					const struct drm_connector_state *state,
					struct drm_property *property,
					uint64_t *val);
1746 1747 1748
struct drm_crtc_state *intel_crtc_duplicate_state(struct drm_crtc *crtc);
void intel_crtc_destroy_state(struct drm_crtc *crtc,
			       struct drm_crtc_state *state);
1749 1750 1751 1752 1753
struct drm_atomic_state *intel_atomic_state_alloc(struct drm_device *dev);
void intel_atomic_state_clear(struct drm_atomic_state *);
struct intel_shared_dpll_config *
intel_atomic_get_shared_dpll_state(struct drm_atomic_state *s);

1754 1755 1756 1757 1758 1759 1760
static inline struct intel_crtc_state *
intel_atomic_get_crtc_state(struct drm_atomic_state *state,
			    struct intel_crtc *crtc)
{
	struct drm_crtc_state *crtc_state;
	crtc_state = drm_atomic_get_crtc_state(state, &crtc->base);
	if (IS_ERR(crtc_state))
1761
		return ERR_CAST(crtc_state);
1762 1763 1764

	return to_intel_crtc_state(crtc_state);
}
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776

static inline struct intel_plane_state *
intel_atomic_get_existing_plane_state(struct drm_atomic_state *state,
				      struct intel_plane *plane)
{
	struct drm_plane_state *plane_state;

	plane_state = drm_atomic_get_existing_plane_state(state, &plane->base);

	return to_intel_plane_state(plane_state);
}

1777 1778 1779
int intel_atomic_setup_scalers(struct drm_device *dev,
	struct intel_crtc *intel_crtc,
	struct intel_crtc_state *crtc_state);
1780 1781

/* intel_atomic_plane.c */
1782
struct intel_plane_state *intel_create_plane_state(struct drm_plane *plane);
1783 1784 1785 1786 1787
struct drm_plane_state *intel_plane_duplicate_state(struct drm_plane *plane);
void intel_plane_destroy_state(struct drm_plane *plane,
			       struct drm_plane_state *state);
extern const struct drm_plane_helper_funcs intel_plane_helper_funcs;

1788 1789
/* intel_color.c */
void intel_color_init(struct drm_crtc *crtc);
1790
int intel_color_check(struct drm_crtc *crtc, struct drm_crtc_state *state);
1791 1792
void intel_color_set_csc(struct drm_crtc_state *crtc_state);
void intel_color_load_luts(struct drm_crtc_state *crtc_state);
1793

J
Jesse Barnes 已提交
1794
#endif /* __INTEL_DRV_H__ */