[mirror_ubuntu-zesty-kernel.git] / drivers / gpu / drm / i915 / intel_crt.c

/*
 * Copyright © 2006-2007 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.
 *
 * Authors:
 *	Eric Anholt <eric@anholt.net>
 */

#include <linux/i2c.h>
#include "drmP.h"
#include "drm.h"
#include "drm_crtc.h"
#include "drm_crtc_helper.h"
#include "intel_drv.h"
#include "i915_drm.h"
#include "i915_drv.h"

static void intel_crt_dpms(struct drm_encoder *encoder, int mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 temp;

	temp = I915_READ(ADPA);
	temp &= ~(ADPA_HSYNC_CNTL_DISABLE | ADPA_VSYNC_CNTL_DISABLE);
	temp &= ~ADPA_DAC_ENABLE;

	switch(mode) {
	case DRM_MODE_DPMS_ON:
		temp |= ADPA_DAC_ENABLE;
		break;
	case DRM_MODE_DPMS_STANDBY:
		temp |= ADPA_DAC_ENABLE | ADPA_HSYNC_CNTL_DISABLE;
		break;
	case DRM_MODE_DPMS_SUSPEND:
		temp |= ADPA_DAC_ENABLE | ADPA_VSYNC_CNTL_DISABLE;
		break;
	case DRM_MODE_DPMS_OFF:
		temp |= ADPA_HSYNC_CNTL_DISABLE | ADPA_VSYNC_CNTL_DISABLE;
		break;
	}

	I915_WRITE(ADPA, temp);
}

static int intel_crt_mode_valid(struct drm_connector *connector,
				struct drm_display_mode *mode)
{
	struct drm_device *dev = connector->dev;

	int max_clock = 0;
	if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
		return MODE_NO_DBLESCAN;

	if (mode->clock < 25000)
		return MODE_CLOCK_LOW;

	if (!IS_I9XX(dev))
		max_clock = 350000;
	else
		max_clock = 400000;
	if (mode->clock > max_clock)
		return MODE_CLOCK_HIGH;

	return MODE_OK;
}

static bool intel_crt_mode_fixup(struct drm_encoder *encoder,
				 struct drm_display_mode *mode,
				 struct drm_display_mode *adjusted_mode)
{
	return true;
}

static void intel_crt_mode_set(struct drm_encoder *encoder,
			       struct drm_display_mode *mode,
			       struct drm_display_mode *adjusted_mode)
{

	struct drm_device *dev = encoder->dev;
	struct drm_crtc *crtc = encoder->crtc;
	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
	struct drm_i915_private *dev_priv = dev->dev_private;
	int dpll_md_reg;
	u32 adpa, dpll_md;

	if (intel_crtc->pipe == 0)
		dpll_md_reg = DPLL_A_MD;
	else
		dpll_md_reg = DPLL_B_MD;

	/*
	 * Disable separate mode multiplier used when cloning SDVO to CRT
	 * XXX this needs to be adjusted when we really are cloning
	 */
	if (IS_I965G(dev)) {
		dpll_md = I915_READ(dpll_md_reg);
		I915_WRITE(dpll_md_reg,
			   dpll_md & ~DPLL_MD_UDI_MULTIPLIER_MASK);
	}

	adpa = 0;
	if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
		adpa |= ADPA_HSYNC_ACTIVE_HIGH;
	if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
		adpa |= ADPA_VSYNC_ACTIVE_HIGH;

	if (intel_crtc->pipe == 0) {
		adpa |= ADPA_PIPE_A_SELECT;
		I915_WRITE(BCLRPAT_A, 0);
	} else {
		adpa |= ADPA_PIPE_B_SELECT;
		I915_WRITE(BCLRPAT_B, 0);
	}

	I915_WRITE(ADPA, adpa);
}

/**
 * Uses CRT_HOTPLUG_EN and CRT_HOTPLUG_STAT to detect CRT presence.
 *
 * Not for i915G/i915GM
 *
 * \return true if CRT is connected.
 * \return false if CRT is disconnected.
 */
