intel_sdvo.c 80.6 KB
Newer Older
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 28
/*
 * Copyright 2006 Dave Airlie <airlied@linux.ie>
 * Copyright © 2006-2007 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.
 *
 * Authors:
 *	Eric Anholt <eric@anholt.net>
 */
#include <linux/i2c.h>
29
#include <linux/slab.h>
30
#include <linux/delay.h>
31
#include <linux/export.h>
32 33 34
#include "drmP.h"
#include "drm.h"
#include "drm_crtc.h"
35
#include "drm_edid.h"
36
#include "intel_drv.h"
37 38 39 40
#include "i915_drm.h"
#include "i915_drv.h"
#include "intel_sdvo_regs.h"

41 42 43
#define SDVO_TMDS_MASK (SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_TMDS1)
#define SDVO_RGB_MASK  (SDVO_OUTPUT_RGB0 | SDVO_OUTPUT_RGB1)
#define SDVO_LVDS_MASK (SDVO_OUTPUT_LVDS0 | SDVO_OUTPUT_LVDS1)
44
#define SDVO_TV_MASK   (SDVO_OUTPUT_CVBS0 | SDVO_OUTPUT_SVID0 | SDVO_OUTPUT_YPRPB0)
45 46

#define SDVO_OUTPUT_MASK (SDVO_TMDS_MASK | SDVO_RGB_MASK | SDVO_LVDS_MASK |\
47
			SDVO_TV_MASK)
48 49

#define IS_TV(c)	(c->output_flag & SDVO_TV_MASK)
50
#define IS_TMDS(c)	(c->output_flag & SDVO_TMDS_MASK)
51
#define IS_LVDS(c)	(c->output_flag & SDVO_LVDS_MASK)
52
#define IS_TV_OR_LVDS(c) (c->output_flag & (SDVO_TV_MASK | SDVO_LVDS_MASK))
53
#define IS_DIGITAL(c) (c->output_flag & (SDVO_TMDS_MASK | SDVO_LVDS_MASK))
54

55

56
static const char *tv_format_names[] = {
57 58 59 60 61 62 63 64 65 66 67
	"NTSC_M"   , "NTSC_J"  , "NTSC_443",
	"PAL_B"    , "PAL_D"   , "PAL_G"   ,
	"PAL_H"    , "PAL_I"   , "PAL_M"   ,
	"PAL_N"    , "PAL_NC"  , "PAL_60"  ,
	"SECAM_B"  , "SECAM_D" , "SECAM_G" ,
	"SECAM_K"  , "SECAM_K1", "SECAM_L" ,
	"SECAM_60"
};

#define TV_FORMAT_NUM  (sizeof(tv_format_names) / sizeof(*tv_format_names))

68 69 70
struct intel_sdvo {
	struct intel_encoder base;

71
	struct i2c_adapter *i2c;
72
	u8 slave_addr;
73

74 75
	struct i2c_adapter ddc;

76
	/* Register for the SDVO device: SDVOB or SDVOC */
77
	uint32_t sdvo_reg;
78

79 80
	/* Active outputs controlled by this SDVO output */
	uint16_t controlled_output;
81

82 83 84 85
	/*
	 * Capabilities of the SDVO device returned by
	 * i830_sdvo_get_capabilities()
	 */
86
	struct intel_sdvo_caps caps;
87 88

	/* Pixel clock limitations reported by the SDVO device, in kHz */
89 90
	int pixel_clock_min, pixel_clock_max;

91 92 93 94 95 96
	/*
	* For multiple function SDVO device,
	* this is for current attached outputs.
	*/
	uint16_t attached_output;

97 98 99 100 101
	/*
	 * Hotplug activation bits for this device
	 */
	uint8_t hotplug_active[2];

102 103 104 105 106 107
	/**
	 * This is used to select the color range of RBG outputs in HDMI mode.
	 * It is only valid when using TMDS encoding and 8 bit per color mode.
	 */
	uint32_t color_range;

108 109 110 111 112 113 114 115 116
	/**
	 * This is set if we're going to treat the device as TV-out.
	 *
	 * While we have these nice friendly flags for output types that ought
	 * to decide this for us, the S-Video output on our HDMI+S-Video card
	 * shows up as RGB1 (VGA).
	 */
	bool is_tv;

117 118 119
	/* On different gens SDVOB is at different places. */
	bool is_sdvob;

120
	/* This is for current tv format name */
121
	int tv_format_index;
122

123 124 125 126
	/**
	 * This is set if we treat the device as HDMI, instead of DVI.
	 */
	bool is_hdmi;
127 128
	bool has_hdmi_monitor;
	bool has_hdmi_audio;
129

130
	/**
131 132
	 * This is set if we detect output of sdvo device as LVDS and
	 * have a valid fixed mode to use with the panel.
133 134
	 */
	bool is_lvds;
135

136 137 138 139 140
	/**
	 * This is sdvo fixed pannel mode pointer
	 */
	struct drm_display_mode *sdvo_lvds_fixed_mode;

141
	/* DDC bus used by this SDVO encoder */
142
	uint8_t ddc_bus;
143 144 145
};

struct intel_sdvo_connector {
146 147
	struct intel_connector base;

148 149 150
	/* Mark the type of connector */
	uint16_t output_flag;

151
	enum hdmi_force_audio force_audio;
152

153
	/* This contains all current supported TV format */
154
	u8 tv_format_supported[TV_FORMAT_NUM];
155
	int   format_supported_num;
156
	struct drm_property *tv_format;
157

158
	/* add the property for the SDVO-TV */
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
	struct drm_property *left;
	struct drm_property *right;
	struct drm_property *top;
	struct drm_property *bottom;
	struct drm_property *hpos;
	struct drm_property *vpos;
	struct drm_property *contrast;
	struct drm_property *saturation;
	struct drm_property *hue;
	struct drm_property *sharpness;
	struct drm_property *flicker_filter;
	struct drm_property *flicker_filter_adaptive;
	struct drm_property *flicker_filter_2d;
	struct drm_property *tv_chroma_filter;
	struct drm_property *tv_luma_filter;
174
	struct drm_property *dot_crawl;
175 176

	/* add the property for the SDVO-TV/LVDS */
177
	struct drm_property *brightness;
178 179 180

	/* Add variable to record current setting for the above property */
	u32	left_margin, right_margin, top_margin, bottom_margin;
181

182 183 184 185 186 187 188 189
	/* this is to get the range of margin.*/
	u32	max_hscan,  max_vscan;
	u32	max_hpos, cur_hpos;
	u32	max_vpos, cur_vpos;
	u32	cur_brightness, max_brightness;
	u32	cur_contrast,	max_contrast;
	u32	cur_saturation, max_saturation;
	u32	cur_hue,	max_hue;
190 191 192 193 194 195
	u32	cur_sharpness,	max_sharpness;
	u32	cur_flicker_filter,		max_flicker_filter;
	u32	cur_flicker_filter_adaptive,	max_flicker_filter_adaptive;
	u32	cur_flicker_filter_2d,		max_flicker_filter_2d;
	u32	cur_tv_chroma_filter,	max_tv_chroma_filter;
	u32	cur_tv_luma_filter,	max_tv_luma_filter;
196
	u32	cur_dot_crawl,	max_dot_crawl;
197 198
};

199
static struct intel_sdvo *to_intel_sdvo(struct drm_encoder *encoder)
200
{
201
	return container_of(encoder, struct intel_sdvo, base.base);
202 203
}

204 205 206 207 208 209
static struct intel_sdvo *intel_attached_sdvo(struct drm_connector *connector)
{
	return container_of(intel_attached_encoder(connector),
			    struct intel_sdvo, base);
}

210 211 212 213 214
static struct intel_sdvo_connector *to_intel_sdvo_connector(struct drm_connector *connector)
{
	return container_of(to_intel_connector(connector), struct intel_sdvo_connector, base);
}

215
static bool
216
intel_sdvo_output_setup(struct intel_sdvo *intel_sdvo, uint16_t flags);
217 218 219 220 221 222 223
static bool
intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
			      struct intel_sdvo_connector *intel_sdvo_connector,
			      int type);
static bool
intel_sdvo_create_enhance_property(struct intel_sdvo *intel_sdvo,
				   struct intel_sdvo_connector *intel_sdvo_connector);
224

225 226 227 228 229
/**
 * Writes the SDVOB or SDVOC with the given value, but always writes both
 * SDVOB and SDVOC to work around apparent hardware issues (according to
 * comments in the BIOS).
 */
230
static void intel_sdvo_write_sdvox(struct intel_sdvo *intel_sdvo, u32 val)
231
{
232
	struct drm_device *dev = intel_sdvo->base.base.dev;
233 234 235 236
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 bval = val, cval = val;
	int i;

237 238 239
	if (intel_sdvo->sdvo_reg == PCH_SDVOB) {
		I915_WRITE(intel_sdvo->sdvo_reg, val);
		I915_READ(intel_sdvo->sdvo_reg);
240 241 242
		return;
	}

243
	if (intel_sdvo->sdvo_reg == SDVOB) {
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
		cval = I915_READ(SDVOC);
	} else {
		bval = I915_READ(SDVOB);
	}
	/*
	 * Write the registers twice for luck. Sometimes,
	 * writing them only once doesn't appear to 'stick'.
	 * The BIOS does this too. Yay, magic
	 */
	for (i = 0; i < 2; i++)
	{
		I915_WRITE(SDVOB, bval);
		I915_READ(SDVOB);
		I915_WRITE(SDVOC, cval);
		I915_READ(SDVOC);
	}
}

262
static bool intel_sdvo_read_byte(struct intel_sdvo *intel_sdvo, u8 addr, u8 *ch)
263 264 265
{
	struct i2c_msg msgs[] = {
		{
266
			.addr = intel_sdvo->slave_addr,
267 268
			.flags = 0,
			.len = 1,
269
			.buf = &addr,
270 271
		},
		{
272
			.addr = intel_sdvo->slave_addr,
273 274
			.flags = I2C_M_RD,
			.len = 1,
275
			.buf = ch,
276 277
		}
	};
278
	int ret;
279

280
	if ((ret = i2c_transfer(intel_sdvo->i2c, msgs, 2)) == 2)
281 282
		return true;

283
	DRM_DEBUG_KMS("i2c transfer returned %d\n", ret);
284 285 286 287 288
	return false;
}

#define SDVO_CMD_NAME_ENTRY(cmd) {cmd, #cmd}
/** Mapping of command numbers to names, for debug output */
289
static const struct _sdvo_cmd_name {
290
	u8 cmd;
291
	const char *name;
292
} sdvo_cmd_names[] = {
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_RESET),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_DEVICE_CAPS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_FIRMWARE_REV),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_TRAINED_INPUTS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_ACTIVE_OUTPUTS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_ACTIVE_OUTPUTS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_IN_OUT_MAP),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_IN_OUT_MAP),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_ATTACHED_DISPLAYS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HOT_PLUG_SUPPORT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_ACTIVE_HOT_PLUG),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_ACTIVE_HOT_PLUG),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_INTERRUPT_EVENT_SOURCE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_TARGET_INPUT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_TARGET_OUTPUT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_INPUT_TIMINGS_PART1),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_INPUT_TIMINGS_PART2),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_INPUT_TIMINGS_PART1),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_INPUT_TIMINGS_PART2),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_INPUT_TIMINGS_PART1),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_OUTPUT_TIMINGS_PART1),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_OUTPUT_TIMINGS_PART2),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_OUTPUT_TIMINGS_PART1),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_OUTPUT_TIMINGS_PART2),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_OUTPUT_PIXEL_CLOCK_RANGE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SUPPORTED_CLOCK_RATE_MULTS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_CLOCK_RATE_MULT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_CLOCK_RATE_MULT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SUPPORTED_TV_FORMATS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_TV_FORMAT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_TV_FORMAT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SUPPORTED_POWER_STATES),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_POWER_STATE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_ENCODER_POWER_STATE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_DISPLAY_POWER_STATE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_CONTROL_BUS_SWITCH),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SDTV_RESOLUTION_SUPPORT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SCALED_HDTV_RESOLUTION_SUPPORT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS),

	/* Add the op code for SDVO enhancements */
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_HPOS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HPOS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_HPOS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_VPOS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_VPOS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_VPOS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_SATURATION),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SATURATION),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_SATURATION),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_HUE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HUE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_HUE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_CONTRAST),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_CONTRAST),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_CONTRAST),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_BRIGHTNESS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_BRIGHTNESS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_BRIGHTNESS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_OVERSCAN_H),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_OVERSCAN_H),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_OVERSCAN_H),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_OVERSCAN_V),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_OVERSCAN_V),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_OVERSCAN_V),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_FLICKER_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_FLICKER_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_FLICKER_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_FLICKER_FILTER_ADAPTIVE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_FLICKER_FILTER_ADAPTIVE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_FLICKER_FILTER_ADAPTIVE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_FLICKER_FILTER_2D),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_FLICKER_FILTER_2D),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_FLICKER_FILTER_2D),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_SHARPNESS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SHARPNESS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_SHARPNESS),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_DOT_CRAWL),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_DOT_CRAWL),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_TV_CHROMA_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_TV_CHROMA_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_TV_CHROMA_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_MAX_TV_LUMA_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_TV_LUMA_FILTER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_TV_LUMA_FILTER),

	/* HDMI op code */
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_SUPP_ENCODE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_ENCODE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_ENCODE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_PIXEL_REPLI),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_PIXEL_REPLI),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_COLORIMETRY_CAP),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_COLORIMETRY),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_COLORIMETRY),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_AUDIO_ENCRYPT_PREFER),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_AUDIO_STAT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_AUDIO_STAT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_INDEX),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_HBUF_INDEX),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_INFO),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_AV_SPLIT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_HBUF_AV_SPLIT),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_TXRATE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_HBUF_TXRATE),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_SET_HBUF_DATA),
	SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_DATA),
