Re: [RESEND PATCH v12] drm/i915/debugfs: Move out pipe CRC code

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Mon, Dec 12, 2016 at 01:29:48PM +0100, Tomeu Vizoso wrote:
> In preparation to using a generic API in the DRM core for continuous CRC
> generation, move the related code out of i915_debugfs.c into a new file.
> 
> Eventually, only the Intel-specific code will remain in this new file.
> 
> v2: Rebased.
> 
> v6: Rebased.
> 
> v7: Fix whitespace issue.
> 
> v9: Have intel_display_crc_init accept a drm_i915_private instead.
> 
> v12: Rebased.
> 
> Signed-off-by: Tomeu Vizoso <tomeu.vizoso@xxxxxxxxxxxxx>
> Reviewed-by: Emil Velikov <emil.velikov@xxxxxxxxxxxxx>

Applied, thanks.
-Daniel

> ---
>  drivers/gpu/drm/i915/Makefile         |   2 +-
>  drivers/gpu/drm/i915/i915_debugfs.c   | 882 +------------------------------
>  drivers/gpu/drm/i915/intel_drv.h      |   5 +
>  drivers/gpu/drm/i915/intel_pipe_crc.c | 939 ++++++++++++++++++++++++++++++++++
>  4 files changed, 949 insertions(+), 879 deletions(-)
>  create mode 100644 drivers/gpu/drm/i915/intel_pipe_crc.c
> 
> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
> index 3c30916727fb..5196509e71cf 100644
> --- a/drivers/gpu/drm/i915/Makefile
> +++ b/drivers/gpu/drm/i915/Makefile
> @@ -24,7 +24,7 @@ i915-y := i915_drv.o \
>  	  intel_runtime_pm.o
>  
>  i915-$(CONFIG_COMPAT)   += i915_ioc32.o
> -i915-$(CONFIG_DEBUG_FS) += i915_debugfs.o
> +i915-$(CONFIG_DEBUG_FS) += i915_debugfs.o intel_pipe_crc.o
>  
>  # GEM code
>  i915-y += i915_cmd_parser.o \
> diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
> index 54e196d9d83e..1fad1235a0c7 100644
> --- a/drivers/gpu/drm/i915/i915_debugfs.c
> +++ b/drivers/gpu/drm/i915/i915_debugfs.c
> @@ -26,19 +26,9 @@
>   *
>   */
>  
> -#include <linux/seq_file.h>
> -#include <linux/circ_buf.h>
> -#include <linux/ctype.h>
>  #include <linux/debugfs.h>
> -#include <linux/slab.h>
> -#include <linux/export.h>
>  #include <linux/list_sort.h>
> -#include <asm/msr-index.h>
> -#include <drm/drmP.h>
>  #include "intel_drv.h"
> -#include "intel_ringbuffer.h"
> -#include <drm/i915_drm.h>
> -#include "i915_drv.h"
>  
>  static inline struct drm_i915_private *node_to_i915(struct drm_info_node *node)
>  {
> @@ -3546,12 +3536,6 @@ static int i915_drrs_status(struct seq_file *m, void *unused)
>  	return 0;
>  }
>  
> -struct pipe_crc_info {
> -	const char *name;
> -	struct drm_i915_private *dev_priv;
> -	enum pipe pipe;
> -};
> -
>  static int i915_dp_mst_info(struct seq_file *m, void *unused)
>  {
>  	struct drm_i915_private *dev_priv = node_to_i915(m->private);
> @@ -3581,844 +3565,6 @@ static int i915_dp_mst_info(struct seq_file *m, void *unused)
>  	return 0;
>  }
>  
> -static int i915_pipe_crc_open(struct inode *inode, struct file *filep)
> -{
> -	struct pipe_crc_info *info = inode->i_private;
> -	struct drm_i915_private *dev_priv = info->dev_priv;
> -	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
> -
> -	if (info->pipe >= INTEL_INFO(dev_priv)->num_pipes)
> -		return -ENODEV;
> -
> -	spin_lock_irq(&pipe_crc->lock);
> -
> -	if (pipe_crc->opened) {
> -		spin_unlock_irq(&pipe_crc->lock);
> -		return -EBUSY; /* already open */
> -	}
> -
> -	pipe_crc->opened = true;
> -	filep->private_data = inode->i_private;
> -
> -	spin_unlock_irq(&pipe_crc->lock);
> -
> -	return 0;
> -}
> -
> -static int i915_pipe_crc_release(struct inode *inode, struct file *filep)
> -{
> -	struct pipe_crc_info *info = inode->i_private;
> -	struct drm_i915_private *dev_priv = info->dev_priv;
> -	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
> -
> -	spin_lock_irq(&pipe_crc->lock);
> -	pipe_crc->opened = false;
> -	spin_unlock_irq(&pipe_crc->lock);
> -
> -	return 0;
> -}
> -
> -/* (6 fields, 8 chars each, space separated (5) + '\n') */
> -#define PIPE_CRC_LINE_LEN	(6 * 8 + 5 + 1)
> -/* account for \'0' */
> -#define PIPE_CRC_BUFFER_LEN	(PIPE_CRC_LINE_LEN + 1)
> -
> -static int pipe_crc_data_count(struct intel_pipe_crc *pipe_crc)
> -{
> -	assert_spin_locked(&pipe_crc->lock);
> -	return CIRC_CNT(pipe_crc->head, pipe_crc->tail,
> -			INTEL_PIPE_CRC_ENTRIES_NR);
> -}
> -
> -static ssize_t
> -i915_pipe_crc_read(struct file *filep, char __user *user_buf, size_t count,
> -		   loff_t *pos)
> -{
> -	struct pipe_crc_info *info = filep->private_data;
> -	struct drm_i915_private *dev_priv = info->dev_priv;
> -	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
> -	char buf[PIPE_CRC_BUFFER_LEN];
> -	int n_entries;
> -	ssize_t bytes_read;
> -
> -	/*
> -	 * Don't allow user space to provide buffers not big enough to hold
> -	 * a line of data.
> -	 */
> -	if (count < PIPE_CRC_LINE_LEN)
> -		return -EINVAL;
> -
> -	if (pipe_crc->source == INTEL_PIPE_CRC_SOURCE_NONE)
> -		return 0;
> -
> -	/* nothing to read */
> -	spin_lock_irq(&pipe_crc->lock);
> -	while (pipe_crc_data_count(pipe_crc) == 0) {
> -		int ret;
> -
> -		if (filep->f_flags & O_NONBLOCK) {
> -			spin_unlock_irq(&pipe_crc->lock);
> -			return -EAGAIN;
> -		}
> -
> -		ret = wait_event_interruptible_lock_irq(pipe_crc->wq,
> -				pipe_crc_data_count(pipe_crc), pipe_crc->lock);
> -		if (ret) {
> -			spin_unlock_irq(&pipe_crc->lock);
> -			return ret;
> -		}
> -	}
> -
> -	/* We now have one or more entries to read */
> -	n_entries = count / PIPE_CRC_LINE_LEN;
> -
> -	bytes_read = 0;
> -	while (n_entries > 0) {
> -		struct intel_pipe_crc_entry *entry =
> -			&pipe_crc->entries[pipe_crc->tail];
> -
> -		if (CIRC_CNT(pipe_crc->head, pipe_crc->tail,
> -			     INTEL_PIPE_CRC_ENTRIES_NR) < 1)
> -			break;
> -
> -		BUILD_BUG_ON_NOT_POWER_OF_2(INTEL_PIPE_CRC_ENTRIES_NR);
> -		pipe_crc->tail = (pipe_crc->tail + 1) & (INTEL_PIPE_CRC_ENTRIES_NR - 1);
> -
> -		bytes_read += snprintf(buf, PIPE_CRC_BUFFER_LEN,
> -				       "%8u %8x %8x %8x %8x %8x\n",
> -				       entry->frame, entry->crc[0],
> -				       entry->crc[1], entry->crc[2],
> -				       entry->crc[3], entry->crc[4]);
> -
> -		spin_unlock_irq(&pipe_crc->lock);
> -
> -		if (copy_to_user(user_buf, buf, PIPE_CRC_LINE_LEN))
> -			return -EFAULT;
> -
> -		user_buf += PIPE_CRC_LINE_LEN;
> -		n_entries--;
> -
> -		spin_lock_irq(&pipe_crc->lock);
> -	}
> -
> -	spin_unlock_irq(&pipe_crc->lock);
> -
> -	return bytes_read;
> -}
> -
> -static const struct file_operations i915_pipe_crc_fops = {
> -	.owner = THIS_MODULE,
> -	.open = i915_pipe_crc_open,
> -	.read = i915_pipe_crc_read,
> -	.release = i915_pipe_crc_release,
> -};
> -
> -static struct pipe_crc_info i915_pipe_crc_data[I915_MAX_PIPES] = {
> -	{
> -		.name = "i915_pipe_A_crc",
> -		.pipe = PIPE_A,
> -	},
> -	{
> -		.name = "i915_pipe_B_crc",
> -		.pipe = PIPE_B,
> -	},
> -	{
> -		.name = "i915_pipe_C_crc",
> -		.pipe = PIPE_C,
> -	},
> -};
> -
> -static int i915_pipe_crc_create(struct dentry *root, struct drm_minor *minor,
> -				enum pipe pipe)
> -{
> -	struct drm_i915_private *dev_priv = to_i915(minor->dev);
> -	struct dentry *ent;
> -	struct pipe_crc_info *info = &i915_pipe_crc_data[pipe];
> -
> -	info->dev_priv = dev_priv;
> -	ent = debugfs_create_file(info->name, S_IRUGO, root, info,
> -				  &i915_pipe_crc_fops);
> -	if (!ent)
> -		return -ENOMEM;
> -
> -	return drm_add_fake_info_node(minor, ent, info);
> -}
> -
> -static const char * const pipe_crc_sources[] = {
> -	"none",
> -	"plane1",
> -	"plane2",
> -	"pf",
> -	"pipe",
> -	"TV",
> -	"DP-B",
> -	"DP-C",
> -	"DP-D",
> -	"auto",
> -};
> -
> -static const char *pipe_crc_source_name(enum intel_pipe_crc_source source)
> -{
> -	BUILD_BUG_ON(ARRAY_SIZE(pipe_crc_sources) != INTEL_PIPE_CRC_SOURCE_MAX);
> -	return pipe_crc_sources[source];
> -}
> -
> -static int display_crc_ctl_show(struct seq_file *m, void *data)
> -{
> -	struct drm_i915_private *dev_priv = m->private;
> -	int i;
> -
> -	for (i = 0; i < I915_MAX_PIPES; i++)
> -		seq_printf(m, "%c %s\n", pipe_name(i),
> -			   pipe_crc_source_name(dev_priv->pipe_crc[i].source));
> -
> -	return 0;
> -}
> -
> -static int display_crc_ctl_open(struct inode *inode, struct file *file)
> -{
> -	return single_open(file, display_crc_ctl_show, inode->i_private);
> -}
> -
> -static int i8xx_pipe_crc_ctl_reg(enum intel_pipe_crc_source *source,
> -				 uint32_t *val)
> -{
> -	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
> -		*source = INTEL_PIPE_CRC_SOURCE_PIPE;
> -
> -	switch (*source) {
> -	case INTEL_PIPE_CRC_SOURCE_PIPE:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_INCLUDE_BORDER_I8XX;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_NONE:
> -		*val = 0;
> -		break;
> -	default:
> -		return -EINVAL;
> -	}
> -
> -	return 0;
> -}
> -
> -static int i9xx_pipe_crc_auto_source(struct drm_i915_private *dev_priv,
> -				     enum pipe pipe,
> -				     enum intel_pipe_crc_source *source)
> -{
> -	struct drm_device *dev = &dev_priv->drm;
> -	struct intel_encoder *encoder;
> -	struct intel_crtc *crtc;
> -	struct intel_digital_port *dig_port;
> -	int ret = 0;
> -
> -	*source = INTEL_PIPE_CRC_SOURCE_PIPE;
> -
> -	drm_modeset_lock_all(dev);
> -	for_each_intel_encoder(dev, encoder) {
> -		if (!encoder->base.crtc)
> -			continue;
> -
> -		crtc = to_intel_crtc(encoder->base.crtc);
> -
> -		if (crtc->pipe != pipe)
> -			continue;
> -
> -		switch (encoder->type) {
> -		case INTEL_OUTPUT_TVOUT:
> -			*source = INTEL_PIPE_CRC_SOURCE_TV;
> -			break;
> -		case INTEL_OUTPUT_DP:
> -		case INTEL_OUTPUT_EDP:
> -			dig_port = enc_to_dig_port(&encoder->base);
> -			switch (dig_port->port) {
> -			case PORT_B:
> -				*source = INTEL_PIPE_CRC_SOURCE_DP_B;
> -				break;
> -			case PORT_C:
> -				*source = INTEL_PIPE_CRC_SOURCE_DP_C;
> -				break;
> -			case PORT_D:
> -				*source = INTEL_PIPE_CRC_SOURCE_DP_D;
> -				break;
> -			default:
> -				WARN(1, "nonexisting DP port %c\n",
> -				     port_name(dig_port->port));
> -				break;
> -			}
> -			break;
> -		default:
> -			break;
> -		}
> -	}
> -	drm_modeset_unlock_all(dev);
> -
> -	return ret;
> -}
> -
> -static int vlv_pipe_crc_ctl_reg(struct drm_i915_private *dev_priv,
> -				enum pipe pipe,
> -				enum intel_pipe_crc_source *source,
> -				uint32_t *val)
> -{
> -	bool need_stable_symbols = false;
> -
> -	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO) {
> -		int ret = i9xx_pipe_crc_auto_source(dev_priv, pipe, source);
> -		if (ret)
> -			return ret;
> -	}
> -
> -	switch (*source) {
> -	case INTEL_PIPE_CRC_SOURCE_PIPE:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_VLV;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_DP_B:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_B_VLV;
> -		need_stable_symbols = true;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_DP_C:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_C_VLV;
> -		need_stable_symbols = true;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_DP_D:
> -		if (!IS_CHERRYVIEW(dev_priv))
> -			return -EINVAL;
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_D_VLV;
> -		need_stable_symbols = true;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_NONE:
> -		*val = 0;
> -		break;
> -	default:
> -		return -EINVAL;
> -	}
> -
> -	/*
> -	 * When the pipe CRC tap point is after the transcoders we need
> -	 * to tweak symbol-level features to produce a deterministic series of
> -	 * symbols for a given frame. We need to reset those features only once
> -	 * a frame (instead of every nth symbol):
> -	 *   - DC-balance: used to ensure a better clock recovery from the data
> -	 *     link (SDVO)
> -	 *   - DisplayPort scrambling: used for EMI reduction
> -	 */
> -	if (need_stable_symbols) {
> -		uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> -
> -		tmp |= DC_BALANCE_RESET_VLV;
> -		switch (pipe) {
> -		case PIPE_A:
> -			tmp |= PIPE_A_SCRAMBLE_RESET;
> -			break;
> -		case PIPE_B:
> -			tmp |= PIPE_B_SCRAMBLE_RESET;
> -			break;
> -		case PIPE_C:
> -			tmp |= PIPE_C_SCRAMBLE_RESET;
> -			break;
> -		default:
> -			return -EINVAL;
> -		}
> -		I915_WRITE(PORT_DFT2_G4X, tmp);
> -	}
> -
> -	return 0;
> -}
> -
> -static int i9xx_pipe_crc_ctl_reg(struct drm_i915_private *dev_priv,
> -				 enum pipe pipe,
> -				 enum intel_pipe_crc_source *source,
> -				 uint32_t *val)
> -{
> -	bool need_stable_symbols = false;
> -
> -	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO) {
> -		int ret = i9xx_pipe_crc_auto_source(dev_priv, pipe, source);
> -		if (ret)
> -			return ret;
> -	}
> -
> -	switch (*source) {
> -	case INTEL_PIPE_CRC_SOURCE_PIPE:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_I9XX;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_TV:
> -		if (!SUPPORTS_TV(dev_priv))
> -			return -EINVAL;
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_TV_PRE;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_DP_B:
> -		if (!IS_G4X(dev_priv))
> -			return -EINVAL;
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_B_G4X;
> -		need_stable_symbols = true;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_DP_C:
> -		if (!IS_G4X(dev_priv))
> -			return -EINVAL;
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_C_G4X;
> -		need_stable_symbols = true;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_DP_D:
> -		if (!IS_G4X(dev_priv))
> -			return -EINVAL;
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_D_G4X;
> -		need_stable_symbols = true;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_NONE:
> -		*val = 0;
> -		break;
> -	default:
> -		return -EINVAL;
> -	}
> -
> -	/*
> -	 * When the pipe CRC tap point is after the transcoders we need
> -	 * to tweak symbol-level features to produce a deterministic series of
> -	 * symbols for a given frame. We need to reset those features only once
> -	 * a frame (instead of every nth symbol):
> -	 *   - DC-balance: used to ensure a better clock recovery from the data
> -	 *     link (SDVO)
> -	 *   - DisplayPort scrambling: used for EMI reduction
> -	 */
> -	if (need_stable_symbols) {
> -		uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> -
> -		WARN_ON(!IS_G4X(dev_priv));
> -
> -		I915_WRITE(PORT_DFT_I9XX,
> -			   I915_READ(PORT_DFT_I9XX) | DC_BALANCE_RESET);
> -
> -		if (pipe == PIPE_A)
> -			tmp |= PIPE_A_SCRAMBLE_RESET;
> -		else
> -			tmp |= PIPE_B_SCRAMBLE_RESET;
> -
> -		I915_WRITE(PORT_DFT2_G4X, tmp);
> -	}
> -
> -	return 0;
> -}
> -
> -static void vlv_undo_pipe_scramble_reset(struct drm_i915_private *dev_priv,
> -					 enum pipe pipe)
> -{
> -	uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> -
> -	switch (pipe) {
> -	case PIPE_A:
> -		tmp &= ~PIPE_A_SCRAMBLE_RESET;
> -		break;
> -	case PIPE_B:
> -		tmp &= ~PIPE_B_SCRAMBLE_RESET;
> -		break;
> -	case PIPE_C:
> -		tmp &= ~PIPE_C_SCRAMBLE_RESET;
> -		break;
> -	default:
> -		return;
> -	}
> -	if (!(tmp & PIPE_SCRAMBLE_RESET_MASK))
> -		tmp &= ~DC_BALANCE_RESET_VLV;
> -	I915_WRITE(PORT_DFT2_G4X, tmp);
> -
> -}
> -
> -static void g4x_undo_pipe_scramble_reset(struct drm_i915_private *dev_priv,
> -					 enum pipe pipe)
> -{
> -	uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> -
> -	if (pipe == PIPE_A)
> -		tmp &= ~PIPE_A_SCRAMBLE_RESET;
> -	else
> -		tmp &= ~PIPE_B_SCRAMBLE_RESET;
> -	I915_WRITE(PORT_DFT2_G4X, tmp);
> -
> -	if (!(tmp & PIPE_SCRAMBLE_RESET_MASK)) {
> -		I915_WRITE(PORT_DFT_I9XX,
> -			   I915_READ(PORT_DFT_I9XX) & ~DC_BALANCE_RESET);
> -	}
> -}
> -
> -static int ilk_pipe_crc_ctl_reg(enum intel_pipe_crc_source *source,
> -				uint32_t *val)
> -{
> -	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
> -		*source = INTEL_PIPE_CRC_SOURCE_PIPE;
> -
> -	switch (*source) {
> -	case INTEL_PIPE_CRC_SOURCE_PLANE1:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PRIMARY_ILK;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_PLANE2:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_SPRITE_ILK;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_PIPE:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_ILK;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_NONE:
> -		*val = 0;
> -		break;
> -	default:
> -		return -EINVAL;
> -	}
> -
> -	return 0;
> -}
> -
> -static void hsw_trans_edp_pipe_A_crc_wa(struct drm_i915_private *dev_priv,
> -					bool enable)
> -{
> -	struct drm_device *dev = &dev_priv->drm;
> -	struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv, PIPE_A);
> -	struct intel_crtc_state *pipe_config;
> -	struct drm_atomic_state *state;
> -	int ret = 0;
> -
> -	drm_modeset_lock_all(dev);
> -	state = drm_atomic_state_alloc(dev);
> -	if (!state) {
> -		ret = -ENOMEM;
> -		goto out;
> -	}
> -
> -	state->acquire_ctx = drm_modeset_legacy_acquire_ctx(&crtc->base);
> -	pipe_config = intel_atomic_get_crtc_state(state, crtc);
> -	if (IS_ERR(pipe_config)) {
> -		ret = PTR_ERR(pipe_config);
> -		goto out;
> -	}
> -
> -	pipe_config->pch_pfit.force_thru = enable;
> -	if (pipe_config->cpu_transcoder == TRANSCODER_EDP &&
> -	    pipe_config->pch_pfit.enabled != enable)
> -		pipe_config->base.connectors_changed = true;
> -
> -	ret = drm_atomic_commit(state);
> -out:
> -	WARN(ret, "Toggling workaround to %i returns %i\n", enable, ret);
> -	drm_modeset_unlock_all(dev);
> -	drm_atomic_state_put(state);
> -}
> -
> -static int ivb_pipe_crc_ctl_reg(struct drm_i915_private *dev_priv,
> -				enum pipe pipe,
> -				enum intel_pipe_crc_source *source,
> -				uint32_t *val)
> -{
> -	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
> -		*source = INTEL_PIPE_CRC_SOURCE_PF;
> -
> -	switch (*source) {
> -	case INTEL_PIPE_CRC_SOURCE_PLANE1:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PRIMARY_IVB;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_PLANE2:
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_SPRITE_IVB;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_PF:
> -		if (IS_HASWELL(dev_priv) && pipe == PIPE_A)
> -			hsw_trans_edp_pipe_A_crc_wa(dev_priv, true);
> -
> -		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PF_IVB;
> -		break;
> -	case INTEL_PIPE_CRC_SOURCE_NONE:
> -		*val = 0;
> -		break;
> -	default:
> -		return -EINVAL;
> -	}
> -
> -	return 0;
> -}
> -
> -static int pipe_crc_set_source(struct drm_i915_private *dev_priv,
> -			       enum pipe pipe,
> -			       enum intel_pipe_crc_source source)
> -{
> -	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe];
> -	struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv, pipe);
> -	enum intel_display_power_domain power_domain;
> -	u32 val = 0; /* shut up gcc */
> -	int ret;
> -
> -	if (pipe_crc->source == source)
> -		return 0;
> -
> -	/* forbid changing the source without going back to 'none' */
> -	if (pipe_crc->source && source)
> -		return -EINVAL;
> -
> -	power_domain = POWER_DOMAIN_PIPE(pipe);
> -	if (!intel_display_power_get_if_enabled(dev_priv, power_domain)) {
> -		DRM_DEBUG_KMS("Trying to capture CRC while pipe is off\n");
> -		return -EIO;
> -	}
> -
> -	if (IS_GEN2(dev_priv))
> -		ret = i8xx_pipe_crc_ctl_reg(&source, &val);
> -	else if (INTEL_GEN(dev_priv) < 5)
> -		ret = i9xx_pipe_crc_ctl_reg(dev_priv, pipe, &source, &val);
> -	else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
> -		ret = vlv_pipe_crc_ctl_reg(dev_priv, pipe, &source, &val);
> -	else if (IS_GEN5(dev_priv) || IS_GEN6(dev_priv))
> -		ret = ilk_pipe_crc_ctl_reg(&source, &val);
> -	else
> -		ret = ivb_pipe_crc_ctl_reg(dev_priv, pipe, &source, &val);
> -
> -	if (ret != 0)
> -		goto out;
> -
> -	/* none -> real source transition */
> -	if (source) {
> -		struct intel_pipe_crc_entry *entries;
> -
> -		DRM_DEBUG_DRIVER("collecting CRCs for pipe %c, %s\n",
> -				 pipe_name(pipe), pipe_crc_source_name(source));
> -
> -		entries = kcalloc(INTEL_PIPE_CRC_ENTRIES_NR,
> -				  sizeof(pipe_crc->entries[0]),
> -				  GFP_KERNEL);
> -		if (!entries) {
> -			ret = -ENOMEM;
> -			goto out;
> -		}
> -
> -		/*
> -		 * When IPS gets enabled, the pipe CRC changes. Since IPS gets
> -		 * enabled and disabled dynamically based on package C states,
> -		 * user space can't make reliable use of the CRCs, so let's just
> -		 * completely disable it.
> -		 */
> -		hsw_disable_ips(crtc);
> -
> -		spin_lock_irq(&pipe_crc->lock);
> -		kfree(pipe_crc->entries);
> -		pipe_crc->entries = entries;
> -		pipe_crc->head = 0;
> -		pipe_crc->tail = 0;
> -		spin_unlock_irq(&pipe_crc->lock);
> -	}
> -
> -	pipe_crc->source = source;
> -
> -	I915_WRITE(PIPE_CRC_CTL(pipe), val);
> -	POSTING_READ(PIPE_CRC_CTL(pipe));
> -
> -	/* real source -> none transition */
> -	if (source == INTEL_PIPE_CRC_SOURCE_NONE) {
> -		struct intel_pipe_crc_entry *entries;
> -		struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv,
> -								  pipe);
> -
> -		DRM_DEBUG_DRIVER("stopping CRCs for pipe %c\n",
> -				 pipe_name(pipe));
> -
> -		drm_modeset_lock(&crtc->base.mutex, NULL);
> -		if (crtc->base.state->active)
> -			intel_wait_for_vblank(dev_priv, pipe);
> -		drm_modeset_unlock(&crtc->base.mutex);
> -
> -		spin_lock_irq(&pipe_crc->lock);
> -		entries = pipe_crc->entries;
> -		pipe_crc->entries = NULL;
> -		pipe_crc->head = 0;
> -		pipe_crc->tail = 0;
> -		spin_unlock_irq(&pipe_crc->lock);
> -
> -		kfree(entries);
> -
> -		if (IS_G4X(dev_priv))
> -			g4x_undo_pipe_scramble_reset(dev_priv, pipe);
> -		else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
> -			vlv_undo_pipe_scramble_reset(dev_priv, pipe);
> -		else if (IS_HASWELL(dev_priv) && pipe == PIPE_A)
> -			hsw_trans_edp_pipe_A_crc_wa(dev_priv, false);
> -
> -		hsw_enable_ips(crtc);
> -	}
> -
> -	ret = 0;
> -
> -out:
> -	intel_display_power_put(dev_priv, power_domain);
> -
> -	return ret;
> -}
> -
> -/*
> - * Parse pipe CRC command strings:
> - *   command: wsp* object wsp+ name wsp+ source wsp*
> - *   object: 'pipe'
> - *   name: (A | B | C)
> - *   source: (none | plane1 | plane2 | pf)
> - *   wsp: (#0x20 | #0x9 | #0xA)+
> - *
> - * eg.:
> - *  "pipe A plane1"  ->  Start CRC computations on plane1 of pipe A
> - *  "pipe A none"    ->  Stop CRC
> - */
> -static int display_crc_ctl_tokenize(char *buf, char *words[], int max_words)
> -{
> -	int n_words = 0;
> -
> -	while (*buf) {
> -		char *end;
> -
> -		/* skip leading white space */
> -		buf = skip_spaces(buf);
> -		if (!*buf)
> -			break;	/* end of buffer */
> -
> -		/* find end of word */
> -		for (end = buf; *end && !isspace(*end); end++)
> -			;
> -
> -		if (n_words == max_words) {
> -			DRM_DEBUG_DRIVER("too many words, allowed <= %d\n",
> -					 max_words);
> -			return -EINVAL;	/* ran out of words[] before bytes */
> -		}
> -
> -		if (*end)
> -			*end++ = '\0';
> -		words[n_words++] = buf;
> -		buf = end;
> -	}
> -
> -	return n_words;
> -}
> -
> -enum intel_pipe_crc_object {
> -	PIPE_CRC_OBJECT_PIPE,
> -};
> -
> -static const char * const pipe_crc_objects[] = {
> -	"pipe",
> -};
> -
> -static int
> -display_crc_ctl_parse_object(const char *buf, enum intel_pipe_crc_object *o)
> -{
> -	int i;
> -
> -	for (i = 0; i < ARRAY_SIZE(pipe_crc_objects); i++)
> -		if (!strcmp(buf, pipe_crc_objects[i])) {
> -			*o = i;
> -			return 0;
> -		    }
> -
> -	return -EINVAL;
> -}
> -
> -static int display_crc_ctl_parse_pipe(const char *buf, enum pipe *pipe)
> -{
> -	const char name = buf[0];
> -
> -	if (name < 'A' || name >= pipe_name(I915_MAX_PIPES))
> -		return -EINVAL;
> -
> -	*pipe = name - 'A';
> -
> -	return 0;
> -}
> -
> -static int
> -display_crc_ctl_parse_source(const char *buf, enum intel_pipe_crc_source *s)
> -{
> -	int i;
> -
> -	for (i = 0; i < ARRAY_SIZE(pipe_crc_sources); i++)
> -		if (!strcmp(buf, pipe_crc_sources[i])) {
> -			*s = i;
> -			return 0;
> -		    }
> -
> -	return -EINVAL;
> -}
> -
> -static int display_crc_ctl_parse(struct drm_i915_private *dev_priv,
> -				 char *buf, size_t len)
> -{
> -#define N_WORDS 3
> -	int n_words;
> -	char *words[N_WORDS];
> -	enum pipe pipe;
> -	enum intel_pipe_crc_object object;
> -	enum intel_pipe_crc_source source;
> -
> -	n_words = display_crc_ctl_tokenize(buf, words, N_WORDS);
> -	if (n_words != N_WORDS) {
> -		DRM_DEBUG_DRIVER("tokenize failed, a command is %d words\n",
> -				 N_WORDS);
> -		return -EINVAL;
> -	}
> -
> -	if (display_crc_ctl_parse_object(words[0], &object) < 0) {
> -		DRM_DEBUG_DRIVER("unknown object %s\n", words[0]);
> -		return -EINVAL;
> -	}
> -
> -	if (display_crc_ctl_parse_pipe(words[1], &pipe) < 0) {
> -		DRM_DEBUG_DRIVER("unknown pipe %s\n", words[1]);
> -		return -EINVAL;
> -	}
> -
> -	if (display_crc_ctl_parse_source(words[2], &source) < 0) {
> -		DRM_DEBUG_DRIVER("unknown source %s\n", words[2]);
> -		return -EINVAL;
> -	}
> -
> -	return pipe_crc_set_source(dev_priv, pipe, source);
> -}
> -
> -static ssize_t display_crc_ctl_write(struct file *file, const char __user *ubuf,
> -				     size_t len, loff_t *offp)
> -{
> -	struct seq_file *m = file->private_data;
> -	struct drm_i915_private *dev_priv = m->private;
> -	char *tmpbuf;
> -	int ret;
> -
> -	if (len == 0)
> -		return 0;
> -
> -	if (len > PAGE_SIZE - 1) {
> -		DRM_DEBUG_DRIVER("expected <%lu bytes into pipe crc control\n",
> -				 PAGE_SIZE);
> -		return -E2BIG;
> -	}
> -
> -	tmpbuf = kmalloc(len + 1, GFP_KERNEL);
> -	if (!tmpbuf)
> -		return -ENOMEM;
> -
> -	if (copy_from_user(tmpbuf, ubuf, len)) {
> -		ret = -EFAULT;
> -		goto out;
> -	}
> -	tmpbuf[len] = '\0';
> -
> -	ret = display_crc_ctl_parse(dev_priv, tmpbuf, len);
> -
> -out:
> -	kfree(tmpbuf);
> -	if (ret < 0)
> -		return ret;
> -
> -	*offp += len;
> -	return len;
> -}
> -
> -static const struct file_operations i915_display_crc_ctl_fops = {
> -	.owner = THIS_MODULE,
> -	.open = display_crc_ctl_open,
> -	.read = seq_read,
> -	.llseek = seq_lseek,
> -	.release = single_release,
> -	.write = display_crc_ctl_write
> -};
> -
>  static ssize_t i915_displayport_test_active_write(struct file *file,
>  						  const char __user *ubuf,
>  						  size_t len, loff_t *offp)
> @@ -5469,19 +4615,6 @@ static const struct i915_debugfs_files {
>  	{"i915_guc_log_control", &i915_guc_log_control_fops}
>  };
>  
> -void intel_display_crc_init(struct drm_i915_private *dev_priv)
> -{
> -	enum pipe pipe;
> -
> -	for_each_pipe(dev_priv, pipe) {
> -		struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe];
> -
> -		pipe_crc->opened = false;
> -		spin_lock_init(&pipe_crc->lock);
> -		init_waitqueue_head(&pipe_crc->wq);
> -	}
> -}
> -
>  int i915_debugfs_register(struct drm_i915_private *dev_priv)
>  {
>  	struct drm_minor *minor = dev_priv->drm.primary;
> @@ -5491,11 +4624,9 @@ int i915_debugfs_register(struct drm_i915_private *dev_priv)
>  	if (ret)
>  		return ret;
>  
> -	for (i = 0; i < ARRAY_SIZE(i915_pipe_crc_data); i++) {
> -		ret = i915_pipe_crc_create(minor->debugfs_root, minor, i);
> -		if (ret)
> -			return ret;
> -	}
> +	ret = intel_pipe_crc_create(minor);
> +	if (ret)
> +		return ret;
>  
>  	for (i = 0; i < ARRAY_SIZE(i915_debugfs_files); i++) {
>  		ret = i915_debugfs_create(minor->debugfs_root, minor,
> @@ -5521,12 +4652,7 @@ void i915_debugfs_unregister(struct drm_i915_private *dev_priv)
>  	drm_debugfs_remove_files((struct drm_info_list *)&i915_forcewake_fops,
>  				 1, minor);
>  
> -	for (i = 0; i < ARRAY_SIZE(i915_pipe_crc_data); i++) {
> -		struct drm_info_list *info_list =
> -			(struct drm_info_list *)&i915_pipe_crc_data[i];
> -
> -		drm_debugfs_remove_files(info_list, 1, minor);
> -	}
> +	intel_pipe_crc_cleanup(minor);
>  
>  	for (i = 0; i < ARRAY_SIZE(i915_debugfs_files); i++) {
>  		struct drm_info_list *info_list =
> diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
> index 8f4ddca0f521..223d44c4aa93 100644
> --- a/drivers/gpu/drm/i915/intel_drv.h
> +++ b/drivers/gpu/drm/i915/intel_drv.h
> @@ -1855,4 +1855,9 @@ void intel_color_load_luts(struct drm_crtc_state *crtc_state);
>  bool lspcon_init(struct intel_digital_port *intel_dig_port);
>  void lspcon_resume(struct intel_lspcon *lspcon);
>  void lspcon_wait_pcon_mode(struct intel_lspcon *lspcon);
> +
> +/* intel_pipe_crc.c */
> +int intel_pipe_crc_create(struct drm_minor *minor);
> +void intel_pipe_crc_cleanup(struct drm_minor *minor);
> +extern const struct file_operations i915_display_crc_ctl_fops;
>  #endif /* __INTEL_DRV_H__ */
> diff --git a/drivers/gpu/drm/i915/intel_pipe_crc.c b/drivers/gpu/drm/i915/intel_pipe_crc.c
> new file mode 100644
> index 000000000000..ef0c0e195164
> --- /dev/null
> +++ b/drivers/gpu/drm/i915/intel_pipe_crc.c
> @@ -0,0 +1,939 @@
> +/*
> + * Copyright © 2013 Intel Corporation
> + *
> + * 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.
> + *
> + * Author: Damien Lespiau <damien.lespiau@xxxxxxxxx>
> + *
> + */
> +
> +#include <linux/seq_file.h>
> +#include <linux/circ_buf.h>
> +#include <linux/ctype.h>
> +#include <linux/debugfs.h>
> +#include "intel_drv.h"
> +
> +struct pipe_crc_info {
> +	const char *name;
> +	struct drm_i915_private *dev_priv;
> +	enum pipe pipe;
> +};
> +
> +/* As the drm_debugfs_init() routines are called before dev->dev_private is
> + * allocated we need to hook into the minor for release.
> + */
> +static int drm_add_fake_info_node(struct drm_minor *minor,
> +				  struct dentry *ent, const void *key)
> +{
> +	struct drm_info_node *node;
> +
> +	node = kmalloc(sizeof(*node), GFP_KERNEL);
> +	if (node == NULL) {
> +		debugfs_remove(ent);
> +		return -ENOMEM;
> +	}
> +
> +	node->minor = minor;
> +	node->dent = ent;
> +	node->info_ent = (void *) key;
> +
> +	mutex_lock(&minor->debugfs_lock);
> +	list_add(&node->list, &minor->debugfs_list);
> +	mutex_unlock(&minor->debugfs_lock);
> +
> +	return 0;
> +}
> +
> +static int i915_pipe_crc_open(struct inode *inode, struct file *filep)
> +{
> +	struct pipe_crc_info *info = inode->i_private;
> +	struct drm_i915_private *dev_priv = info->dev_priv;
> +	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
> +
> +	if (info->pipe >= INTEL_INFO(dev_priv)->num_pipes)
> +		return -ENODEV;
> +
> +	spin_lock_irq(&pipe_crc->lock);
> +
> +	if (pipe_crc->opened) {
> +		spin_unlock_irq(&pipe_crc->lock);
> +		return -EBUSY; /* already open */
> +	}
> +
> +	pipe_crc->opened = true;
> +	filep->private_data = inode->i_private;
> +
> +	spin_unlock_irq(&pipe_crc->lock);
> +
> +	return 0;
> +}
> +
> +static int i915_pipe_crc_release(struct inode *inode, struct file *filep)
> +{
> +	struct pipe_crc_info *info = inode->i_private;
> +	struct drm_i915_private *dev_priv = info->dev_priv;
> +	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
> +
> +	spin_lock_irq(&pipe_crc->lock);
> +	pipe_crc->opened = false;
> +	spin_unlock_irq(&pipe_crc->lock);
> +
> +	return 0;
> +}
> +
> +/* (6 fields, 8 chars each, space separated (5) + '\n') */
> +#define PIPE_CRC_LINE_LEN	(6 * 8 + 5 + 1)
> +/* account for \'0' */
> +#define PIPE_CRC_BUFFER_LEN	(PIPE_CRC_LINE_LEN + 1)
> +
> +static int pipe_crc_data_count(struct intel_pipe_crc *pipe_crc)
> +{
> +	assert_spin_locked(&pipe_crc->lock);
> +	return CIRC_CNT(pipe_crc->head, pipe_crc->tail,
> +			INTEL_PIPE_CRC_ENTRIES_NR);
> +}
> +
> +static ssize_t
> +i915_pipe_crc_read(struct file *filep, char __user *user_buf, size_t count,
> +		   loff_t *pos)
> +{
> +	struct pipe_crc_info *info = filep->private_data;
> +	struct drm_i915_private *dev_priv = info->dev_priv;
> +	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[info->pipe];
> +	char buf[PIPE_CRC_BUFFER_LEN];
> +	int n_entries;
> +	ssize_t bytes_read;
> +
> +	/*
> +	 * Don't allow user space to provide buffers not big enough to hold
> +	 * a line of data.
> +	 */
> +	if (count < PIPE_CRC_LINE_LEN)
> +		return -EINVAL;
> +
> +	if (pipe_crc->source == INTEL_PIPE_CRC_SOURCE_NONE)
> +		return 0;
> +
> +	/* nothing to read */
> +	spin_lock_irq(&pipe_crc->lock);
> +	while (pipe_crc_data_count(pipe_crc) == 0) {
> +		int ret;
> +
> +		if (filep->f_flags & O_NONBLOCK) {
> +			spin_unlock_irq(&pipe_crc->lock);
> +			return -EAGAIN;
> +		}
> +
> +		ret = wait_event_interruptible_lock_irq(pipe_crc->wq,
> +				pipe_crc_data_count(pipe_crc), pipe_crc->lock);
> +		if (ret) {
> +			spin_unlock_irq(&pipe_crc->lock);
> +			return ret;
> +		}
> +	}
> +
> +	/* We now have one or more entries to read */
> +	n_entries = count / PIPE_CRC_LINE_LEN;
> +
> +	bytes_read = 0;
> +	while (n_entries > 0) {
> +		struct intel_pipe_crc_entry *entry =
> +			&pipe_crc->entries[pipe_crc->tail];
> +
> +		if (CIRC_CNT(pipe_crc->head, pipe_crc->tail,
> +			     INTEL_PIPE_CRC_ENTRIES_NR) < 1)
> +			break;
> +
> +		BUILD_BUG_ON_NOT_POWER_OF_2(INTEL_PIPE_CRC_ENTRIES_NR);
> +		pipe_crc->tail = (pipe_crc->tail + 1) &
> +				 (INTEL_PIPE_CRC_ENTRIES_NR - 1);
> +
> +		bytes_read += snprintf(buf, PIPE_CRC_BUFFER_LEN,
> +				       "%8u %8x %8x %8x %8x %8x\n",
> +				       entry->frame, entry->crc[0],
> +				       entry->crc[1], entry->crc[2],
> +				       entry->crc[3], entry->crc[4]);
> +
> +		spin_unlock_irq(&pipe_crc->lock);
> +
> +		if (copy_to_user(user_buf, buf, PIPE_CRC_LINE_LEN))
> +			return -EFAULT;
> +
> +		user_buf += PIPE_CRC_LINE_LEN;
> +		n_entries--;
> +
> +		spin_lock_irq(&pipe_crc->lock);
> +	}
> +
> +	spin_unlock_irq(&pipe_crc->lock);
> +
> +	return bytes_read;
> +}
> +
> +static const struct file_operations i915_pipe_crc_fops = {
> +	.owner = THIS_MODULE,
> +	.open = i915_pipe_crc_open,
> +	.read = i915_pipe_crc_read,
> +	.release = i915_pipe_crc_release,
> +};
> +
> +static struct pipe_crc_info i915_pipe_crc_data[I915_MAX_PIPES] = {
> +	{
> +		.name = "i915_pipe_A_crc",
> +		.pipe = PIPE_A,
> +	},
> +	{
> +		.name = "i915_pipe_B_crc",
> +		.pipe = PIPE_B,
> +	},
> +	{
> +		.name = "i915_pipe_C_crc",
> +		.pipe = PIPE_C,
> +	},
> +};
> +
> +static int i915_pipe_crc_create(struct dentry *root, struct drm_minor *minor,
> +				enum pipe pipe)
> +{
> +	struct drm_i915_private *dev_priv = to_i915(minor->dev);
> +	struct dentry *ent;
> +	struct pipe_crc_info *info = &i915_pipe_crc_data[pipe];
> +
> +	info->dev_priv = dev_priv;
> +	ent = debugfs_create_file(info->name, S_IRUGO, root, info,
> +				  &i915_pipe_crc_fops);
> +	if (!ent)
> +		return -ENOMEM;
> +
> +	return drm_add_fake_info_node(minor, ent, info);
> +}
> +
> +static const char * const pipe_crc_sources[] = {
> +	"none",
> +	"plane1",
> +	"plane2",
> +	"pf",
> +	"pipe",
> +	"TV",
> +	"DP-B",
> +	"DP-C",
> +	"DP-D",
> +	"auto",
> +};
> +
> +static const char *pipe_crc_source_name(enum intel_pipe_crc_source source)
> +{
> +	BUILD_BUG_ON(ARRAY_SIZE(pipe_crc_sources) != INTEL_PIPE_CRC_SOURCE_MAX);
> +	return pipe_crc_sources[source];
> +}
> +
> +static int display_crc_ctl_show(struct seq_file *m, void *data)
> +{
> +	struct drm_i915_private *dev_priv = m->private;
> +	int i;
> +
> +	for (i = 0; i < I915_MAX_PIPES; i++)
> +		seq_printf(m, "%c %s\n", pipe_name(i),
> +			   pipe_crc_source_name(dev_priv->pipe_crc[i].source));
> +
> +	return 0;
> +}
> +
> +static int display_crc_ctl_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, display_crc_ctl_show, inode->i_private);
> +}
> +
> +static int i8xx_pipe_crc_ctl_reg(enum intel_pipe_crc_source *source,
> +				 uint32_t *val)
> +{
> +	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
> +		*source = INTEL_PIPE_CRC_SOURCE_PIPE;
> +
> +	switch (*source) {
> +	case INTEL_PIPE_CRC_SOURCE_PIPE:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_INCLUDE_BORDER_I8XX;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_NONE:
> +		*val = 0;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +static int i9xx_pipe_crc_auto_source(struct drm_i915_private *dev_priv,
> +				     enum pipe pipe,
> +				     enum intel_pipe_crc_source *source)
> +{
> +	struct drm_device *dev = &dev_priv->drm;
> +	struct intel_encoder *encoder;
> +	struct intel_crtc *crtc;
> +	struct intel_digital_port *dig_port;
> +	int ret = 0;
> +
> +	*source = INTEL_PIPE_CRC_SOURCE_PIPE;
> +
> +	drm_modeset_lock_all(dev);
> +	for_each_intel_encoder(dev, encoder) {
> +		if (!encoder->base.crtc)
> +			continue;
> +
> +		crtc = to_intel_crtc(encoder->base.crtc);
> +
> +		if (crtc->pipe != pipe)
> +			continue;
> +
> +		switch (encoder->type) {
> +		case INTEL_OUTPUT_TVOUT:
> +			*source = INTEL_PIPE_CRC_SOURCE_TV;
> +			break;
> +		case INTEL_OUTPUT_DP:
> +		case INTEL_OUTPUT_EDP:
> +			dig_port = enc_to_dig_port(&encoder->base);
> +			switch (dig_port->port) {
> +			case PORT_B:
> +				*source = INTEL_PIPE_CRC_SOURCE_DP_B;
> +				break;
> +			case PORT_C:
> +				*source = INTEL_PIPE_CRC_SOURCE_DP_C;
> +				break;
> +			case PORT_D:
> +				*source = INTEL_PIPE_CRC_SOURCE_DP_D;
> +				break;
> +			default:
> +				WARN(1, "nonexisting DP port %c\n",
> +				     port_name(dig_port->port));
> +				break;
> +			}
> +			break;
> +		default:
> +			break;
> +		}
> +	}
> +	drm_modeset_unlock_all(dev);
> +
> +	return ret;
> +}
> +
> +static int vlv_pipe_crc_ctl_reg(struct drm_i915_private *dev_priv,
> +				enum pipe pipe,
> +				enum intel_pipe_crc_source *source,
> +				uint32_t *val)
> +{
> +	bool need_stable_symbols = false;
> +
> +	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO) {
> +		int ret = i9xx_pipe_crc_auto_source(dev_priv, pipe, source);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	switch (*source) {
> +	case INTEL_PIPE_CRC_SOURCE_PIPE:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_VLV;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_DP_B:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_B_VLV;
> +		need_stable_symbols = true;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_DP_C:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_C_VLV;
> +		need_stable_symbols = true;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_DP_D:
> +		if (!IS_CHERRYVIEW(dev_priv))
> +			return -EINVAL;
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_D_VLV;
> +		need_stable_symbols = true;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_NONE:
> +		*val = 0;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	/*
> +	 * When the pipe CRC tap point is after the transcoders we need
> +	 * to tweak symbol-level features to produce a deterministic series of
> +	 * symbols for a given frame. We need to reset those features only once
> +	 * a frame (instead of every nth symbol):
> +	 *   - DC-balance: used to ensure a better clock recovery from the data
> +	 *     link (SDVO)
> +	 *   - DisplayPort scrambling: used for EMI reduction
> +	 */
> +	if (need_stable_symbols) {
> +		uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> +
> +		tmp |= DC_BALANCE_RESET_VLV;
> +		switch (pipe) {
> +		case PIPE_A:
> +			tmp |= PIPE_A_SCRAMBLE_RESET;
> +			break;
> +		case PIPE_B:
> +			tmp |= PIPE_B_SCRAMBLE_RESET;
> +			break;
> +		case PIPE_C:
> +			tmp |= PIPE_C_SCRAMBLE_RESET;
> +			break;
> +		default:
> +			return -EINVAL;
> +		}
> +		I915_WRITE(PORT_DFT2_G4X, tmp);
> +	}
> +
> +	return 0;
> +}
> +
> +static int i9xx_pipe_crc_ctl_reg(struct drm_i915_private *dev_priv,
> +				 enum pipe pipe,
> +				 enum intel_pipe_crc_source *source,
> +				 uint32_t *val)
> +{
> +	bool need_stable_symbols = false;
> +
> +	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO) {
> +		int ret = i9xx_pipe_crc_auto_source(dev_priv, pipe, source);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	switch (*source) {
> +	case INTEL_PIPE_CRC_SOURCE_PIPE:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_I9XX;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_TV:
> +		if (!SUPPORTS_TV(dev_priv))
> +			return -EINVAL;
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_TV_PRE;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_DP_B:
> +		if (!IS_G4X(dev_priv))
> +			return -EINVAL;
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_B_G4X;
> +		need_stable_symbols = true;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_DP_C:
> +		if (!IS_G4X(dev_priv))
> +			return -EINVAL;
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_C_G4X;
> +		need_stable_symbols = true;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_DP_D:
> +		if (!IS_G4X(dev_priv))
> +			return -EINVAL;
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_DP_D_G4X;
> +		need_stable_symbols = true;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_NONE:
> +		*val = 0;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	/*
> +	 * When the pipe CRC tap point is after the transcoders we need
> +	 * to tweak symbol-level features to produce a deterministic series of
> +	 * symbols for a given frame. We need to reset those features only once
> +	 * a frame (instead of every nth symbol):
> +	 *   - DC-balance: used to ensure a better clock recovery from the data
> +	 *     link (SDVO)
> +	 *   - DisplayPort scrambling: used for EMI reduction
> +	 */
> +	if (need_stable_symbols) {
> +		uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> +
> +		WARN_ON(!IS_G4X(dev_priv));
> +
> +		I915_WRITE(PORT_DFT_I9XX,
> +			   I915_READ(PORT_DFT_I9XX) | DC_BALANCE_RESET);
> +
> +		if (pipe == PIPE_A)
> +			tmp |= PIPE_A_SCRAMBLE_RESET;
> +		else
> +			tmp |= PIPE_B_SCRAMBLE_RESET;
> +
> +		I915_WRITE(PORT_DFT2_G4X, tmp);
> +	}
> +
> +	return 0;
> +}
> +
> +static void vlv_undo_pipe_scramble_reset(struct drm_i915_private *dev_priv,
> +					 enum pipe pipe)
> +{
> +	uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> +
> +	switch (pipe) {
> +	case PIPE_A:
> +		tmp &= ~PIPE_A_SCRAMBLE_RESET;
> +		break;
> +	case PIPE_B:
> +		tmp &= ~PIPE_B_SCRAMBLE_RESET;
> +		break;
> +	case PIPE_C:
> +		tmp &= ~PIPE_C_SCRAMBLE_RESET;
> +		break;
> +	default:
> +		return;
> +	}
> +	if (!(tmp & PIPE_SCRAMBLE_RESET_MASK))
> +		tmp &= ~DC_BALANCE_RESET_VLV;
> +	I915_WRITE(PORT_DFT2_G4X, tmp);
> +
> +}
> +
> +static void g4x_undo_pipe_scramble_reset(struct drm_i915_private *dev_priv,
> +					 enum pipe pipe)
> +{
> +	uint32_t tmp = I915_READ(PORT_DFT2_G4X);
> +
> +	if (pipe == PIPE_A)
> +		tmp &= ~PIPE_A_SCRAMBLE_RESET;
> +	else
> +		tmp &= ~PIPE_B_SCRAMBLE_RESET;
> +	I915_WRITE(PORT_DFT2_G4X, tmp);
> +
> +	if (!(tmp & PIPE_SCRAMBLE_RESET_MASK)) {
> +		I915_WRITE(PORT_DFT_I9XX,
> +			   I915_READ(PORT_DFT_I9XX) & ~DC_BALANCE_RESET);
> +	}
> +}
> +
> +static int ilk_pipe_crc_ctl_reg(enum intel_pipe_crc_source *source,
> +				uint32_t *val)
> +{
> +	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
> +		*source = INTEL_PIPE_CRC_SOURCE_PIPE;
> +
> +	switch (*source) {
> +	case INTEL_PIPE_CRC_SOURCE_PLANE1:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PRIMARY_ILK;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_PLANE2:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_SPRITE_ILK;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_PIPE:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PIPE_ILK;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_NONE:
> +		*val = 0;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +static void hsw_trans_edp_pipe_A_crc_wa(struct drm_i915_private *dev_priv,
> +					bool enable)
> +{
> +	struct drm_device *dev = &dev_priv->drm;
> +	struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv, PIPE_A);
> +	struct intel_crtc_state *pipe_config;
> +	struct drm_atomic_state *state;
> +	int ret = 0;
> +
> +	drm_modeset_lock_all(dev);
> +	state = drm_atomic_state_alloc(dev);
> +	if (!state) {
> +		ret = -ENOMEM;
> +		goto out;
> +	}
> +
> +	state->acquire_ctx = drm_modeset_legacy_acquire_ctx(&crtc->base);
> +	pipe_config = intel_atomic_get_crtc_state(state, crtc);
> +	if (IS_ERR(pipe_config)) {
> +		ret = PTR_ERR(pipe_config);
> +		goto out;
> +	}
> +
> +	pipe_config->pch_pfit.force_thru = enable;
> +	if (pipe_config->cpu_transcoder == TRANSCODER_EDP &&
> +	    pipe_config->pch_pfit.enabled != enable)
> +		pipe_config->base.connectors_changed = true;
> +
> +	ret = drm_atomic_commit(state);
> +out:
> +	WARN(ret, "Toggling workaround to %i returns %i\n", enable, ret);
> +	drm_modeset_unlock_all(dev);
> +	drm_atomic_state_put(state);
> +}
> +
> +static int ivb_pipe_crc_ctl_reg(struct drm_i915_private *dev_priv,
> +				enum pipe pipe,
> +				enum intel_pipe_crc_source *source,
> +				uint32_t *val)
> +{
> +	if (*source == INTEL_PIPE_CRC_SOURCE_AUTO)
> +		*source = INTEL_PIPE_CRC_SOURCE_PF;
> +
> +	switch (*source) {
> +	case INTEL_PIPE_CRC_SOURCE_PLANE1:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PRIMARY_IVB;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_PLANE2:
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_SPRITE_IVB;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_PF:
> +		if (IS_HASWELL(dev_priv) && pipe == PIPE_A)
> +			hsw_trans_edp_pipe_A_crc_wa(dev_priv, true);
> +
> +		*val = PIPE_CRC_ENABLE | PIPE_CRC_SOURCE_PF_IVB;
> +		break;
> +	case INTEL_PIPE_CRC_SOURCE_NONE:
> +		*val = 0;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +static int pipe_crc_set_source(struct drm_i915_private *dev_priv,
> +			       enum pipe pipe,
> +			       enum intel_pipe_crc_source source)
> +{
> +	struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe];
> +	struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv, pipe);
> +	enum intel_display_power_domain power_domain;
> +	u32 val = 0; /* shut up gcc */
> +	int ret;
> +
> +	if (pipe_crc->source == source)
> +		return 0;
> +
> +	/* forbid changing the source without going back to 'none' */
> +	if (pipe_crc->source && source)
> +		return -EINVAL;
> +
> +	power_domain = POWER_DOMAIN_PIPE(pipe);
> +	if (!intel_display_power_get_if_enabled(dev_priv, power_domain)) {
> +		DRM_DEBUG_KMS("Trying to capture CRC while pipe is off\n");
> +		return -EIO;
> +	}
> +
> +	if (IS_GEN2(dev_priv))
> +		ret = i8xx_pipe_crc_ctl_reg(&source, &val);
> +	else if (INTEL_GEN(dev_priv) < 5)
> +		ret = i9xx_pipe_crc_ctl_reg(dev_priv, pipe, &source, &val);
> +	else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
> +		ret = vlv_pipe_crc_ctl_reg(dev_priv, pipe, &source, &val);
> +	else if (IS_GEN5(dev_priv) || IS_GEN6(dev_priv))
> +		ret = ilk_pipe_crc_ctl_reg(&source, &val);
> +	else
> +		ret = ivb_pipe_crc_ctl_reg(dev_priv, pipe, &source, &val);
> +
> +	if (ret != 0)
> +		goto out;
> +
> +	/* none -> real source transition */
> +	if (source) {
> +		struct intel_pipe_crc_entry *entries;
> +
> +		DRM_DEBUG_DRIVER("collecting CRCs for pipe %c, %s\n",
> +				 pipe_name(pipe), pipe_crc_source_name(source));
> +
> +		entries = kcalloc(INTEL_PIPE_CRC_ENTRIES_NR,
> +				  sizeof(pipe_crc->entries[0]),
> +				  GFP_KERNEL);
> +		if (!entries) {
> +			ret = -ENOMEM;
> +			goto out;
> +		}
> +
> +		/*
> +		 * When IPS gets enabled, the pipe CRC changes. Since IPS gets
> +		 * enabled and disabled dynamically based on package C states,
> +		 * user space can't make reliable use of the CRCs, so let's just
> +		 * completely disable it.
> +		 */
> +		hsw_disable_ips(crtc);
> +
> +		spin_lock_irq(&pipe_crc->lock);
> +		kfree(pipe_crc->entries);
> +		pipe_crc->entries = entries;
> +		pipe_crc->head = 0;
> +		pipe_crc->tail = 0;
> +		spin_unlock_irq(&pipe_crc->lock);
> +	}
> +
> +	pipe_crc->source = source;
> +
> +	I915_WRITE(PIPE_CRC_CTL(pipe), val);
> +	POSTING_READ(PIPE_CRC_CTL(pipe));
> +
> +	/* real source -> none transition */
> +	if (source == INTEL_PIPE_CRC_SOURCE_NONE) {
> +		struct intel_pipe_crc_entry *entries;
> +		struct intel_crtc *crtc = intel_get_crtc_for_pipe(dev_priv,
> +								  pipe);
> +
> +		DRM_DEBUG_DRIVER("stopping CRCs for pipe %c\n",
> +				 pipe_name(pipe));
> +
> +		drm_modeset_lock(&crtc->base.mutex, NULL);
> +		if (crtc->base.state->active)
> +			intel_wait_for_vblank(dev_priv, pipe);
> +		drm_modeset_unlock(&crtc->base.mutex);
> +
> +		spin_lock_irq(&pipe_crc->lock);
> +		entries = pipe_crc->entries;
> +		pipe_crc->entries = NULL;
> +		pipe_crc->head = 0;
> +		pipe_crc->tail = 0;
> +		spin_unlock_irq(&pipe_crc->lock);
> +
> +		kfree(entries);
> +
> +		if (IS_G4X(dev_priv))
> +			g4x_undo_pipe_scramble_reset(dev_priv, pipe);
> +		else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
> +			vlv_undo_pipe_scramble_reset(dev_priv, pipe);
> +		else if (IS_HASWELL(dev_priv) && pipe == PIPE_A)
> +			hsw_trans_edp_pipe_A_crc_wa(dev_priv, false);
> +
> +		hsw_enable_ips(crtc);
> +	}
> +
> +	ret = 0;
> +
> +out:
> +	intel_display_power_put(dev_priv, power_domain);
> +
> +	return ret;
> +}
> +
> +/*
> + * Parse pipe CRC command strings:
> + *   command: wsp* object wsp+ name wsp+ source wsp*
> + *   object: 'pipe'
> + *   name: (A | B | C)
> + *   source: (none | plane1 | plane2 | pf)
> + *   wsp: (#0x20 | #0x9 | #0xA)+
> + *
> + * eg.:
> + *  "pipe A plane1"  ->  Start CRC computations on plane1 of pipe A
> + *  "pipe A none"    ->  Stop CRC
> + */
> +static int display_crc_ctl_tokenize(char *buf, char *words[], int max_words)
> +{
> +	int n_words = 0;
> +
> +	while (*buf) {
> +		char *end;
> +
> +		/* skip leading white space */
> +		buf = skip_spaces(buf);
> +		if (!*buf)
> +			break;	/* end of buffer */
> +
> +		/* find end of word */
> +		for (end = buf; *end && !isspace(*end); end++)
> +			;
> +
> +		if (n_words == max_words) {
> +			DRM_DEBUG_DRIVER("too many words, allowed <= %d\n",
> +					 max_words);
> +			return -EINVAL;	/* ran out of words[] before bytes */
> +		}
> +
> +		if (*end)
> +			*end++ = '\0';
> +		words[n_words++] = buf;
> +		buf = end;
> +	}
> +
> +	return n_words;
> +}
> +
> +enum intel_pipe_crc_object {
> +	PIPE_CRC_OBJECT_PIPE,
> +};
> +
> +static const char * const pipe_crc_objects[] = {
> +	"pipe",
> +};
> +
> +static int
> +display_crc_ctl_parse_object(const char *buf, enum intel_pipe_crc_object *o)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(pipe_crc_objects); i++)
> +		if (!strcmp(buf, pipe_crc_objects[i])) {
> +			*o = i;
> +			return 0;
> +		}
> +
> +	return -EINVAL;
> +}
> +
> +static int display_crc_ctl_parse_pipe(const char *buf, enum pipe *pipe)
> +{
> +	const char name = buf[0];
> +
> +	if (name < 'A' || name >= pipe_name(I915_MAX_PIPES))
> +		return -EINVAL;
> +
> +	*pipe = name - 'A';
> +
> +	return 0;
> +}
> +
> +static int
> +display_crc_ctl_parse_source(const char *buf, enum intel_pipe_crc_source *s)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(pipe_crc_sources); i++)
> +		if (!strcmp(buf, pipe_crc_sources[i])) {
> +			*s = i;
> +			return 0;
> +		}
> +
> +	return -EINVAL;
> +}
> +
> +static int display_crc_ctl_parse(struct drm_i915_private *dev_priv,
> +				 char *buf, size_t len)
> +{
> +#define N_WORDS 3
> +	int n_words;
> +	char *words[N_WORDS];
> +	enum pipe pipe;
> +	enum intel_pipe_crc_object object;
> +	enum intel_pipe_crc_source source;
> +
> +	n_words = display_crc_ctl_tokenize(buf, words, N_WORDS);
> +	if (n_words != N_WORDS) {
> +		DRM_DEBUG_DRIVER("tokenize failed, a command is %d words\n",
> +				 N_WORDS);
> +		return -EINVAL;
> +	}
> +
> +	if (display_crc_ctl_parse_object(words[0], &object) < 0) {
> +		DRM_DEBUG_DRIVER("unknown object %s\n", words[0]);
> +		return -EINVAL;
> +	}
> +
> +	if (display_crc_ctl_parse_pipe(words[1], &pipe) < 0) {
> +		DRM_DEBUG_DRIVER("unknown pipe %s\n", words[1]);
> +		return -EINVAL;
> +	}
> +
> +	if (display_crc_ctl_parse_source(words[2], &source) < 0) {
> +		DRM_DEBUG_DRIVER("unknown source %s\n", words[2]);
> +		return -EINVAL;
> +	}
> +
> +	return pipe_crc_set_source(dev_priv, pipe, source);
> +}
> +
> +static ssize_t display_crc_ctl_write(struct file *file, const char __user *ubuf,
> +				     size_t len, loff_t *offp)
> +{
> +	struct seq_file *m = file->private_data;
> +	struct drm_i915_private *dev_priv = m->private;
> +	char *tmpbuf;
> +	int ret;
> +
> +	if (len == 0)
> +		return 0;
> +
> +	if (len > PAGE_SIZE - 1) {
> +		DRM_DEBUG_DRIVER("expected <%lu bytes into pipe crc control\n",
> +				 PAGE_SIZE);
> +		return -E2BIG;
> +	}
> +
> +	tmpbuf = kmalloc(len + 1, GFP_KERNEL);
> +	if (!tmpbuf)
> +		return -ENOMEM;
> +
> +	if (copy_from_user(tmpbuf, ubuf, len)) {
> +		ret = -EFAULT;
> +		goto out;
> +	}
> +	tmpbuf[len] = '\0';
> +
> +	ret = display_crc_ctl_parse(dev_priv, tmpbuf, len);
> +
> +out:
> +	kfree(tmpbuf);
> +	if (ret < 0)
> +		return ret;
> +
> +	*offp += len;
> +	return len;
> +}
> +
> +const struct file_operations i915_display_crc_ctl_fops = {
> +	.owner = THIS_MODULE,
> +	.open = display_crc_ctl_open,
> +	.read = seq_read,
> +	.llseek = seq_lseek,
> +	.release = single_release,
> +	.write = display_crc_ctl_write
> +};
> +
> +void intel_display_crc_init(struct drm_i915_private *dev_priv)
> +{
> +	enum pipe pipe;
> +
> +	for_each_pipe(dev_priv, pipe) {
> +		struct intel_pipe_crc *pipe_crc = &dev_priv->pipe_crc[pipe];
> +
> +		pipe_crc->opened = false;
> +		spin_lock_init(&pipe_crc->lock);
> +		init_waitqueue_head(&pipe_crc->wq);
> +	}
> +}
> +
> +int intel_pipe_crc_create(struct drm_minor *minor)
> +{
> +	int ret, i;
> +
> +	for (i = 0; i < ARRAY_SIZE(i915_pipe_crc_data); i++) {
> +		ret = i915_pipe_crc_create(minor->debugfs_root, minor, i);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +void intel_pipe_crc_cleanup(struct drm_minor *minor)
> +{
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(i915_pipe_crc_data); i++) {
> +		struct drm_info_list *info_list =
> +			(struct drm_info_list *)&i915_pipe_crc_data[i];
> +
> +		drm_debugfs_remove_files(info_list, 1, minor);
> +	}
> +}
> -- 
> 2.7.4
> 
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx

-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/intel-gfx





[Index of Archives]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]
  Powered by Linux