static bool intel_crt_detect_hotplug(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 temp;

	unsigned long timeout = jiffies + msecs_to_jiffies(1000);

	temp = I915_READ(PORT_HOTPLUG_EN);

	I915_WRITE(PORT_HOTPLUG_EN,
		   temp | CRT_HOTPLUG_FORCE_DETECT | (1 << 5));

	do {
		if (!(I915_READ(PORT_HOTPLUG_EN) & CRT_HOTPLUG_FORCE_DETECT))
			break;
		msleep(1);
	} while (time_after(timeout, jiffies));

	if ((I915_READ(PORT_HOTPLUG_STAT) & CRT_HOTPLUG_MONITOR_MASK) ==
	    CRT_HOTPLUG_MONITOR_COLOR)
		return true;

	return false;
}

static bool intel_crt_detect_ddc(struct drm_connector *connector)
{
	struct intel_output *intel_output = to_intel_output(connector);

	/* CRT should always be at 0, but check anyway */
	if (intel_output->type != INTEL_OUTPUT_ANALOG)
		return false;

	return intel_ddc_probe(intel_output);
}

static enum drm_connector_status intel_crt_detect(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;

	if (IS_I9XX(dev) && !IS_I915G(dev) && !IS_I915GM(dev)) {
		if (intel_crt_detect_hotplug(connector))
			return connector_status_connected;
		else
			return connector_status_disconnected;
	}

	if (intel_crt_detect_ddc(connector))
		return connector_status_connected;

	/* TODO use load detect */
	return connector_status_unknown;
}

static void intel_crt_destroy(struct drm_connector *connector)
{
	struct intel_output *intel_output = to_intel_output(connector);

	intel_i2c_destroy(intel_output->ddc_bus);
	drm_sysfs_connector_remove(connector);
	drm_connector_cleanup(connector);
	kfree(connector);
}

static int intel_crt_get_modes(struct drm_connector *connector)
{
	struct intel_output *intel_output = to_intel_output(connector);
	return intel_ddc_get_modes(intel_output);
}

static int intel_crt_set_property(struct drm_connector *connector,
				  struct drm_property *property,
				  uint64_t value)
{
	struct drm_device *dev = connector->dev;

	if (property == dev->mode_config.dpms_property && connector->encoder)
		intel_crt_dpms(connector->encoder, (uint32_t)(value & 0xf));

	return 0;
}

/*
 * Routines for controlling stuff on the analog port
 */

static const struct drm_encoder_helper_funcs intel_crt_helper_funcs = {
	.dpms = intel_crt_dpms,
	.mode_fixup = intel_crt_mode_fixup,
	.prepare = intel_encoder_prepare,
	.commit = intel_encoder_commit,
	.mode_set = intel_crt_mode_set,
};

static const struct drm_connector_funcs intel_crt_connector_funcs = {
	.detect = intel_crt_detect,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.destroy = intel_crt_destroy,
	.set_property = intel_crt_set_property,
};

static const struct drm_connector_helper_funcs intel_crt_connector_helper_funcs = {
	.mode_valid = intel_crt_mode_valid,
	.get_modes = intel_crt_get_modes,
	.best_encoder = intel_best_encoder,
};

static void intel_crt_enc_destroy(struct drm_encoder *encoder)
{
	drm_encoder_cleanup(encoder);
}

static const struct drm_encoder_funcs intel_crt_enc_funcs = {
	.destroy = intel_crt_enc_destroy,
};