404 405
};

406
#define SDVO_NAME(svdo) ((svdo)->is_sdvob ? "SDVOB" : "SDVOC")
407

408
static void intel_sdvo_debug_write(struct intel_sdvo *intel_sdvo, u8 cmd,
409
				   const void *args, int args_len)
410 411 412
{
	int i;

413
	DRM_DEBUG_KMS("%s: W: %02X ",
414
				SDVO_NAME(intel_sdvo), cmd);
415
	for (i = 0; i < args_len; i++)
416
		DRM_LOG_KMS("%02X ", ((u8 *)args)[i]);
417
	for (; i < 8; i++)
418
		DRM_LOG_KMS("   ");
419
	for (i = 0; i < ARRAY_SIZE(sdvo_cmd_names); i++) {
420
		if (cmd == sdvo_cmd_names[i].cmd) {
421
			DRM_LOG_KMS("(%s)", sdvo_cmd_names[i].name);
422 423 424
			break;
		}
	}
425
	if (i == ARRAY_SIZE(sdvo_cmd_names))
426 427
		DRM_LOG_KMS("(%02X)", cmd);
	DRM_LOG_KMS("\n");
428 429
}

430 431 432 433 434 435 436 437 438 439
static const char *cmd_status_names[] = {
	"Power on",
	"Success",
	"Not supported",
	"Invalid arg",
	"Pending",
	"Target not specified",
	"Scaling not supported"
};

440 441
static bool intel_sdvo_write_cmd(struct intel_sdvo *intel_sdvo, u8 cmd,
				 const void *args, int args_len)
442
{
443 444 445 446
	u8 *buf, status;
	struct i2c_msg *msgs;
	int i, ret = true;

447
        /* Would be simpler to allocate both in one go ? */        
448 449 450 451 452
	buf = (u8 *)kzalloc(args_len * 2 + 2, GFP_KERNEL);
	if (!buf)
		return false;

	msgs = kcalloc(args_len + 3, sizeof(*msgs), GFP_KERNEL);
453 454
	if (!msgs) {
	        kfree(buf);
455
		return false;
456
        }
457

458
	intel_sdvo_debug_write(intel_sdvo, cmd, args, args_len);
459 460

	for (i = 0; i < args_len; i++) {
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
		msgs[i].addr = intel_sdvo->slave_addr;
		msgs[i].flags = 0;
		msgs[i].len = 2;
		msgs[i].buf = buf + 2 *i;
		buf[2*i + 0] = SDVO_I2C_ARG_0 - i;
		buf[2*i + 1] = ((u8*)args)[i];
	}
	msgs[i].addr = intel_sdvo->slave_addr;
	msgs[i].flags = 0;
	msgs[i].len = 2;
	msgs[i].buf = buf + 2*i;
	buf[2*i + 0] = SDVO_I2C_OPCODE;
	buf[2*i + 1] = cmd;

	/* the following two are to read the response */
	status = SDVO_I2C_CMD_STATUS;
	msgs[i+1].addr = intel_sdvo->slave_addr;
	msgs[i+1].flags = 0;
	msgs[i+1].len = 1;
	msgs[i+1].buf = &status;

	msgs[i+2].addr = intel_sdvo->slave_addr;
	msgs[i+2].flags = I2C_M_RD;
	msgs[i+2].len = 1;
	msgs[i+2].buf = &status;

	ret = i2c_transfer(intel_sdvo->i2c, msgs, i+3);
	if (ret < 0) {
		DRM_DEBUG_KMS("I2c transfer returned %d\n", ret);
490 491
		ret = false;
		goto out;
492 493 494 495
	}
	if (ret != i+3) {
		/* failure in I2C transfer */
		DRM_DEBUG_KMS("I2c transfer returned %d/%d\n", ret, i+3);
496
		ret = false;
497 498
	}

499 500 501 502
out:
	kfree(msgs);
	kfree(buf);
	return ret;
503 504
}

505 506
static bool intel_sdvo_read_response(struct intel_sdvo *intel_sdvo,
				     void *response, int response_len)
507
{
508 509
	u8 retry = 5;
	u8 status;
510
	int i;
511

512 513
	DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(intel_sdvo));

514 515 516 517 518 519 520 521
	/*
	 * The documentation states that all commands will be
	 * processed within 15µs, and that we need only poll
	 * the status byte a maximum of 3 times in order for the
	 * command to be complete.
	 *
	 * Check 5 times in case the hardware failed to read the docs.
	 */
522 523 524 525 526 527 528
	if (!intel_sdvo_read_byte(intel_sdvo,
				  SDVO_I2C_CMD_STATUS,
				  &status))
		goto log_fail;

	while (status == SDVO_CMD_STATUS_PENDING && retry--) {
		udelay(15);
529 530 531
		if (!intel_sdvo_read_byte(intel_sdvo,
					  SDVO_I2C_CMD_STATUS,
					  &status))
532 533
			goto log_fail;
	}
534

535
	if (status <= SDVO_CMD_STATUS_SCALING_NOT_SUPP)
536
		DRM_LOG_KMS("(%s)", cmd_status_names[status]);
537
	else
538
		DRM_LOG_KMS("(??? %d)", status);
539

540 541
	if (status != SDVO_CMD_STATUS_SUCCESS)
		goto log_fail;
542

543 544 545 546 547 548
	/* Read the command response */
	for (i = 0; i < response_len; i++) {
		if (!intel_sdvo_read_byte(intel_sdvo,
					  SDVO_I2C_RETURN_0 + i,
					  &((u8 *)response)[i]))
			goto log_fail;
549
		DRM_LOG_KMS(" %02X", ((u8 *)response)[i]);
550 551 552
	}
	DRM_LOG_KMS("\n");
	return true;
553

554
log_fail:
555
	DRM_LOG_KMS("... failed\n");
556
	return false;
557 558
}

559
static int intel_sdvo_get_pixel_multiplier(struct drm_display_mode *mode)
560 561 562 563 564 565 566 567 568
{
	if (mode->clock >= 100000)
		return 1;
	else if (mode->clock >= 50000)
		return 2;
	else
		return 4;
}

569 570
static bool intel_sdvo_set_control_bus_switch(struct intel_sdvo *intel_sdvo,
					      u8 ddc_bus)
571
{
572
	/* This must be the immediately preceding write before the i2c xfer */
573 574 575
	return intel_sdvo_write_cmd(intel_sdvo,
				    SDVO_CMD_SET_CONTROL_BUS_SWITCH,
				    &ddc_bus, 1);
576 577
}

578
static bool intel_sdvo_set_value(struct intel_sdvo *intel_sdvo, u8 cmd, const void *data, int len)
579
{
580 581 582 583
	if (!intel_sdvo_write_cmd(intel_sdvo, cmd, data, len))
		return false;

	return intel_sdvo_read_response(intel_sdvo, NULL, 0);
584
}
585

586 587 588 589 590
static bool
intel_sdvo_get_value(struct intel_sdvo *intel_sdvo, u8 cmd, void *value, int len)
{
	if (!intel_sdvo_write_cmd(intel_sdvo, cmd, NULL, 0))
		return false;
591

592 593
	return intel_sdvo_read_response(intel_sdvo, value, len);
}
594

595 596 597 598 599 600
static bool intel_sdvo_set_target_input(struct intel_sdvo *intel_sdvo)
{
	struct intel_sdvo_set_target_input_args targets = {0};
	return intel_sdvo_set_value(intel_sdvo,
				    SDVO_CMD_SET_TARGET_INPUT,
				    &targets, sizeof(targets));
601 602 603 604 605 606 607 608
}

/**
 * Return whether each input is trained.
 *
 * This function is making an assumption about the layout of the response,
 * which should be checked against the docs.
 */
609
static bool intel_sdvo_get_trained_inputs(struct intel_sdvo *intel_sdvo, bool *input_1, bool *input_2)
610 611 612
{
	struct intel_sdvo_get_trained_inputs_response response;

613
	BUILD_BUG_ON(sizeof(response) != 1);
614 615
	if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_TRAINED_INPUTS,
				  &response, sizeof(response)))
616 617 618 619 620 621 622
		return false;

	*input_1 = response.input0_trained;
	*input_2 = response.input1_trained;
	return true;
}

623
static bool intel_sdvo_set_active_outputs(struct intel_sdvo *intel_sdvo,
624 625
					  u16 outputs)
{
626 627 628
	return intel_sdvo_set_value(intel_sdvo,
				    SDVO_CMD_SET_ACTIVE_OUTPUTS,
				    &outputs, sizeof(outputs));
629 630
}

631
static bool intel_sdvo_set_encoder_power_state(struct intel_sdvo *intel_sdvo,
632 633
					       int mode)
{
634
	u8 state = SDVO_ENCODER_STATE_ON;
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650

	switch (mode) {
	case DRM_MODE_DPMS_ON:
		state = SDVO_ENCODER_STATE_ON;
		break;
	case DRM_MODE_DPMS_STANDBY:
		state = SDVO_ENCODER_STATE_STANDBY;
		break;
	case DRM_MODE_DPMS_SUSPEND:
		state = SDVO_ENCODER_STATE_SUSPEND;
		break;
	case DRM_MODE_DPMS_OFF:
		state = SDVO_ENCODER_STATE_OFF;
		break;
	}

651 652
	return intel_sdvo_set_value(intel_sdvo,
				    SDVO_CMD_SET_ENCODER_POWER_STATE, &state, sizeof(state));
653 654
}

655
static bool intel_sdvo_get_input_pixel_clock_range(struct intel_sdvo *intel_sdvo,
656 657 658 659 660
						   int *clock_min,
						   int *clock_max)
{
	struct intel_sdvo_pixel_clock_range clocks;

661
	BUILD_BUG_ON(sizeof(clocks) != 4);
662 663 664
	if (!intel_sdvo_get_value(intel_sdvo,
				  SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE,
				  &clocks, sizeof(clocks)))
665 666 667 668 669 670 671 672
		return false;

	/* Convert the values from units of 10 kHz to kHz. */
	*clock_min = clocks.min * 10;
	*clock_max = clocks.max * 10;
	return true;
}

673
static bool intel_sdvo_set_target_output(struct intel_sdvo *intel_sdvo,
674 675
					 u16 outputs)
{
676 677 678
	return intel_sdvo_set_value(intel_sdvo,
				    SDVO_CMD_SET_TARGET_OUTPUT,
				    &outputs, sizeof(outputs));
679 680
}

681
static bool intel_sdvo_set_timing(struct intel_sdvo *intel_sdvo, u8 cmd,
682 683
				  struct intel_sdvo_dtd *dtd)
{
684 685
	return intel_sdvo_set_value(intel_sdvo, cmd, &dtd->part1, sizeof(dtd->part1)) &&
		intel_sdvo_set_value(intel_sdvo, cmd + 1, &dtd->part2, sizeof(dtd->part2));
686 687
}

688
static bool intel_sdvo_set_input_timing(struct intel_sdvo *intel_sdvo,
689 690
					 struct intel_sdvo_dtd *dtd)
{
691
	return intel_sdvo_set_timing(intel_sdvo,
692 693 694
				     SDVO_CMD_SET_INPUT_TIMINGS_PART1, dtd);
}

695
static bool intel_sdvo_set_output_timing(struct intel_sdvo *intel_sdvo,
696 697
					 struct intel_sdvo_dtd *dtd)
{
698
	return intel_sdvo_set_timing(intel_sdvo,
699 700 701
				     SDVO_CMD_SET_OUTPUT_TIMINGS_PART1, dtd);
}

702
static bool
703
intel_sdvo_create_preferred_input_timing(struct intel_sdvo *intel_sdvo,
704 705 706 707 708 709
					 uint16_t clock,
					 uint16_t width,
					 uint16_t height)
{
	struct intel_sdvo_preferred_input_timing_args args;

710
	memset(&args, 0, sizeof(args));
711 712 713
	args.clock = clock;
	args.width = width;
	args.height = height;
714
	args.interlace = 0;
715

716 717 718
	if (intel_sdvo->is_lvds &&
	   (intel_sdvo->sdvo_lvds_fixed_mode->hdisplay != width ||
	    intel_sdvo->sdvo_lvds_fixed_mode->vdisplay != height))
719 720
		args.scaled = 1;

721 722 723
	return intel_sdvo_set_value(intel_sdvo,
				    SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING,
				    &args, sizeof(args));
724 725
}

726
static bool intel_sdvo_get_preferred_input_timing(struct intel_sdvo *intel_sdvo,
727 728
						  struct intel_sdvo_dtd *dtd)
{
729 730
	BUILD_BUG_ON(sizeof(dtd->part1) != 8);
	BUILD_BUG_ON(sizeof(dtd->part2) != 8);
731 732 733 734
	return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1,
				    &dtd->part1, sizeof(dtd->part1)) &&
		intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2,
				     &dtd->part2, sizeof(dtd->part2));
735
}
736

737
static bool intel_sdvo_set_clock_rate_mult(struct intel_sdvo *intel_sdvo, u8 val)
738
{
739
	return intel_sdvo_set_value(intel_sdvo, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1);
740 741
}

742
static void intel_sdvo_get_dtd_from_mode(struct intel_sdvo_dtd *dtd,
743
					 const struct drm_display_mode *mode)
744
{
745 746 747
	uint16_t width, height;
	uint16_t h_blank_len, h_sync_len, v_blank_len, v_sync_len;
	uint16_t h_sync_offset, v_sync_offset;
748
	int mode_clock;
749

750 751
	width = mode->hdisplay;
	height = mode->vdisplay;
752 753

	/* do some mode translations */
754 755
	h_blank_len = mode->htotal - mode->hdisplay;
	h_sync_len = mode->hsync_end - mode->hsync_start;
756

757 758
	v_blank_len = mode->vtotal - mode->vdisplay;
	v_sync_len = mode->vsync_end - mode->vsync_start;
759

760 761
	h_sync_offset = mode->hsync_start - mode->hdisplay;
	v_sync_offset = mode->vsync_start - mode->vdisplay;
762

763 764 765 766 767
	mode_clock = mode->clock;
	mode_clock /= intel_mode_get_pixel_multiplier(mode) ?: 1;
	mode_clock /= 10;
	dtd->part1.clock = mode_clock;

768 769 770
	dtd->part1.h_active = width & 0xff;
	dtd->part1.h_blank = h_blank_len & 0xff;
	dtd->part1.h_high = (((width >> 8) & 0xf) << 4) |
771
		((h_blank_len >> 8) & 0xf);
772 773 774
	dtd->part1.v_active = height & 0xff;
	dtd->part1.v_blank = v_blank_len & 0xff;
	dtd->part1.v_high = (((height >> 8) & 0xf) << 4) |
775 776
		((v_blank_len >> 8) & 0xf);

777
	dtd->part2.h_sync_off = h_sync_offset & 0xff;
778 779
	dtd->part2.h_sync_width = h_sync_len & 0xff;
	dtd->part2.v_sync_off_width = (v_sync_offset & 0xf) << 4 |
780
		(v_sync_len & 0xf);
781
	dtd->part2.sync_off_width_high = ((h_sync_offset & 0x300) >> 2) |
782 783 784
		((h_sync_len & 0x300) >> 4) | ((v_sync_offset & 0x30) >> 2) |
		((v_sync_len & 0x30) >> 4);

785
	dtd->part2.dtd_flags = 0x18;
786 787
	if (mode->flags & DRM_MODE_FLAG_INTERLACE)
		dtd->part2.dtd_flags |= DTD_FLAG_INTERLACE;
788
	if (mode->flags & DRM_MODE_FLAG_PHSYNC)
789
		dtd->part2.dtd_flags |= DTD_FLAG_HSYNC_POSITIVE;
790
	if (mode->flags & DRM_MODE_FLAG_PVSYNC)
791
		dtd->part2.dtd_flags |= DTD_FLAG_VSYNC_POSITIVE;
792 793 794 795 796 797 798

	dtd->part2.sdvo_flags = 0;
	dtd->part2.v_sync_off_high = v_sync_offset & 0xc0;
	dtd->part2.reserved = 0;
}

static void intel_sdvo_get_mode_from_dtd(struct drm_display_mode * mode,
799
					 const struct intel_sdvo_dtd *dtd)
800 801 802 803
{
	mode->hdisplay = dtd->part1.h_active;
	mode->hdisplay += ((dtd->part1.h_high >> 4) & 0x0f) << 8;
	mode->hsync_start = mode->hdisplay + dtd->part2.h_sync_off;
804
	mode->hsync_start += (dtd->part2.sync_off_width_high & 0xc0) << 2;
805 806 807 808 809 810 811 812 813
	mode->hsync_end = mode->hsync_start + dtd->part2.h_sync_width;
	mode->hsync_end += (dtd->part2.sync_off_width_high & 0x30) << 4;
	mode->htotal = mode->hdisplay + dtd->part1.h_blank;
	mode->htotal += (dtd->part1.h_high & 0xf) << 8;

	mode->vdisplay = dtd->part1.v_active;
	mode->vdisplay += ((dtd->part1.v_high >> 4) & 0x0f) << 8;
	mode->vsync_start = mode->vdisplay;
	mode->vsync_start += (dtd->part2.v_sync_off_width >> 4) & 0xf;
814
	mode->vsync_start += (dtd->part2.sync_off_width_high & 0x0c) << 2;
815 816 817 818 819 820 821 822 823
	mode->vsync_start += dtd->part2.v_sync_off_high & 0xc0;
	mode->vsync_end = mode->vsync_start +
		(dtd->part2.v_sync_off_width & 0xf);
	mode->vsync_end += (dtd->part2.sync_off_width_high & 0x3) << 4;
	mode->vtotal = mode->vdisplay + dtd->part1.v_blank;
	mode->vtotal += (dtd->part1.v_high & 0xf) << 8;

	mode->clock = dtd->part1.clock * 10;

824
	mode->flags &= ~(DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC);
825 826 827
	if (dtd->part2.dtd_flags & DTD_FLAG_INTERLACE)
		mode->flags |= DRM_MODE_FLAG_INTERLACE;
	if (dtd->part2.dtd_flags & DTD_FLAG_HSYNC_POSITIVE)
828
		mode->flags |= DRM_MODE_FLAG_PHSYNC;
829
	if (dtd->part2.dtd_flags & DTD_FLAG_VSYNC_POSITIVE)
830 831 832
		mode->flags |= DRM_MODE_FLAG_PVSYNC;
}

833
static bool intel_sdvo_check_supp_encode(struct intel_sdvo *intel_sdvo)
834
{
835
	struct intel_sdvo_encode encode;
836

837
	BUILD_BUG_ON(sizeof(encode) != 2);
838 839 840
	return intel_sdvo_get_value(intel_sdvo,
				  SDVO_CMD_GET_SUPP_ENCODE,
				  &encode, sizeof(encode));
841 842
}

843
static bool intel_sdvo_set_encode(struct intel_sdvo *intel_sdvo,
844
				  uint8_t mode)
845
{
846
	return intel_sdvo_set_value(intel_sdvo, SDVO_CMD_SET_ENCODE, &mode, 1);
847 848
}

849
static bool intel_sdvo_set_colorimetry(struct intel_sdvo *intel_sdvo,
850 851
				       uint8_t mode)
{
852
	return intel_sdvo_set_value(intel_sdvo, SDVO_CMD_SET_COLORIMETRY, &mode, 1);
853 854 855
}

#if 0
856
static void intel_sdvo_dump_hdmi_buf(struct intel_sdvo *intel_sdvo)
857 858 859 860 861 862 863 864
{
	int i, j;
	uint8_t set_buf_index[2];
	uint8_t av_split;
	uint8_t buf_size;
	uint8_t buf[48];
	uint8_t *pos;

865
	intel_sdvo_get_value(encoder, SDVO_CMD_GET_HBUF_AV_SPLIT, &av_split, 1);
866 867 868

	for (i = 0; i <= av_split; i++) {
		set_buf_index[0] = i; set_buf_index[1] = 0;
869
		intel_sdvo_write_cmd(encoder, SDVO_CMD_SET_HBUF_INDEX,
870
				     set_buf_index, 2);
871 872
		intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_INFO, NULL, 0);
		intel_sdvo_read_response(encoder, &buf_size, 1);
873 874 875

		pos = buf;
		for (j = 0; j <= buf_size; j += 8) {
876
			intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_DATA,
877
					     NULL, 0);
878
			intel_sdvo_read_response(encoder, pos, 8);
879 880 881 882 883 884
			pos += 8;
		}
	}
}
#endif

885
static bool intel_sdvo_set_avi_infoframe(struct intel_sdvo *intel_sdvo)
886 887 888
{
	struct dip_infoframe avi_if = {
		.type = DIP_TYPE_AVI,
889
		.ver = DIP_VERSION_AVI,
890 891
		.len = DIP_LEN_AVI,
	};
892 893
	uint8_t tx_rate = SDVO_HBUF_TX_VSYNC;
	uint8_t set_buf_index[2] = { 1, 0 };
894 895
	uint8_t sdvo_data[4 + sizeof(avi_if.body.avi)];
	uint64_t *data = (uint64_t *)sdvo_data;
896 897 898 899
	unsigned i;

	intel_dip_infoframe_csum(&avi_if);

900 901 902 903 904 905
	/* sdvo spec says that the ecc is handled by the hw, and it looks like
	 * we must not send the ecc field, either. */
	memcpy(sdvo_data, &avi_if, 3);
	sdvo_data[3] = avi_if.checksum;
	memcpy(&sdvo_data[4], &avi_if.body, sizeof(avi_if.body.avi));

906 907
	if (!intel_sdvo_set_value(intel_sdvo,
				  SDVO_CMD_SET_HBUF_INDEX,
908 909 910
				  set_buf_index, 2))
		return false;

911
	for (i = 0; i < sizeof(sdvo_data); i += 8) {
912 913
		if (!intel_sdvo_set_value(intel_sdvo,
					  SDVO_CMD_SET_HBUF_DATA,
914 915 916 917
					  data, 8))
			return false;
		data++;
	}
918

919 920
	return intel_sdvo_set_value(intel_sdvo,
				    SDVO_CMD_SET_HBUF_TXRATE,
921
				    &tx_rate, 1);
922 923
}

924
static bool intel_sdvo_set_tv_format(struct intel_sdvo *intel_sdvo)
925
{
926
	struct intel_sdvo_tv_format format;
927
	uint32_t format_map;
928

929
	format_map = 1 << intel_sdvo->tv_format_index;
930
	memset(&format, 0, sizeof(format));
931
	memcpy(&format, &format_map, min(sizeof(format), sizeof(format_map)));
932

933 934 935 936
	BUILD_BUG_ON(sizeof(format) != 6);
	return intel_sdvo_set_value(intel_sdvo,
				    SDVO_CMD_SET_TV_FORMAT,
				    &format, sizeof(format));
937 938
}

939 940
static bool
intel_sdvo_set_output_timings_from_mode(struct intel_sdvo *intel_sdvo,
941
					const struct drm_display_mode *mode)
942
{
943
	struct intel_sdvo_dtd output_dtd;
944

945 946 947
	if (!intel_sdvo_set_target_output(intel_sdvo,
					  intel_sdvo->attached_output))
		return false;
948

949 950 951
	intel_sdvo_get_dtd_from_mode(&output_dtd, mode);
	if (!intel_sdvo_set_output_timing(intel_sdvo, &output_dtd))
		return false;
952

953 954 955
	return true;
}

956 957
/* Asks the sdvo controller for the preferred input mode given the output mode.
 * Unfortunately we have to set up the full output mode to do that. */
958
static bool
959
intel_sdvo_get_preferred_input_mode(struct intel_sdvo *intel_sdvo,
960
				    const struct drm_display_mode *mode,
961
				    struct drm_display_mode *adjusted_mode)
962
{
963 964
	struct intel_sdvo_dtd input_dtd;

965 966 967
	/* Reset the input timing to the screen. Assume always input 0. */
	if (!intel_sdvo_set_target_input(intel_sdvo))
		return false;
968

969 970 971 972 973
	if (!intel_sdvo_create_preferred_input_timing(intel_sdvo,
						      mode->clock / 10,
						      mode->hdisplay,
						      mode->vdisplay))
		return false;
974

975
	if (!intel_sdvo_get_preferred_input_timing(intel_sdvo,
976
						   &input_dtd))
977
		return false;
978

979
	intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
980

981 982
	return true;
}
983

984
static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
985
				  const struct drm_display_mode *mode,
986 987
				  struct drm_display_mode *adjusted_mode)
{
988
	struct intel_sdvo *intel_sdvo = to_intel_sdvo(encoder);
989
	int multiplier;
990

991 992 993 994 995 996 997 998
	/* We need to construct preferred input timings based on our
	 * output timings.  To do that, we have to set the output
	 * timings, even though this isn't really the right place in
	 * the sequence to do it. Oh well.
	 */
	if (intel_sdvo->is_tv) {
		if (!intel_sdvo_set_output_timings_from_mode(intel_sdvo, mode))
			return false;
999

1000 1001 1002
		(void) intel_sdvo_get_preferred_input_mode(intel_sdvo,
							   mode,
							   adjusted_mode);
1003
	} else if (intel_sdvo->is_lvds) {
1004
		if (!intel_sdvo_set_output_timings_from_mode(intel_sdvo,
1005
							     intel_sdvo->sdvo_lvds_fixed_mode))
1006
			return false;
1007

1008 1009 1010
		(void) intel_sdvo_get_preferred_input_mode(intel_sdvo,
							   mode,
							   adjusted_mode);
1011
	}
1012 1013

	/* Make the CRTC code factor in the SDVO pixel multiplier.  The
1014
	 * SDVO device will factor out the multiplier during mode_set.
1015
	 */
1016 1017
	multiplier = intel_sdvo_get_pixel_multiplier(adjusted_mode);
	intel_mode_set_pixel_multiplier(adjusted_mode, multiplier);
1018

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
	return true;
}

static void intel_sdvo_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_i915_private *dev_priv = dev->dev_private;
	struct drm_crtc *crtc = encoder->crtc;
	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
1030
	struct intel_sdvo *intel_sdvo = to_intel_sdvo(encoder);
1031
	u32 sdvox;
1032
	struct intel_sdvo_in_out_map in_out;
1033
	struct intel_sdvo_dtd input_dtd, output_dtd;
1034 1035
	int pixel_multiplier = intel_mode_get_pixel_multiplier(adjusted_mode);
	int rate;
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045

	if (!mode)
		return;

	/* First, set the input mapping for the first input to our controlled
	 * output. This is only correct if we're a single-input device, in
	 * which case the first input is the output from the appropriate SDVO
	 * channel on the motherboard.  In a two-input device, the first input
	 * will be SDVOB and the second SDVOC.
	 */
1046
	in_out.in0 = intel_sdvo->attached_output;
1047 1048
	in_out.in1 = 0;

1049 1050 1051
	intel_sdvo_set_value(intel_sdvo,
			     SDVO_CMD_SET_IN_OUT_MAP,
			     &in_out, sizeof(in_out));
1052

1053 1054 1055 1056
	/* Set the output timings to the screen */
	if (!intel_sdvo_set_target_output(intel_sdvo,
					  intel_sdvo->attached_output))
		return;
1057

1058 1059 1060 1061 1062 1063
	/* lvds has a special fixed output timing. */
	if (intel_sdvo->is_lvds)
		intel_sdvo_get_dtd_from_mode(&output_dtd,
					     intel_sdvo->sdvo_lvds_fixed_mode);
	else
		intel_sdvo_get_dtd_from_mode(&output_dtd, mode);