void intel_crt_init(struct drm_device *dev)
{
	struct drm_connector *connector;
	struct intel_output *intel_output;

	intel_output = kzalloc(sizeof(struct intel_output), GFP_KERNEL);
	if (!intel_output)
		return;

	connector = &intel_output->base;
	drm_connector_init(dev, &intel_output->base,
			   &intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA);

	drm_encoder_init(dev, &intel_output->enc, &intel_crt_enc_funcs,
			 DRM_MODE_ENCODER_DAC);

	drm_mode_connector_attach_encoder(&intel_output->base,
					  &intel_output->enc);

	/* Set up the DDC bus. */
	intel_output->ddc_bus = intel_i2c_create(dev, GPIOA, "CRTDDC_A");
	if (!intel_output->ddc_bus) {
		dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration "
			   "failed.\n");
		return;
	}

	intel_output->type = INTEL_OUTPUT_ANALOG;
	connector->interlace_allowed = 0;
	connector->doublescan_allowed = 0;

	drm_encoder_helper_add(&intel_output->enc, &intel_crt_helper_funcs);
	drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);

	drm_sysfs_connector_add(connector);
}
Commit	Line	Data
79e53945 JB	1	/*
	2	* Copyright © 2006-2007 Intel Corporation
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice (including the next
	12	* paragraph) shall be included in all copies or substantial portions of the
	13	* Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	21	* DEALINGS IN THE SOFTWARE.
	22	*
	23	* Authors:
	24	* Eric Anholt <eric@anholt.net>
	25	*/
	26
	27	#include <linux/i2c.h>
	28	#include "drmP.h"
	29	#include "drm.h"
	30	#include "drm_crtc.h"
	31	#include "drm_crtc_helper.h"
	32	#include "intel_drv.h"
	33	#include "i915_drm.h"
	34	#include "i915_drv.h"
	35
	36	static void intel_crt_dpms(struct drm_encoder *encoder, int mode)
	37	{
	38	struct drm_device *dev = encoder->dev;
	39	struct drm_i915_private *dev_priv = dev->dev_private;
	40	u32 temp;
	41
	42	temp = I915_READ(ADPA);
	43	temp &= ~(ADPA_HSYNC_CNTL_DISABLE \| ADPA_VSYNC_CNTL_DISABLE);
	44	temp &= ~ADPA_DAC_ENABLE;
	45
	46	switch(mode) {
	47	case DRM_MODE_DPMS_ON:
	48	temp \|= ADPA_DAC_ENABLE;
	49	break;
	50	case DRM_MODE_DPMS_STANDBY:
	51	temp \|= ADPA_DAC_ENABLE \| ADPA_HSYNC_CNTL_DISABLE;
	52	break;
	53	case DRM_MODE_DPMS_SUSPEND:
	54	temp \|= ADPA_DAC_ENABLE \| ADPA_VSYNC_CNTL_DISABLE;
	55	break;
	56	case DRM_MODE_DPMS_OFF:
	57	temp \|= ADPA_HSYNC_CNTL_DISABLE \| ADPA_VSYNC_CNTL_DISABLE;
	58	break;
	59	}
	60
	61	I915_WRITE(ADPA, temp);
	62	}
	63
	64	static int intel_crt_mode_valid(struct drm_connector *connector,
65	struct drm_display_mode *mode)
66	{
6bcdcd9e ZY	67	struct drm_device *dev = connector->dev;
	68
	69	int max_clock = 0;
79e53945 JB	70	if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
	71	return MODE_NO_DBLESCAN;
	72
6bcdcd9e ZY	73	if (mode->clock < 25000)
	74	return MODE_CLOCK_LOW;
	75
	76	if (!IS_I9XX(dev))
	77	max_clock = 350000;
	78	else
	79	max_clock = 400000;
	80	if (mode->clock > max_clock)
	81	return MODE_CLOCK_HIGH;
79e53945 JB	82
	83	return MODE_OK;
	84	}
	85
	86	static bool intel_crt_mode_fixup(struct drm_encoder *encoder,
	87	struct drm_display_mode *mode,
	88	struct drm_display_mode *adjusted_mode)
	89	{
	90	return true;
	91	}
	92
	93	static void intel_crt_mode_set(struct drm_encoder *encoder,
	94	struct drm_display_mode *mode,
	95	struct drm_display_mode *adjusted_mode)
	96	{
	97
	98	struct drm_device *dev = encoder->dev;
	99	struct drm_crtc *crtc = encoder->crtc;
	100	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
	101	struct drm_i915_private *dev_priv = dev->dev_private;
	102	int dpll_md_reg;
	103	u32 adpa, dpll_md;
	104
	105	if (intel_crtc->pipe == 0)
	106	dpll_md_reg = DPLL_A_MD;
	107	else
	108	dpll_md_reg = DPLL_B_MD;
	109
	110	/*
	111	* Disable separate mode multiplier used when cloning SDVO to CRT
	112	* XXX this needs to be adjusted when we really are cloning
	113	*/
	114	if (IS_I965G(dev)) {
	115	dpll_md = I915_READ(dpll_md_reg);
	116	I915_WRITE(dpll_md_reg,
	117	dpll_md & ~DPLL_MD_UDI_MULTIPLIER_MASK);
	118	}
	119
	120	adpa = 0;
	121	if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
	122	adpa \|= ADPA_HSYNC_ACTIVE_HIGH;
	123	if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
	124	adpa \|= ADPA_VSYNC_ACTIVE_HIGH;
	125
6bcdcd9e	126	if (intel_crtc->pipe == 0) {
79e53945	127	adpa \|= ADPA_PIPE_A_SELECT;
6bcdcd9e ZY	128	I915_WRITE(BCLRPAT_A, 0);
6bcdcd9e ZY	129	} else {
79e53945	130	adpa \|= ADPA_PIPE_B_SELECT;
6bcdcd9e ZY	131	I915_WRITE(BCLRPAT_B, 0);
6bcdcd9e ZY	132	}
79e53945 JB	133
	134	I915_WRITE(ADPA, adpa);
	135	}
	136
	137	/**
	138	* Uses CRT_HOTPLUG_EN and CRT_HOTPLUG_STAT to detect CRT presence.
	139	*
	140	* Not for i915G/i915GM
	141	*
	142	* \return true if CRT is connected.
	143	* \return false if CRT is disconnected.
	144	*/
	145	static bool intel_crt_detect_hotplug(struct drm_connector *connector)
	146	{
	147	struct drm_device *dev = connector->dev;
	148	struct drm_i915_private *dev_priv = dev->dev_private;
	149	u32 temp;
	150
	151	unsigned long timeout = jiffies + msecs_to_jiffies(1000);
	152
	153	temp = I915_READ(PORT_HOTPLUG_EN);
	154
	155	I915_WRITE(PORT_HOTPLUG_EN,
	156	temp \| CRT_HOTPLUG_FORCE_DETECT \| (1 << 5));
	157
	158	do {
	159	if (!(I915_READ(PORT_HOTPLUG_EN) & CRT_HOTPLUG_FORCE_DETECT))
	160	break;
	161	msleep(1);
	162	} while (time_after(timeout, jiffies));
	163
	164	if ((I915_READ(PORT_HOTPLUG_STAT) & CRT_HOTPLUG_MONITOR_MASK) ==
	165	CRT_HOTPLUG_MONITOR_COLOR)
	166	return true;
	167
	168	return false;
	169	}
	170
	171	static bool intel_crt_detect_ddc(struct drm_connector *connector)
	172	{
	173	struct intel_output *intel_output = to_intel_output(connector);
	174
	175	/* CRT should always be at 0, but check anyway */
	176	if (intel_output->type != INTEL_OUTPUT_ANALOG)
	177	return false;
	178
	179	return intel_ddc_probe(intel_output);
	180	}
	181
	182	static enum drm_connector_status intel_crt_detect(struct drm_connector *connector)
	183	{
	184	struct drm_device *dev = connector->dev;
	185
	186	if (IS_I9XX(dev) && !IS_I915G(dev) && !IS_I915GM(dev)) {
	187	if (intel_crt_detect_hotplug(connector))
	188	return connector_status_connected;
	189	else
	190	return connector_status_disconnected;
	191	}
	192
	193	if (intel_crt_detect_ddc(connector))
	194	return connector_status_connected;
	195
	196	/* TODO use load detect */
197	return connector_status_unknown;
198	}
199
200	static void intel_crt_destroy(struct drm_connector *connector)
201	{
202	struct intel_output *intel_output = to_intel_output(connector);
203
204	intel_i2c_destroy(intel_output->ddc_bus);
205	drm_sysfs_connector_remove(connector);
206	drm_connector_cleanup(connector);
207	kfree(connector);
208	}
209
210	static int intel_crt_get_modes(struct drm_connector *connector)
211	{
212	struct intel_output *intel_output = to_intel_output(connector);
213	return intel_ddc_get_modes(intel_output);
214	}
215
216	static int intel_crt_set_property(struct drm_connector *connector,
217	struct drm_property *property,
218	uint64_t value)
219	{
220	struct drm_device *dev = connector->dev;
221
222	if (property == dev->mode_config.dpms_property && connector->encoder)
223	intel_crt_dpms(connector->encoder, (uint32_t)(value & 0xf));
224
225	return 0;
226	}
227
228	/*
229	* Routines for controlling stuff on the analog port
230	*/
231
232	static const struct drm_encoder_helper_funcs intel_crt_helper_funcs = {
233	.dpms = intel_crt_dpms,
234	.mode_fixup = intel_crt_mode_fixup,
235	.prepare = intel_encoder_prepare,
236	.commit = intel_encoder_commit,
237	.mode_set = intel_crt_mode_set,
238	};
239
240	static const struct drm_connector_funcs intel_crt_connector_funcs = {
241	.detect = intel_crt_detect,
242	.fill_modes = drm_helper_probe_single_connector_modes,
243	.destroy = intel_crt_destroy,
244	.set_property = intel_crt_set_property,
245	};
246
247	static const struct drm_connector_helper_funcs intel_crt_connector_helper_funcs = {
248	.mode_valid = intel_crt_mode_valid,
249	.get_modes = intel_crt_get_modes,
250	.best_encoder = intel_best_encoder,
251	};
252
b358d0a6	253	static void intel_crt_enc_destroy(struct drm_encoder *encoder)
79e53945 JB	254	{
	255	drm_encoder_cleanup(encoder);
	256	}
	257
	258	static const struct drm_encoder_funcs intel_crt_enc_funcs = {
	259	.destroy = intel_crt_enc_destroy,
	260	};
	261
	262	void intel_crt_init(struct drm_device *dev)
	263	{
	264	struct drm_connector *connector;
	265	struct intel_output *intel_output;
	266
	267	intel_output = kzalloc(sizeof(struct intel_output), GFP_KERNEL);
	268	if (!intel_output)
	269	return;
	270
	271	connector = &intel_output->base;
	272	drm_connector_init(dev, &intel_output->base,
	273	&intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA);
	274
	275	drm_encoder_init(dev, &intel_output->enc, &intel_crt_enc_funcs,
	276	DRM_MODE_ENCODER_DAC);
	277
	278	drm_mode_connector_attach_encoder(&intel_output->base,
	279	&intel_output->enc);
	280
	281	/* Set up the DDC bus. */
	282	intel_output->ddc_bus = intel_i2c_create(dev, GPIOA, "CRTDDC_A");
	283	if (!intel_output->ddc_bus) {
	284	dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration "
	285	"failed.\n");
	286	return;
	287	}
	288
	289	intel_output->type = INTEL_OUTPUT_ANALOG;
	290	connector->interlace_allowed = 0;
	291	connector->doublescan_allowed = 0;
	292
	293	drm_encoder_helper_add(&intel_output->enc, &intel_crt_helper_funcs);
	294	drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs);
	295
	296	drm_sysfs_connector_add(connector);
	297	}