1064 1065 1066
	if (!intel_sdvo_set_output_timing(intel_sdvo, &output_dtd))
		DRM_INFO("Setting output timings on %s failed\n",
			 SDVO_NAME(intel_sdvo));
1067 1068

	/* Set the input timing to the screen. Assume always input 0. */
1069 1070
	if (!intel_sdvo_set_target_input(intel_sdvo))
		return;
1071

1072 1073 1074 1075 1076 1077 1078
	if (intel_sdvo->has_hdmi_monitor) {
		intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_HDMI);
		intel_sdvo_set_colorimetry(intel_sdvo,
					   SDVO_COLORIMETRY_RGB256);
		intel_sdvo_set_avi_infoframe(intel_sdvo);
	} else
		intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_DVI);
1079

1080 1081 1082
	if (intel_sdvo->is_tv &&
	    !intel_sdvo_set_tv_format(intel_sdvo))
		return;
1083

1084 1085 1086 1087
	/* We have tried to get input timing in mode_fixup, and filled into
	 * adjusted_mode.
	 */
	intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode);
1088 1089 1090
	if (!intel_sdvo_set_input_timing(intel_sdvo, &input_dtd))
		DRM_INFO("Setting input timings on %s failed\n",
			 SDVO_NAME(intel_sdvo));
1091

1092 1093
	switch (pixel_multiplier) {
	default:
1094 1095 1096
	case 1: rate = SDVO_CLOCK_RATE_MULT_1X; break;
	case 2: rate = SDVO_CLOCK_RATE_MULT_2X; break;
	case 4: rate = SDVO_CLOCK_RATE_MULT_4X; break;
1097
	}
1098 1099
	if (!intel_sdvo_set_clock_rate_mult(intel_sdvo, rate))
		return;
1100 1101

	/* Set the SDVO control regs. */
1102
	if (INTEL_INFO(dev)->gen >= 4) {
1103 1104 1105
		/* The real mode polarity is set by the SDVO commands, using
		 * struct intel_sdvo_dtd. */
		sdvox = SDVO_VSYNC_ACTIVE_HIGH | SDVO_HSYNC_ACTIVE_HIGH;
1106 1107
		if (intel_sdvo->is_hdmi)
			sdvox |= intel_sdvo->color_range;
1108 1109
		if (INTEL_INFO(dev)->gen < 5)
			sdvox |= SDVO_BORDER_ENABLE;
1110
	} else {
1111
		sdvox = I915_READ(intel_sdvo->sdvo_reg);
1112
		switch (intel_sdvo->sdvo_reg) {
1113 1114 1115 1116 1117 1118 1119 1120 1121
		case SDVOB:
			sdvox &= SDVOB_PRESERVE_MASK;
			break;
		case SDVOC:
			sdvox &= SDVOC_PRESERVE_MASK;
			break;
		}
		sdvox |= (9 << 19) | SDVO_BORDER_ENABLE;
	}
1122 1123 1124 1125 1126 1127

	if (INTEL_PCH_TYPE(dev) >= PCH_CPT)
		sdvox |= TRANSCODER_CPT(intel_crtc->pipe);
	else
		sdvox |= TRANSCODER(intel_crtc->pipe);

1128
	if (intel_sdvo->has_hdmi_audio)
1129
		sdvox |= SDVO_AUDIO_ENABLE;
1130

1131
	if (INTEL_INFO(dev)->gen >= 4) {
1132 1133 1134
		/* done in crtc_mode_set as the dpll_md reg must be written early */
	} else if (IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev)) {
		/* done in crtc_mode_set as it lives inside the dpll register */
1135
	} else {
1136
		sdvox |= (pixel_multiplier - 1) << SDVO_PORT_MULTIPLY_SHIFT;
1137 1138
	}

1139 1140
	if (input_dtd.part2.sdvo_flags & SDVO_NEED_TO_STALL &&
	    INTEL_INFO(dev)->gen < 5)
1141
		sdvox |= SDVO_STALL_SELECT;
1142
	intel_sdvo_write_sdvox(intel_sdvo, sdvox);
1143 1144
}

1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
static void intel_disable_sdvo(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
	struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
	u32 temp;

	intel_sdvo_set_active_outputs(intel_sdvo, 0);
	if (0)
		intel_sdvo_set_encoder_power_state(intel_sdvo,
						   DRM_MODE_DPMS_OFF);

	temp = I915_READ(intel_sdvo->sdvo_reg);
	if ((temp & SDVO_ENABLE) != 0) {
		intel_sdvo_write_sdvox(intel_sdvo, temp & ~SDVO_ENABLE);
	}
}

static void intel_enable_sdvo(struct intel_encoder *encoder)
{
	struct drm_device *dev = encoder->base.dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
	struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
	u32 temp;
	bool input1, input2;
	int i;
	u8 status;

	temp = I915_READ(intel_sdvo->sdvo_reg);
	if ((temp & SDVO_ENABLE) == 0)
		intel_sdvo_write_sdvox(intel_sdvo, temp | SDVO_ENABLE);
	for (i = 0; i < 2; i++)
		intel_wait_for_vblank(dev, intel_crtc->pipe);

	status = intel_sdvo_get_trained_inputs(intel_sdvo, &input1, &input2);
	/* Warn if the device reported failure to sync.
	 * A lot of SDVO devices fail to notify of sync, but it's
	 * a given it the status is a success, we succeeded.
	 */
	if (status == SDVO_CMD_STATUS_SUCCESS && !input1) {
		DRM_DEBUG_KMS("First %s output reported failure to "
				"sync\n", SDVO_NAME(intel_sdvo));
	}

	if (0)
		intel_sdvo_set_encoder_power_state(intel_sdvo,
						   DRM_MODE_DPMS_ON);
	intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo->attached_output);
}

1195
static void intel_sdvo_dpms(struct drm_connector *connector, int mode)
1196
{
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
	struct drm_crtc *crtc;
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);

	/* dvo supports only 2 dpms states. */
	if (mode != DRM_MODE_DPMS_ON)
		mode = DRM_MODE_DPMS_OFF;

	if (mode == connector->dpms)
		return;

	connector->dpms = mode;

	/* Only need to change hw state when actually enabled */
	crtc = intel_sdvo->base.base.crtc;
	if (!crtc) {
		intel_sdvo->base.connectors_active = false;
		return;
	}
1215 1216

	if (mode != DRM_MODE_DPMS_ON) {
1217
		intel_sdvo_set_active_outputs(intel_sdvo, 0);
1218
		if (0)
1219
			intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
1220

1221 1222 1223
		intel_sdvo->base.connectors_active = false;

		intel_crtc_update_dpms(crtc);
1224
	} else {
1225 1226 1227
		intel_sdvo->base.connectors_active = true;

		intel_crtc_update_dpms(crtc);
1228 1229

		if (0)
1230 1231
			intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
		intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo->attached_output);
1232 1233 1234 1235 1236 1237
	}
}

static int intel_sdvo_mode_valid(struct drm_connector *connector,
				 struct drm_display_mode *mode)
{
1238
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
1239 1240 1241 1242

	if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
		return MODE_NO_DBLESCAN;

1243
	if (intel_sdvo->pixel_clock_min > mode->clock)
1244 1245
		return MODE_CLOCK_LOW;

1246
	if (intel_sdvo->pixel_clock_max < mode->clock)
1247 1248
		return MODE_CLOCK_HIGH;

1249
	if (intel_sdvo->is_lvds) {
1250
		if (mode->hdisplay > intel_sdvo->sdvo_lvds_fixed_mode->hdisplay)
1251 1252
			return MODE_PANEL;

1253
		if (mode->vdisplay > intel_sdvo->sdvo_lvds_fixed_mode->vdisplay)
1254 1255 1256
			return MODE_PANEL;
	}

1257 1258 1259
	return MODE_OK;
}

1260
static bool intel_sdvo_get_capabilities(struct intel_sdvo *intel_sdvo, struct intel_sdvo_caps *caps)
1261
{
1262
	BUILD_BUG_ON(sizeof(*caps) != 8);
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
	if (!intel_sdvo_get_value(intel_sdvo,
				  SDVO_CMD_GET_DEVICE_CAPS,
				  caps, sizeof(*caps)))
		return false;

	DRM_DEBUG_KMS("SDVO capabilities:\n"
		      "  vendor_id: %d\n"
		      "  device_id: %d\n"
		      "  device_rev_id: %d\n"
		      "  sdvo_version_major: %d\n"
		      "  sdvo_version_minor: %d\n"
		      "  sdvo_inputs_mask: %d\n"
		      "  smooth_scaling: %d\n"
		      "  sharp_scaling: %d\n"
		      "  up_scaling: %d\n"
		      "  down_scaling: %d\n"
		      "  stall_support: %d\n"
		      "  output_flags: %d\n",
		      caps->vendor_id,
		      caps->device_id,
		      caps->device_rev_id,
		      caps->sdvo_version_major,
		      caps->sdvo_version_minor,
		      caps->sdvo_inputs_mask,
		      caps->smooth_scaling,
		      caps->sharp_scaling,
		      caps->up_scaling,
		      caps->down_scaling,
		      caps->stall_support,
		      caps->output_flags);

	return true;
1295 1296
}

1297
static int intel_sdvo_supports_hotplug(struct intel_sdvo *intel_sdvo)
1298
{
1299
	struct drm_device *dev = intel_sdvo->base.base.dev;
1300 1301
	u8 response[2];

1302 1303 1304 1305 1306
	/* HW Erratum: SDVO Hotplug is broken on all i945G chips, there's noise
	 * on the line. */
	if (IS_I945G(dev) || IS_I945GM(dev))
		return false;

1307 1308
	return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
				    &response, 2) && response[0];
1309 1310
}

1311
static void intel_sdvo_enable_hotplug(struct intel_encoder *encoder)
1312
{
1313
	struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
1314

1315
	intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &intel_sdvo->hotplug_active, 2);
1316 1317
}

1318
static bool
1319
intel_sdvo_multifunc_encoder(struct intel_sdvo *intel_sdvo)
1320
{
1321
	/* Is there more than one type of output? */
1322
	return hweight16(intel_sdvo->caps.output_flags) > 1;
1323 1324
}

1325
static struct edid *
1326
intel_sdvo_get_edid(struct drm_connector *connector)
1327
{
1328 1329
	struct intel_sdvo *sdvo = intel_attached_sdvo(connector);
	return drm_get_edid(connector, &sdvo->ddc);
1330 1331
}

1332 1333 1334 1335
/* Mac mini hack -- use the same DDC as the analog connector */
static struct edid *
intel_sdvo_get_analog_edid(struct drm_connector *connector)
{
1336
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
1337

1338
	return drm_get_edid(connector,
1339 1340
			    intel_gmbus_get_adapter(dev_priv,
						    dev_priv->crt_ddc_pin));
1341 1342
}

1343
static enum drm_connector_status
1344
intel_sdvo_tmds_sink_detect(struct drm_connector *connector)
1345
{
1346
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
1347 1348
	enum drm_connector_status status;
	struct edid *edid;
1349

1350
	edid = intel_sdvo_get_edid(connector);
1351

1352
	if (edid == NULL && intel_sdvo_multifunc_encoder(intel_sdvo)) {
1353
		u8 ddc, saved_ddc = intel_sdvo->ddc_bus;
1354

1355 1356 1357 1358
		/*
		 * Don't use the 1 as the argument of DDC bus switch to get
		 * the EDID. It is used for SDVO SPD ROM.
		 */
1359
		for (ddc = intel_sdvo->ddc_bus >> 1; ddc > 1; ddc >>= 1) {
1360 1361 1362
			intel_sdvo->ddc_bus = ddc;
			edid = intel_sdvo_get_edid(connector);
			if (edid)
1363 1364
				break;
		}
1365 1366 1367 1368 1369 1370
		/*
		 * If we found the EDID on the other bus,
		 * assume that is the correct DDC bus.
		 */
		if (edid == NULL)
			intel_sdvo->ddc_bus = saved_ddc;
1371
	}
1372 1373 1374 1375

	/*
	 * When there is no edid and no monitor is connected with VGA
	 * port, try to use the CRT ddc to read the EDID for DVI-connector.
1376
	 */
1377 1378
	if (edid == NULL)
		edid = intel_sdvo_get_analog_edid(connector);
1379

1380
	status = connector_status_unknown;
1381
	if (edid != NULL) {
1382
		/* DDC bus is shared, match EDID to connector type */
1383 1384
		if (edid->input & DRM_EDID_INPUT_DIGITAL) {
			status = connector_status_connected;
1385 1386 1387 1388
			if (intel_sdvo->is_hdmi) {
				intel_sdvo->has_hdmi_monitor = drm_detect_hdmi_monitor(edid);
				intel_sdvo->has_hdmi_audio = drm_detect_monitor_audio(edid);
			}
1389 1390
		} else
			status = connector_status_disconnected;
1391
		connector->display_info.raw_edid = NULL;
1392 1393
		kfree(edid);
	}
1394 1395 1396

	if (status == connector_status_connected) {
		struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
1397 1398
		if (intel_sdvo_connector->force_audio != HDMI_AUDIO_AUTO)
			intel_sdvo->has_hdmi_audio = (intel_sdvo_connector->force_audio == HDMI_AUDIO_ON);
1399 1400
	}

1401
	return status;
1402 1403
}

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
static bool
intel_sdvo_connector_matches_edid(struct intel_sdvo_connector *sdvo,
				  struct edid *edid)
{
	bool monitor_is_digital = !!(edid->input & DRM_EDID_INPUT_DIGITAL);
	bool connector_is_digital = !!IS_DIGITAL(sdvo);

	DRM_DEBUG_KMS("connector_is_digital? %d, monitor_is_digital? %d\n",
		      connector_is_digital, monitor_is_digital);
	return connector_is_digital == monitor_is_digital;
}

1416
static enum drm_connector_status
1417
intel_sdvo_detect(struct drm_connector *connector, bool force)
1418
{
1419
	uint16_t response;
1420
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
1421
	struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
1422
	enum drm_connector_status ret;
1423

1424
	if (!intel_sdvo_write_cmd(intel_sdvo,
1425
				  SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0))
1426
		return connector_status_unknown;
1427 1428

	/* add 30ms delay when the output type might be TV */
1429
	if (intel_sdvo->caps.output_flags & SDVO_TV_MASK)
1430
		msleep(30);
1431

1432 1433
	if (!intel_sdvo_read_response(intel_sdvo, &response, 2))
		return connector_status_unknown;
1434

1435 1436 1437
	DRM_DEBUG_KMS("SDVO response %d %d [%x]\n",
		      response & 0xff, response >> 8,
		      intel_sdvo_connector->output_flag);
1438

1439
	if (response == 0)
1440
		return connector_status_disconnected;
1441

1442
	intel_sdvo->attached_output = response;
1443

1444 1445 1446
	intel_sdvo->has_hdmi_monitor = false;
	intel_sdvo->has_hdmi_audio = false;

1447
	if ((intel_sdvo_connector->output_flag & response) == 0)
1448
		ret = connector_status_disconnected;
1449
	else if (IS_TMDS(intel_sdvo_connector))
1450
		ret = intel_sdvo_tmds_sink_detect(connector);
1451 1452 1453 1454 1455 1456 1457 1458
	else {
		struct edid *edid;

		/* if we have an edid check it matches the connection */
		edid = intel_sdvo_get_edid(connector);
		if (edid == NULL)
			edid = intel_sdvo_get_analog_edid(connector);
		if (edid != NULL) {
1459 1460
			if (intel_sdvo_connector_matches_edid(intel_sdvo_connector,
							      edid))
1461
				ret = connector_status_connected;
1462 1463 1464
			else
				ret = connector_status_disconnected;

1465 1466 1467 1468 1469
			connector->display_info.raw_edid = NULL;
			kfree(edid);
		} else
			ret = connector_status_connected;
	}
1470 1471 1472

	/* May update encoder flag for like clock for SDVO TV, etc.*/
	if (ret == connector_status_connected) {
1473 1474 1475
		intel_sdvo->is_tv = false;
		intel_sdvo->is_lvds = false;
		intel_sdvo->base.needs_tv_clock = false;
1476 1477

		if (response & SDVO_TV_MASK) {
1478 1479
			intel_sdvo->is_tv = true;
			intel_sdvo->base.needs_tv_clock = true;
1480 1481
		}
		if (response & SDVO_LVDS_MASK)
1482
			intel_sdvo->is_lvds = intel_sdvo->sdvo_lvds_fixed_mode != NULL;
1483
	}
1484 1485

	return ret;
1486 1487
}

1488
static void intel_sdvo_get_ddc_modes(struct drm_connector *connector)
1489
{
1490
	struct edid *edid;
1491 1492

	/* set the bus switch and get the modes */
1493
	edid = intel_sdvo_get_edid(connector);
1494

1495 1496 1497 1498 1499
	/*
	 * Mac mini hack.  On this device, the DVI-I connector shares one DDC
	 * link between analog and digital outputs. So, if the regular SDVO
	 * DDC fails, check to see if the analog output is disconnected, in
	 * which case we'll look there for the digital DDC data.
1500
	 */
1501 1502 1503
	if (edid == NULL)
		edid = intel_sdvo_get_analog_edid(connector);

1504
	if (edid != NULL) {
1505 1506
		if (intel_sdvo_connector_matches_edid(to_intel_sdvo_connector(connector),
						      edid)) {
1507 1508 1509
			drm_mode_connector_update_edid_property(connector, edid);
			drm_add_edid_modes(connector, edid);
		}
1510

1511 1512
		connector->display_info.raw_edid = NULL;
		kfree(edid);
1513 1514 1515 1516 1517 1518 1519 1520
	}
}

/*
 * Set of SDVO TV modes.
 * Note!  This is in reply order (see loop in get_tv_modes).
 * XXX: all 60Hz refresh?
 */
1521
static const struct drm_display_mode sdvo_tv_modes[] = {
1522 1523
	{ DRM_MODE("320x200", DRM_MODE_TYPE_DRIVER, 5815, 320, 321, 384,
		   416, 0, 200, 201, 232, 233, 0,
1524
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1525 1526
	{ DRM_MODE("320x240", DRM_MODE_TYPE_DRIVER, 6814, 320, 321, 384,
		   416, 0, 240, 241, 272, 273, 0,
1527
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1528 1529
	{ DRM_MODE("400x300", DRM_MODE_TYPE_DRIVER, 9910, 400, 401, 464,
		   496, 0, 300, 301, 332, 333, 0,
1530
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1531 1532
	{ DRM_MODE("640x350", DRM_MODE_TYPE_DRIVER, 16913, 640, 641, 704,
		   736, 0, 350, 351, 382, 383, 0,
1533
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1534 1535
	{ DRM_MODE("640x400", DRM_MODE_TYPE_DRIVER, 19121, 640, 641, 704,
		   736, 0, 400, 401, 432, 433, 0,
1536
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1537 1538
	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 22654, 640, 641, 704,
		   736, 0, 480, 481, 512, 513, 0,
1539
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1540 1541
	{ DRM_MODE("704x480", DRM_MODE_TYPE_DRIVER, 24624, 704, 705, 768,
		   800, 0, 480, 481, 512, 513, 0,
1542
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1543 1544
	{ DRM_MODE("704x576", DRM_MODE_TYPE_DRIVER, 29232, 704, 705, 768,
		   800, 0, 576, 577, 608, 609, 0,
1545
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1546 1547
	{ DRM_MODE("720x350", DRM_MODE_TYPE_DRIVER, 18751, 720, 721, 784,
		   816, 0, 350, 351, 382, 383, 0,
1548
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1549 1550
	{ DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 21199, 720, 721, 784,
		   816, 0, 400, 401, 432, 433, 0,
1551
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1552 1553
	{ DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 25116, 720, 721, 784,
		   816, 0, 480, 481, 512, 513, 0,
1554
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1555 1556
	{ DRM_MODE("720x540", DRM_MODE_TYPE_DRIVER, 28054, 720, 721, 784,
		   816, 0, 540, 541, 572, 573, 0,
1557
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1558 1559
	{ DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 29816, 720, 721, 784,
		   816, 0, 576, 577, 608, 609, 0,
1560
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1561 1562
	{ DRM_MODE("768x576", DRM_MODE_TYPE_DRIVER, 31570, 768, 769, 832,
		   864, 0, 576, 577, 608, 609, 0,
1563
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1564 1565
	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 34030, 800, 801, 864,
		   896, 0, 600, 601, 632, 633, 0,
1566
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1567 1568
	{ DRM_MODE("832x624", DRM_MODE_TYPE_DRIVER, 36581, 832, 833, 896,
		   928, 0, 624, 625, 656, 657, 0,
1569
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1570 1571
	{ DRM_MODE("920x766", DRM_MODE_TYPE_DRIVER, 48707, 920, 921, 984,
		   1016, 0, 766, 767, 798, 799, 0,
1572
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1573 1574
	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 53827, 1024, 1025, 1088,
		   1120, 0, 768, 769, 800, 801, 0,
1575
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
1576 1577
	{ DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 87265, 1280, 1281, 1344,
		   1376, 0, 1024, 1025, 1056, 1057, 0,
1578 1579 1580 1581 1582
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
};

static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
{
1583
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
1584
	struct intel_sdvo_sdtv_resolution_request tv_res;
1585 1586
	uint32_t reply = 0, format_map = 0;
	int i;
1587 1588 1589 1590

	/* Read the list of supported input resolutions for the selected TV
	 * format.
	 */
1591
	format_map = 1 << intel_sdvo->tv_format_index;
1592
	memcpy(&tv_res, &format_map,
1593
	       min(sizeof(format_map), sizeof(struct intel_sdvo_sdtv_resolution_request)));
1594

1595 1596
	if (!intel_sdvo_set_target_output(intel_sdvo, intel_sdvo->attached_output))
		return;
1597

1598
	BUILD_BUG_ON(sizeof(tv_res) != 3);
1599 1600
	if (!intel_sdvo_write_cmd(intel_sdvo,
				  SDVO_CMD_GET_SDTV_RESOLUTION_SUPPORT,
1601 1602 1603
				  &tv_res, sizeof(tv_res)))
		return;
	if (!intel_sdvo_read_response(intel_sdvo, &reply, 3))
1604 1605 1606
		return;

	for (i = 0; i < ARRAY_SIZE(sdvo_tv_modes); i++)
1607 1608 1609
		if (reply & (1 << i)) {
			struct drm_display_mode *nmode;
			nmode = drm_mode_duplicate(connector->dev,
1610
						   &sdvo_tv_modes[i]);
1611 1612 1613
			if (nmode)
				drm_mode_probed_add(connector, nmode);
		}
1614 1615
}

1616 1617
static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
{
1618
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
1619
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
1620
	struct drm_display_mode *newmode;
1621 1622 1623 1624 1625 1626

	/*
	 * Attempt to get the mode list from DDC.
	 * Assume that the preferred modes are
	 * arranged in priority order.
	 */
1627
	intel_ddc_get_modes(connector, intel_sdvo->i2c);
1628
	if (list_empty(&connector->probed_modes) == false)
1629
		goto end;
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641

	/* Fetch modes from VBT */
	if (dev_priv->sdvo_lvds_vbt_mode != NULL) {
		newmode = drm_mode_duplicate(connector->dev,
					     dev_priv->sdvo_lvds_vbt_mode);
		if (newmode != NULL) {
			/* Guarantee the mode is preferred */
			newmode->type = (DRM_MODE_TYPE_PREFERRED |
					 DRM_MODE_TYPE_DRIVER);
			drm_mode_probed_add(connector, newmode);
		}
	}
1642 1643 1644 1645

end:
	list_for_each_entry(newmode, &connector->probed_modes, head) {
		if (newmode->type & DRM_MODE_TYPE_PREFERRED) {
1646
			intel_sdvo->sdvo_lvds_fixed_mode =
1647
				drm_mode_duplicate(connector->dev, newmode);
1648

1649
			intel_sdvo->is_lvds = true;
1650 1651 1652 1653
			break;
		}
	}

1654 1655
}

1656 1657
static int intel_sdvo_get_modes(struct drm_connector *connector)
{
1658
	struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
1659

1660
	if (IS_TV(intel_sdvo_connector))
1661
		intel_sdvo_get_tv_modes(connector);
1662
	else if (IS_LVDS(intel_sdvo_connector))
1663
		intel_sdvo_get_lvds_modes(connector);
1664 1665 1666
	else
		intel_sdvo_get_ddc_modes(connector);

1667
	return !list_empty(&connector->probed_modes);
1668 1669
}

1670 1671
static void
intel_sdvo_destroy_enhance_property(struct drm_connector *connector)
1672
{
1673
	struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
1674 1675
	struct drm_device *dev = connector->dev;

1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
	if (intel_sdvo_connector->left)
		drm_property_destroy(dev, intel_sdvo_connector->left);
	if (intel_sdvo_connector->right)
		drm_property_destroy(dev, intel_sdvo_connector->right);
	if (intel_sdvo_connector->top)
		drm_property_destroy(dev, intel_sdvo_connector->top);
	if (intel_sdvo_connector->bottom)
		drm_property_destroy(dev, intel_sdvo_connector->bottom);
	if (intel_sdvo_connector->hpos)
		drm_property_destroy(dev, intel_sdvo_connector->hpos);
	if (intel_sdvo_connector->vpos)
		drm_property_destroy(dev, intel_sdvo_connector->vpos);
	if (intel_sdvo_connector->saturation)
		drm_property_destroy(dev, intel_sdvo_connector->saturation);
	if (intel_sdvo_connector->contrast)
		drm_property_destroy(dev, intel_sdvo_connector->contrast);
	if (intel_sdvo_connector->hue)
		drm_property_destroy(dev, intel_sdvo_connector->hue);
	if (intel_sdvo_connector->sharpness)
		drm_property_destroy(dev, intel_sdvo_connector->sharpness);
	if (intel_sdvo_connector->flicker_filter)
		drm_property_destroy(dev, intel_sdvo_connector->flicker_filter);
	if (intel_sdvo_connector->flicker_filter_2d)
		drm_property_destroy(dev, intel_sdvo_connector->flicker_filter_2d);
	if (intel_sdvo_connector->flicker_filter_adaptive)
		drm_property_destroy(dev, intel_sdvo_connector->flicker_filter_adaptive);
	if (intel_sdvo_connector->tv_luma_filter)
		drm_property_destroy(dev, intel_sdvo_connector->tv_luma_filter);
	if (intel_sdvo_connector->tv_chroma_filter)
		drm_property_destroy(dev, intel_sdvo_connector->tv_chroma_filter);
1706 1707
	if (intel_sdvo_connector->dot_crawl)
		drm_property_destroy(dev, intel_sdvo_connector->dot_crawl);
1708 1709
	if (intel_sdvo_connector->brightness)
		drm_property_destroy(dev, intel_sdvo_connector->brightness);
1710 1711
}

1712 1713
static void intel_sdvo_destroy(struct drm_connector *connector)
{
1714
	struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
1715

1716
	if (intel_sdvo_connector->tv_format)
1717
		drm_property_destroy(connector->dev,
1718
				     intel_sdvo_connector->tv_format);
1719

1720
	intel_sdvo_destroy_enhance_property(connector);
1721 1722
	drm_sysfs_connector_remove(connector);
	drm_connector_cleanup(connector);
1723
	kfree(connector);
1724 1725
}

1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
static bool intel_sdvo_detect_hdmi_audio(struct drm_connector *connector)
{
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
	struct edid *edid;
	bool has_audio = false;

	if (!intel_sdvo->is_hdmi)
		return false;

	edid = intel_sdvo_get_edid(connector);
	if (edid != NULL && edid->input & DRM_EDID_INPUT_DIGITAL)
		has_audio = drm_detect_monitor_audio(edid);

	return has_audio;
}

1742 1743 1744 1745 1746
static int
intel_sdvo_set_property(struct drm_connector *connector,
			struct drm_property *property,
			uint64_t val)
{
1747
	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
1748
	struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
1749
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
1750
	uint16_t temp_value;
1751 1752
	uint8_t cmd;
	int ret;
1753 1754

	ret = drm_connector_property_set_value(connector, property, val);
1755 1756
	if (ret)
		return ret;
1757

1758
	if (property == dev_priv->force_audio_property) {
1759 1760 1761 1762
		int i = val;
		bool has_audio;

		if (i == intel_sdvo_connector->force_audio)
1763 1764
			return 0;

1765
		intel_sdvo_connector->force_audio = i;
1766

1767
		if (i == HDMI_AUDIO_AUTO)
1768 1769
			has_audio = intel_sdvo_detect_hdmi_audio(connector);
		else
1770
			has_audio = (i == HDMI_AUDIO_ON);
1771

1772
		if (has_audio == intel_sdvo->has_hdmi_audio)
1773 1774
			return 0;

1775
		intel_sdvo->has_hdmi_audio = has_audio;
1776 1777 1778
		goto done;
	}

1779 1780
	if (property == dev_priv->broadcast_rgb_property) {
		if (val == !!intel_sdvo->color_range)
1781 1782
			return 0;

1783
		intel_sdvo->color_range = val ? SDVO_COLOR_RANGE_16_235 : 0;
1784 1785 1786
		goto done;
	}

1787 1788 1789 1790 1791 1792 1793 1794 1795 1796
#define CHECK_PROPERTY(name, NAME) \
	if (intel_sdvo_connector->name == property) { \
		if (intel_sdvo_connector->cur_##name == temp_value) return 0; \
		if (intel_sdvo_connector->max_##name < temp_value) return -EINVAL; \
		cmd = SDVO_CMD_SET_##NAME; \
		intel_sdvo_connector->cur_##name = temp_value; \
		goto set_value; \
	}

	if (property == intel_sdvo_connector->tv_format) {
1797 1798 1799
		if (val >= TV_FORMAT_NUM)
			return -EINVAL;

1800
		if (intel_sdvo->tv_format_index ==
1801
		    intel_sdvo_connector->tv_format_supported[val])
1802
			return 0;
1803

1804
		intel_sdvo->tv_format_index = intel_sdvo_connector->tv_format_supported[val];
1805
		goto done;
1806
	} else if (IS_TV_OR_LVDS(intel_sdvo_connector)) {
1807
		temp_value = val;
1808
		if (intel_sdvo_connector->left == property) {
1809
			drm_connector_property_set_value(connector,
1810
							 intel_sdvo_connector->right, val);
1811
			if (intel_sdvo_connector->left_margin == temp_value)
1812
				return 0;
1813

1814 1815 1816
			intel_sdvo_connector->left_margin = temp_value;
			intel_sdvo_connector->right_margin = temp_value;
			temp_value = intel_sdvo_connector->max_hscan -
1817
				intel_sdvo_connector->left_margin;
1818
			cmd = SDVO_CMD_SET_OVERSCAN_H;
1819 1820
			goto set_value;
		} else if (intel_sdvo_connector->right == property) {
1821
			drm_connector_property_set_value(connector,
1822
							 intel_sdvo_connector->left, val);
1823
			if (intel_sdvo_connector->right_margin == temp_value)
1824
				return 0;
1825

1826 1827 1828 1829
			intel_sdvo_connector->left_margin = temp_value;
			intel_sdvo_connector->right_margin = temp_value;
			temp_value = intel_sdvo_connector->max_hscan -
				intel_sdvo_connector->left_margin;
1830
			cmd = SDVO_CMD_SET_OVERSCAN_H;
1831 1832
			goto set_value;
		} else if (intel_sdvo_connector->top == property) {
1833
			drm_connector_property_set_value(connector,
1834
							 intel_sdvo_connector->bottom, val);
1835
			if (intel_sdvo_connector->top_margin == temp_value)
1836
				return 0;
1837

1838 1839 1840
			intel_sdvo_connector->top_margin = temp_value;
			intel_sdvo_connector->bottom_margin = temp_value;
			temp_value = intel_sdvo_connector->max_vscan -
1841
				intel_sdvo_connector->top_margin;
1842
			cmd = SDVO_CMD_SET_OVERSCAN_V;
1843 1844
			goto set_value;
		} else if (intel_sdvo_connector->bottom == property) {
1845
			drm_connector_property_set_value(connector,
1846
							 intel_sdvo_connector->top, val);
1847
			if (intel_sdvo_connector->bottom_margin == temp_value)
1848 1849
				return 0;

1850 1851 1852
			intel_sdvo_connector->top_margin = temp_value;
			intel_sdvo_connector->bottom_margin = temp_value;
			temp_value = intel_sdvo_connector->max_vscan -
1853
				intel_sdvo_connector->top_margin;
1854
			cmd = SDVO_CMD_SET_OVERSCAN_V;
1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
			goto set_value;
		}
		CHECK_PROPERTY(hpos, HPOS)
		CHECK_PROPERTY(vpos, VPOS)
		CHECK_PROPERTY(saturation, SATURATION)
		CHECK_PROPERTY(contrast, CONTRAST)
		CHECK_PROPERTY(hue, HUE)
		CHECK_PROPERTY(brightness, BRIGHTNESS)
		CHECK_PROPERTY(sharpness, SHARPNESS)
		CHECK_PROPERTY(flicker_filter, FLICKER_FILTER)
		CHECK_PROPERTY(flicker_filter_2d, FLICKER_FILTER_2D)
		CHECK_PROPERTY(flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE)
		CHECK_PROPERTY(tv_chroma_filter, TV_CHROMA_FILTER)
		CHECK_PROPERTY(tv_luma_filter, TV_LUMA_FILTER)
1869
		CHECK_PROPERTY(dot_crawl, DOT_CRAWL)
1870
	}
1871

1872
	return -EINVAL; /* unknown property */
1873

1874 1875 1876
set_value:
	if (!intel_sdvo_set_value(intel_sdvo, cmd, &temp_value, 2))
		return -EIO;
1877 1878


1879
done:
1880 1881
	if (intel_sdvo->base.base.crtc) {
		struct drm_crtc *crtc = intel_sdvo->base.base.crtc;
1882 1883
		intel_set_mode(crtc, &crtc->mode,
			       crtc->x, crtc->y, crtc->fb);
1884 1885
	}

1886
	return 0;
1887
#undef CHECK_PROPERTY
1888 1889
}

1890 1891 1892
static const struct drm_encoder_helper_funcs intel_sdvo_helper_funcs = {
	.mode_fixup = intel_sdvo_mode_fixup,
	.mode_set = intel_sdvo_mode_set,
1893
	.disable = intel_encoder_disable
1894 1895 1896
};

static const struct drm_connector_funcs intel_sdvo_connector_funcs = {
1897
	.dpms = intel_sdvo_dpms,
1898 1899
	.detect = intel_sdvo_detect,
	.fill_modes = drm_helper_probe_single_connector_modes,
1900
	.set_property = intel_sdvo_set_property,
1901 1902 1903 1904 1905 1906
	.destroy = intel_sdvo_destroy,
};

static const struct drm_connector_helper_funcs intel_sdvo_connector_helper_funcs = {
	.get_modes = intel_sdvo_get_modes,
	.mode_valid = intel_sdvo_mode_valid,
1907
	.best_encoder = intel_best_encoder,
1908 1909
};

1910
static void intel_sdvo_enc_destroy(struct drm_encoder *encoder)
1911
{
1912
	struct intel_sdvo *intel_sdvo = to_intel_sdvo(encoder);
1913

1914
	if (intel_sdvo->sdvo_lvds_fixed_mode != NULL)
1915
		drm_mode_destroy(encoder->dev,
1916
				 intel_sdvo->sdvo_lvds_fixed_mode);
1917

1918
	i2c_del_adapter(&intel_sdvo->ddc);
1919
	intel_encoder_destroy(encoder);
1920 1921 1922 1923 1924 1925
}

static const struct drm_encoder_funcs intel_sdvo_enc_funcs = {
	.destroy = intel_sdvo_enc_destroy,
};

1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
static void
intel_sdvo_guess_ddc_bus(struct intel_sdvo *sdvo)
{
	uint16_t mask = 0;
	unsigned int num_bits;

	/* Make a mask of outputs less than or equal to our own priority in the
	 * list.
	 */
	switch (sdvo->controlled_output) {
	case SDVO_OUTPUT_LVDS1:
		mask |= SDVO_OUTPUT_LVDS1;
	case SDVO_OUTPUT_LVDS0:
		mask |= SDVO_OUTPUT_LVDS0;
	case SDVO_OUTPUT_TMDS1:
		mask |= SDVO_OUTPUT_TMDS1;
	case SDVO_OUTPUT_TMDS0:
		mask |= SDVO_OUTPUT_TMDS0;
	case SDVO_OUTPUT_RGB1:
		mask |= SDVO_OUTPUT_RGB1;
	case SDVO_OUTPUT_RGB0:
		mask |= SDVO_OUTPUT_RGB0;
		break;
	}

	/* Count bits to find what number we are in the priority list. */
	mask &= sdvo->caps.output_flags;
	num_bits = hweight16(mask);
	/* If more than 3 outputs, default to DDC bus 3 for now. */
	if (num_bits > 3)
		num_bits = 3;

	/* Corresponds to SDVO_CONTROL_BUS_DDCx */
	sdvo->ddc_bus = 1 << num_bits;
}
1961

1962 1963 1964 1965 1966 1967 1968 1969
/**
 * Choose the appropriate DDC bus for control bus switch command for this
 * SDVO output based on the controlled output.
 *
 * DDC bus number assignment is in a priority order of RGB outputs, then TMDS
 * outputs, then LVDS outputs.
 */
static void
1970
intel_sdvo_select_ddc_bus(struct drm_i915_private *dev_priv,
1971
			  struct intel_sdvo *sdvo, u32 reg)
1972
{
1973
	struct sdvo_device_mapping *mapping;
1974

1975
	if (sdvo->is_sdvob)
1976 1977 1978
		mapping = &(dev_priv->sdvo_mappings[0]);
	else
		mapping = &(dev_priv->sdvo_mappings[1]);
1979

1980 1981 1982 1983
	if (mapping->initialized)
		sdvo->ddc_bus = 1 << ((mapping->ddc_pin & 0xf0) >> 4);
	else
		intel_sdvo_guess_ddc_bus(sdvo);
1984 1985
}

1986 1987 1988 1989 1990
static void
intel_sdvo_select_i2c_bus(struct drm_i915_private *dev_priv,
			  struct intel_sdvo *sdvo, u32 reg)
{
	struct sdvo_device_mapping *mapping;
1991
	u8 pin;
1992

1993
	if (sdvo->is_sdvob)
1994 1995 1996 1997 1998
		mapping = &dev_priv->sdvo_mappings[0];
	else
		mapping = &dev_priv->sdvo_mappings[1];

	pin = GMBUS_PORT_DPB;
1999
	if (mapping->initialized)
2000 2001
		pin = mapping->i2c_pin;

2002 2003
	if (intel_gmbus_is_port_valid(pin)) {
		sdvo->i2c = intel_gmbus_get_adapter(dev_priv, pin);
2004
		intel_gmbus_set_speed(sdvo->i2c, GMBUS_RATE_1MHZ);
2005
		intel_gmbus_force_bit(sdvo->i2c, true);
2006
	} else {
2007
		sdvo->i2c = intel_gmbus_get_adapter(dev_priv, GMBUS_PORT_DPB);
2008
	}
2009 2010
}

2011
static bool
2012
intel_sdvo_is_hdmi_connector(struct intel_sdvo *intel_sdvo, int device)
2013
{
2014
	return intel_sdvo_check_supp_encode(intel_sdvo);
2015 2016
}

2017
static u8
2018
intel_sdvo_get_slave_addr(struct drm_device *dev, struct intel_sdvo *sdvo)
2019 2020 2021 2022
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct sdvo_device_mapping *my_mapping, *other_mapping;

2023
	if (sdvo->is_sdvob) {
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
		my_mapping = &dev_priv->sdvo_mappings[0];
		other_mapping = &dev_priv->sdvo_mappings[1];
	} else {
		my_mapping = &dev_priv->sdvo_mappings[1];
		other_mapping = &dev_priv->sdvo_mappings[0];
	}

	/* If the BIOS described our SDVO device, take advantage of it. */
	if (my_mapping->slave_addr)
		return my_mapping->slave_addr;

	/* If the BIOS only described a different SDVO device, use the
	 * address that it isn't using.
	 */
	if (other_mapping->slave_addr) {
		if (other_mapping->slave_addr == 0x70)
			return 0x72;
		else
			return 0x70;
	}

	/* No SDVO device info is found for another DVO port,
	 * so use mapping assumption we had before BIOS parsing.
	 */
2048
	if (sdvo->is_sdvob)
2049 2050 2051 2052 2053
		return 0x70;
	else
		return 0x72;
}

2054
static void
2055 2056
intel_sdvo_connector_init(struct intel_sdvo_connector *connector,
			  struct intel_sdvo *encoder)
2057
{
2058 2059 2060 2061
	drm_connector_init(encoder->base.base.dev,
			   &connector->base.base,
			   &intel_sdvo_connector_funcs,
			   connector->base.base.connector_type);
2062

2063 2064
	drm_connector_helper_add(&connector->base.base,
				 &intel_sdvo_connector_helper_funcs);
2065

2066
	connector->base.base.interlace_allowed = 1;
2067 2068
	connector->base.base.doublescan_allowed = 0;
	connector->base.base.display_info.subpixel_order = SubPixelHorizontalRGB;
2069

2070 2071
	intel_connector_attach_encoder(&connector->base, &encoder->base);
	drm_sysfs_connector_add(&connector->base.base);
2072
}
2073

2074 2075 2076 2077 2078
static void
intel_sdvo_add_hdmi_properties(struct intel_sdvo_connector *connector)
{
	struct drm_device *dev = connector->base.base.dev;

2079
	intel_attach_force_audio_property(&connector->base.base);
2080 2081
	if (INTEL_INFO(dev)->gen >= 4 && IS_MOBILE(dev))
		intel_attach_broadcast_rgb_property(&connector->base.base);
2082 2083
}

2084
static bool
2085
intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
2086
{
2087
	struct drm_encoder *encoder = &intel_sdvo->base.base;
2088
	struct drm_connector *connector;
2089
	struct intel_encoder *intel_encoder = to_intel_encoder(encoder);
2090
	struct intel_connector *intel_connector;
2091
	struct intel_sdvo_connector *intel_sdvo_connector;
2092

2093 2094
	intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
	if (!intel_sdvo_connector)
2095 2096 2097
		return false;

	if (device == 0) {
2098
		intel_sdvo->controlled_output |= SDVO_OUTPUT_TMDS0;
2099
		intel_sdvo_connector->output_flag = SDVO_OUTPUT_TMDS0;
2100
	} else if (device == 1) {
2101
		intel_sdvo->controlled_output |= SDVO_OUTPUT_TMDS1;
2102
		intel_sdvo_connector->output_flag = SDVO_OUTPUT_TMDS1;
2103 2104
	}

2105
	intel_connector = &intel_sdvo_connector->base;
2106
	connector = &intel_connector->base;
2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
	if (intel_sdvo_supports_hotplug(intel_sdvo) & (1 << device)) {
		connector->polled = DRM_CONNECTOR_POLL_HPD;
		intel_sdvo->hotplug_active[0] |= 1 << device;
		/* Some SDVO devices have one-shot hotplug interrupts.
		 * Ensure that they get re-enabled when an interrupt happens.
		 */
		intel_encoder->hot_plug = intel_sdvo_enable_hotplug;
		intel_sdvo_enable_hotplug(intel_encoder);
	}
	else
		connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
2118 2119 2120
	encoder->encoder_type = DRM_MODE_ENCODER_TMDS;
	connector->connector_type = DRM_MODE_CONNECTOR_DVID;

2121
	if (intel_sdvo_is_hdmi_connector(intel_sdvo, device)) {
2122
		connector->connector_type = DRM_MODE_CONNECTOR_HDMIA;
2123
		intel_sdvo->is_hdmi = true;
2124
	}
2125
	intel_sdvo->base.cloneable = true;
2126

2127
	intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
2128 2129
	if (intel_sdvo->is_hdmi)
		intel_sdvo_add_hdmi_properties(intel_sdvo_connector);
2130 2131 2132 2133 2134

	return true;
}

static bool
2135
intel_sdvo_tv_init(struct intel_sdvo *intel_sdvo, int type)
2136
{
2137 2138 2139 2140
	struct drm_encoder *encoder = &intel_sdvo->base.base;
	struct drm_connector *connector;
	struct intel_connector *intel_connector;
	struct intel_sdvo_connector *intel_sdvo_connector;
2141

2142 2143 2144
	intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
	if (!intel_sdvo_connector)
		return false;
2145

2146
	intel_connector = &intel_sdvo_connector->base;
2147 2148 2149
	connector = &intel_connector->base;
	encoder->encoder_type = DRM_MODE_ENCODER_TVDAC;
	connector->connector_type = DRM_MODE_CONNECTOR_SVIDEO;
2150

2151 2152
	intel_sdvo->controlled_output |= type;
	intel_sdvo_connector->output_flag = type;
2153

2154 2155
	intel_sdvo->is_tv = true;
	intel_sdvo->base.needs_tv_clock = true;
2156
	intel_sdvo->base.cloneable = false;
2157

2158
	intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
2159

2160
	if (!intel_sdvo_tv_create_property(intel_sdvo, intel_sdvo_connector, type))
2161
		goto err;
2162

2163
	if (!intel_sdvo_create_enhance_property(intel_sdvo, intel_sdvo_connector))
2164
		goto err;
2165

2166
	return true;
2167 2168

err:
2169
	intel_sdvo_destroy(connector);
2170
	return false;
2171 2172 2173
}

static bool
2174
intel_sdvo_analog_init(struct intel_sdvo *intel_sdvo, int device)
2175
{
2176 2177 2178 2179
	struct drm_encoder *encoder = &intel_sdvo->base.base;
	struct drm_connector *connector;
	struct intel_connector *intel_connector;
	struct intel_sdvo_connector *intel_sdvo_connector;
2180

2181 2182 2183
	intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
	if (!intel_sdvo_connector)
		return false;
2184

2185
	intel_connector = &intel_sdvo_connector->base;
2186
	connector = &intel_connector->base;
2187
	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
	encoder->encoder_type = DRM_MODE_ENCODER_DAC;
	connector->connector_type = DRM_MODE_CONNECTOR_VGA;

	if (device == 0) {
		intel_sdvo->controlled_output |= SDVO_OUTPUT_RGB0;
		intel_sdvo_connector->output_flag = SDVO_OUTPUT_RGB0;
	} else if (device == 1) {
		intel_sdvo->controlled_output |= SDVO_OUTPUT_RGB1;
		intel_sdvo_connector->output_flag = SDVO_OUTPUT_RGB1;
	}

2199
	intel_sdvo->base.cloneable = true;
2200

2201 2202
	intel_sdvo_connector_init(intel_sdvo_connector,
				  intel_sdvo);
2203
	return true;
2204 2205 2206
}

static bool
2207
intel_sdvo_lvds_init(struct intel_sdvo *intel_sdvo, int device)
2208
{
2209 2210 2211 2212
	struct drm_encoder *encoder = &intel_sdvo->base.base;
	struct drm_connector *connector;
	struct intel_connector *intel_connector;
	struct intel_sdvo_connector *intel_sdvo_connector;
2213

2214 2215 2216
	intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL);
	if (!intel_sdvo_connector)
		return false;
2217

2218 2219
	intel_connector = &intel_sdvo_connector->base;
	connector = &intel_connector->base;
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230
	encoder->encoder_type = DRM_MODE_ENCODER_LVDS;
	connector->connector_type = DRM_MODE_CONNECTOR_LVDS;

	if (device == 0) {
		intel_sdvo->controlled_output |= SDVO_OUTPUT_LVDS0;
		intel_sdvo_connector->output_flag = SDVO_OUTPUT_LVDS0;
	} else if (device == 1) {
		intel_sdvo->controlled_output |= SDVO_OUTPUT_LVDS1;
		intel_sdvo_connector->output_flag = SDVO_OUTPUT_LVDS1;
	}

2231 2232 2233 2234
	/* SDVO LVDS is cloneable because the SDVO encoder does the upscaling,
	 * as opposed to native LVDS, where we upscale with the panel-fitter
	 * (and hence only the native LVDS resolution could be cloned). */
	intel_sdvo->base.cloneable = true;
2235

2236
	intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
2237
	if (!intel_sdvo_create_enhance_property(intel_sdvo, intel_sdvo_connector))
2238 2239 2240 2241 2242
		goto err;

	return true;

err:
2243
	intel_sdvo_destroy(connector);
2244
	return false;
2245 2246 2247
}

static bool
2248
intel_sdvo_output_setup(struct intel_sdvo *intel_sdvo, uint16_t flags)
2249
{
2250 2251 2252
	intel_sdvo->is_tv = false;
	intel_sdvo->base.needs_tv_clock = false;
	intel_sdvo->is_lvds = false;
2253

2254
	/* SDVO requires XXX1 function may not exist unless it has XXX0 function.*/
2255

2256
	if (flags & SDVO_OUTPUT_TMDS0)
2257
		if (!intel_sdvo_dvi_init(intel_sdvo, 0))
2258 2259 2260
			return false;

	if ((flags & SDVO_TMDS_MASK) == SDVO_TMDS_MASK)
2261
		if (!intel_sdvo_dvi_init(intel_sdvo, 1))
2262 2263 2264
			return false;

	/* TV has no XXX1 function block */
2265
	if (flags & SDVO_OUTPUT_SVID0)
2266
		if (!intel_sdvo_tv_init(intel_sdvo, SDVO_OUTPUT_SVID0))
2267 2268 2269
			return false;

	if (flags & SDVO_OUTPUT_CVBS0)
2270
		if (!intel_sdvo_tv_init(intel_sdvo, SDVO_OUTPUT_CVBS0))
2271
			return false;
2272

2273 2274 2275 2276
	if (flags & SDVO_OUTPUT_YPRPB0)
		if (!intel_sdvo_tv_init(intel_sdvo, SDVO_OUTPUT_YPRPB0))
			return false;

2277
	if (flags & SDVO_OUTPUT_RGB0)
2278
		if (!intel_sdvo_analog_init(intel_sdvo, 0))
2279 2280 2281
			return false;

	if ((flags & SDVO_RGB_MASK) == SDVO_RGB_MASK)
2282
		if (!intel_sdvo_analog_init(intel_sdvo, 1))
2283 2284 2285
			return false;

	if (flags & SDVO_OUTPUT_LVDS0)
2286
		if (!intel_sdvo_lvds_init(intel_sdvo, 0))
2287 2288 2289
			return false;

	if ((flags & SDVO_LVDS_MASK) == SDVO_LVDS_MASK)
2290
		if (!intel_sdvo_lvds_init(intel_sdvo, 1))
2291
			return false;
2292

2293
	if ((flags & SDVO_OUTPUT_MASK) == 0) {
2294 2295
		unsigned char bytes[2];

2296 2297
		intel_sdvo->controlled_output = 0;
		memcpy(bytes, &intel_sdvo->caps.output_flags, 2);
2298
		DRM_DEBUG_KMS("%s: Unknown SDVO output type (0x%02x%02x)\n",
2299
			      SDVO_NAME(intel_sdvo),
2300
			      bytes[0], bytes[1]);
2301
		return false;
2302
	}
2303
	intel_sdvo->base.crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
2304

2305
	return true;
2306 2307
}

2308 2309 2310
static bool intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
					  struct intel_sdvo_connector *intel_sdvo_connector,
					  int type)
2311
{
2312
	struct drm_device *dev = intel_sdvo->base.base.dev;
2313 2314 2315
	struct intel_sdvo_tv_format format;
	uint32_t format_map, i;

2316 2317
	if (!intel_sdvo_set_target_output(intel_sdvo, type))
		return false;
2318

2319
	BUILD_BUG_ON(sizeof(format) != 6);
2320 2321 2322 2323
	if (!intel_sdvo_get_value(intel_sdvo,
				  SDVO_CMD_GET_SUPPORTED_TV_FORMATS,
				  &format, sizeof(format)))
		return false;
2324

2325
	memcpy(&format_map, &format, min(sizeof(format_map), sizeof(format)));
2326 2327

	if (format_map == 0)
2328
		return false;
2329

2330
	intel_sdvo_connector->format_supported_num = 0;
2331
	for (i = 0 ; i < TV_FORMAT_NUM; i++)
2332 2333
		if (format_map & (1 << i))
			intel_sdvo_connector->tv_format_supported[intel_sdvo_connector->format_supported_num++] = i;
2334 2335


2336
	intel_sdvo_connector->tv_format =
2337 2338
			drm_property_create(dev, DRM_MODE_PROP_ENUM,
					    "mode", intel_sdvo_connector->format_supported_num);
2339
	if (!intel_sdvo_connector->tv_format)
2340
		return false;
2341

2342
	for (i = 0; i < intel_sdvo_connector->format_supported_num; i++)
2343
		drm_property_add_enum(
2344
				intel_sdvo_connector->tv_format, i,
2345
				i, tv_format_names[intel_sdvo_connector->tv_format_supported[i]]);
2346

2347
	intel_sdvo->tv_format_index = intel_sdvo_connector->tv_format_supported[0];
2348
	drm_connector_attach_property(&intel_sdvo_connector->base.base,
2349
				      intel_sdvo_connector->tv_format, 0);
2350
	return true;
2351 2352 2353

}

2354 2355 2356 2357 2358 2359 2360 2361
#define ENHANCEMENT(name, NAME) do { \
	if (enhancements.name) { \
		if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_MAX_##NAME, &data_value, 4) || \
		    !intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_##NAME, &response, 2)) \
			return false; \
		intel_sdvo_connector->max_##name = data_value[0]; \
		intel_sdvo_connector->cur_##name = response; \
		intel_sdvo_connector->name = \
2362
			drm_property_create_range(dev, 0, #name, 0, data_value[0]); \
2363 2364 2365 2366 2367 2368 2369
		if (!intel_sdvo_connector->name) return false; \
		drm_connector_attach_property(connector, \
					      intel_sdvo_connector->name, \
					      intel_sdvo_connector->cur_##name); \
		DRM_DEBUG_KMS(#name ": max %d, default %d, current %d\n", \
			      data_value[0], data_value[1], response); \
	} \
2370
} while (0)
2371 2372 2373 2374 2375

static bool
intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
				      struct intel_sdvo_connector *intel_sdvo_connector,
				      struct intel_sdvo_enhancements_reply enhancements)
2376
{
2377
	struct drm_device *dev = intel_sdvo->base.base.dev;
2378
	struct drm_connector *connector = &intel_sdvo_connector->base.base;
2379 2380
	uint16_t response, data_value[2];

2381 2382 2383 2384 2385 2386
	/* when horizontal overscan is supported, Add the left/right  property */
	if (enhancements.overscan_h) {
		if (!intel_sdvo_get_value(intel_sdvo,
					  SDVO_CMD_GET_MAX_OVERSCAN_H,
					  &data_value, 4))
			return false;
2387

2388 2389 2390 2391
		if (!intel_sdvo_get_value(intel_sdvo,
					  SDVO_CMD_GET_OVERSCAN_H,
					  &response, 2))
			return false;
2392

2393 2394 2395 2396
		intel_sdvo_connector->max_hscan = data_value[0];
		intel_sdvo_connector->left_margin = data_value[0] - response;
		intel_sdvo_connector->right_margin = intel_sdvo_connector->left_margin;
		intel_sdvo_connector->left =
2397
			drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]);
2398 2399
		if (!intel_sdvo_connector->left)
			return false;
2400

2401 2402 2403
		drm_connector_attach_property(connector,
					      intel_sdvo_connector->left,
					      intel_sdvo_connector->left_margin);
2404

2405
		intel_sdvo_connector->right =
2406
			drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]);
2407 2408
		if (!intel_sdvo_connector->right)
			return false;
2409

2410 2411 2412 2413 2414 2415 2416
		drm_connector_attach_property(connector,
					      intel_sdvo_connector->right,
					      intel_sdvo_connector->right_margin);
		DRM_DEBUG_KMS("h_overscan: max %d, "
			      "default %d, current %d\n",
			      data_value[0], data_value[1], response);
	}
2417

2418 2419 2420 2421 2422
	if (enhancements.overscan_v) {
		if (!intel_sdvo_get_value(intel_sdvo,
					  SDVO_CMD_GET_MAX_OVERSCAN_V,
					  &data_value, 4))
			return false;
2423

2424 2425 2426 2427
		if (!intel_sdvo_get_value(intel_sdvo,
					  SDVO_CMD_GET_OVERSCAN_V,
					  &response, 2))
			return false;
2428

2429 2430 2431 2432
		intel_sdvo_connector->max_vscan = data_value[0];
		intel_sdvo_connector->top_margin = data_value[0] - response;
		intel_sdvo_connector->bottom_margin = intel_sdvo_connector->top_margin;
		intel_sdvo_connector->top =
2433 2434
			drm_property_create_range(dev, 0,
					    "top_margin", 0, data_value[0]);
2435 2436
		if (!intel_sdvo_connector->top)
			return false;
2437

2438 2439 2440
		drm_connector_attach_property(connector,
					      intel_sdvo_connector->top,
					      intel_sdvo_connector->top_margin);
2441

2442
		intel_sdvo_connector->bottom =
2443 2444
			drm_property_create_range(dev, 0,
					    "bottom_margin", 0, data_value[0]);
2445 2446
		if (!intel_sdvo_connector->bottom)
			return false;
2447

2448 2449 2450 2451 2452 2453 2454
		drm_connector_attach_property(connector,
					      intel_sdvo_connector->bottom,
					      intel_sdvo_connector->bottom_margin);
		DRM_DEBUG_KMS("v_overscan: max %d, "
			      "default %d, current %d\n",
			      data_value[0], data_value[1], response);
	}
2455

2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
	ENHANCEMENT(hpos, HPOS);
	ENHANCEMENT(vpos, VPOS);
	ENHANCEMENT(saturation, SATURATION);
	ENHANCEMENT(contrast, CONTRAST);
	ENHANCEMENT(hue, HUE);
	ENHANCEMENT(sharpness, SHARPNESS);
	ENHANCEMENT(brightness, BRIGHTNESS);
	ENHANCEMENT(flicker_filter, FLICKER_FILTER);
	ENHANCEMENT(flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE);
	ENHANCEMENT(flicker_filter_2d, FLICKER_FILTER_2D);
	ENHANCEMENT(tv_chroma_filter, TV_CHROMA_FILTER);
	ENHANCEMENT(tv_luma_filter, TV_LUMA_FILTER);
2468

2469 2470 2471 2472 2473 2474 2475
	if (enhancements.dot_crawl) {
		if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_DOT_CRAWL, &response, 2))
			return false;

		intel_sdvo_connector->max_dot_crawl = 1;
		intel_sdvo_connector->cur_dot_crawl = response & 0x1;
		intel_sdvo_connector->dot_crawl =
2476
			drm_property_create_range(dev, 0, "dot_crawl", 0, 1);
2477 2478 2479 2480 2481 2482 2483 2484 2485
		if (!intel_sdvo_connector->dot_crawl)
			return false;

		drm_connector_attach_property(connector,
					      intel_sdvo_connector->dot_crawl,
					      intel_sdvo_connector->cur_dot_crawl);
		DRM_DEBUG_KMS("dot crawl: current %d\n", response);
	}

2486 2487
	return true;
}
2488

2489 2490 2491 2492 2493
static bool
intel_sdvo_create_enhance_property_lvds(struct intel_sdvo *intel_sdvo,
					struct intel_sdvo_connector *intel_sdvo_connector,
					struct intel_sdvo_enhancements_reply enhancements)
{
2494
	struct drm_device *dev = intel_sdvo->base.base.dev;
2495 2496
	struct drm_connector *connector = &intel_sdvo_connector->base.base;
	uint16_t response, data_value[2];
2497

2498
	ENHANCEMENT(brightness, BRIGHTNESS);
2499

2500 2501 2502
	return true;
}
#undef ENHANCEMENT
2503

2504 2505 2506 2507 2508 2509 2510
static bool intel_sdvo_create_enhance_property(struct intel_sdvo *intel_sdvo,
					       struct intel_sdvo_connector *intel_sdvo_connector)
{
	union {
		struct intel_sdvo_enhancements_reply reply;
		uint16_t response;
	} enhancements;
2511

2512 2513
	BUILD_BUG_ON(sizeof(enhancements) != 2);

2514 2515 2516 2517
	enhancements.response = 0;
	intel_sdvo_get_value(intel_sdvo,
			     SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS,
			     &enhancements, sizeof(enhancements));
2518 2519 2520
	if (enhancements.response == 0) {
		DRM_DEBUG_KMS("No enhancement is supported\n");
		return true;
2521
	}
2522

2523 2524
	if (IS_TV(intel_sdvo_connector))
		return intel_sdvo_create_enhance_property_tv(intel_sdvo, intel_sdvo_connector, enhancements.reply);
2525
	else if (IS_LVDS(intel_sdvo_connector))
2526 2527 2528
		return intel_sdvo_create_enhance_property_lvds(intel_sdvo, intel_sdvo_connector, enhancements.reply);
	else
		return true;
2529 2530 2531 2532 2533 2534 2535
}

static int intel_sdvo_ddc_proxy_xfer(struct i2c_adapter *adapter,
				     struct i2c_msg *msgs,
				     int num)
{
	struct intel_sdvo *sdvo = adapter->algo_data;
2536

2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565
	if (!intel_sdvo_set_control_bus_switch(sdvo, sdvo->ddc_bus))
		return -EIO;

	return sdvo->i2c->algo->master_xfer(sdvo->i2c, msgs, num);
}

static u32 intel_sdvo_ddc_proxy_func(struct i2c_adapter *adapter)
{
	struct intel_sdvo *sdvo = adapter->algo_data;
	return sdvo->i2c->algo->functionality(sdvo->i2c);
}

static const struct i2c_algorithm intel_sdvo_ddc_proxy = {
	.master_xfer	= intel_sdvo_ddc_proxy_xfer,
	.functionality	= intel_sdvo_ddc_proxy_func
};

static bool
intel_sdvo_init_ddc_proxy(struct intel_sdvo *sdvo,
			  struct drm_device *dev)
{
	sdvo->ddc.owner = THIS_MODULE;
	sdvo->ddc.class = I2C_CLASS_DDC;
	snprintf(sdvo->ddc.name, I2C_NAME_SIZE, "SDVO DDC proxy");
	sdvo->ddc.dev.parent = &dev->pdev->dev;
	sdvo->ddc.algo_data = sdvo;
	sdvo->ddc.algo = &intel_sdvo_ddc_proxy;

	return i2c_add_adapter(&sdvo->ddc) == 0;
2566 2567
}

2568
bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
2569
{
2570
	struct drm_i915_private *dev_priv = dev->dev_private;
2571
	struct intel_encoder *intel_encoder;
2572
	struct intel_sdvo *intel_sdvo;
2573
	u32 hotplug_mask;
2574 2575
	int i;

2576 2577
	intel_sdvo = kzalloc(sizeof(struct intel_sdvo), GFP_KERNEL);
	if (!intel_sdvo)
2578
		return false;
2579

2580
	intel_sdvo->sdvo_reg = sdvo_reg;
2581 2582
	intel_sdvo->is_sdvob = is_sdvob;
	intel_sdvo->slave_addr = intel_sdvo_get_slave_addr(dev, intel_sdvo) >> 1;
2583
	intel_sdvo_select_i2c_bus(dev_priv, intel_sdvo, sdvo_reg);
2584 2585 2586 2587 2588
	if (!intel_sdvo_init_ddc_proxy(intel_sdvo, dev)) {
		kfree(intel_sdvo);
		return false;
	}

2589
	/* encoder type will be decided later */
2590
	intel_encoder = &intel_sdvo->base;
2591
	intel_encoder->type = INTEL_OUTPUT_SDVO;
2592
	drm_encoder_init(dev, &intel_encoder->base, &intel_sdvo_enc_funcs, 0);
2593 2594 2595

	/* Read the regs to test if we can talk to the device */
	for (i = 0; i < 0x40; i++) {
2596 2597 2598
		u8 byte;

		if (!intel_sdvo_read_byte(intel_sdvo, i, &byte)) {
2599 2600
			DRM_DEBUG_KMS("No SDVO device found on %s\n",
				      SDVO_NAME(intel_sdvo));
2601
			goto err;
2602 2603 2604
		}
	}

2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616
	hotplug_mask = 0;
	if (IS_G4X(dev)) {
		hotplug_mask = intel_sdvo->is_sdvob ?
			SDVOB_HOTPLUG_INT_STATUS_G4X : SDVOC_HOTPLUG_INT_STATUS_G4X;
	} else if (IS_GEN4(dev)) {
		hotplug_mask = intel_sdvo->is_sdvob ?
			SDVOB_HOTPLUG_INT_STATUS_I965 : SDVOC_HOTPLUG_INT_STATUS_I965;
	} else {
		hotplug_mask = intel_sdvo->is_sdvob ?
			SDVOB_HOTPLUG_INT_STATUS_I915 : SDVOC_HOTPLUG_INT_STATUS_I915;
	}
	dev_priv->hotplug_supported_mask |= hotplug_mask;
2617

2618
	drm_encoder_helper_add(&intel_encoder->base, &intel_sdvo_helper_funcs);
2619

2620 2621 2622
	intel_encoder->disable = intel_disable_sdvo;
	intel_encoder->enable = intel_enable_sdvo;

2623
	/* In default case sdvo lvds is false */
2624
	if (!intel_sdvo_get_capabilities(intel_sdvo, &intel_sdvo->caps))
2625
		goto err;
2626

2627 2628 2629 2630 2631 2632 2633 2634
	/* Set up hotplug command - note paranoia about contents of reply.
	 * We assume that the hardware is in a sane state, and only touch
	 * the bits we think we understand.
	 */
	intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG,
			     &intel_sdvo->hotplug_active, 2);
	intel_sdvo->hotplug_active[0] &= ~0x3;

2635 2636
	if (intel_sdvo_output_setup(intel_sdvo,
				    intel_sdvo->caps.output_flags) != true) {
2637 2638
		DRM_DEBUG_KMS("SDVO output failed to setup on %s\n",
			      SDVO_NAME(intel_sdvo));
2639
		goto err;
2640 2641
	}

2642
	intel_sdvo_select_ddc_bus(dev_priv, intel_sdvo, sdvo_reg);
2643

2644
	/* Set the input timing to the screen. Assume always input 0. */
2645
	if (!intel_sdvo_set_target_input(intel_sdvo))
2646
		goto err;
2647

2648 2649 2650
	if (!intel_sdvo_get_input_pixel_clock_range(intel_sdvo,
						    &intel_sdvo->pixel_clock_min,
						    &intel_sdvo->pixel_clock_max))
2651
		goto err;
2652

2653
	DRM_DEBUG_KMS("%s device VID/DID: %02X:%02X.%02X, "
2654 2655 2656
			"clock range %dMHz - %dMHz, "
			"input 1: %c, input 2: %c, "
			"output 1: %c, output 2: %c\n",
2657 2658 2659 2660 2661 2662 2663
			SDVO_NAME(intel_sdvo),
			intel_sdvo->caps.vendor_id, intel_sdvo->caps.device_id,
			intel_sdvo->caps.device_rev_id,
			intel_sdvo->pixel_clock_min / 1000,
			intel_sdvo->pixel_clock_max / 1000,
			(intel_sdvo->caps.sdvo_inputs_mask & 0x1) ? 'Y' : 'N',
			(intel_sdvo->caps.sdvo_inputs_mask & 0x2) ? 'Y' : 'N',
2664
			/* check currently supported outputs */
2665
			intel_sdvo->caps.output_flags &
2666
			(SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_RGB0) ? 'Y' : 'N',
2667
			intel_sdvo->caps.output_flags &
2668
			(SDVO_OUTPUT_TMDS1 | SDVO_OUTPUT_RGB1) ? 'Y' : 'N');
2669
	return true;
2670

2671
err:
2672
	drm_encoder_cleanup(&intel_encoder->base);
2673
	i2c_del_adapter(&intel_sdvo->ddc);
2674
	kfree(intel_sdvo);
2675

2676
	return false;
2677
}
新手
引导
客服 返回
顶部