aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/gpu/drm/i915/intel_sdvo.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/gpu/drm/i915/intel_sdvo.c')
-rw-r--r--drivers/gpu/drm/i915/intel_sdvo.c849
1 files changed, 478 insertions, 371 deletions
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 083bec2e50f9..87d953664cb0 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -26,6 +26,7 @@
26 * Eric Anholt <eric@anholt.net> 26 * Eric Anholt <eric@anholt.net>
27 */ 27 */
28#include <linux/i2c.h> 28#include <linux/i2c.h>
29#include <linux/slab.h>
29#include <linux/delay.h> 30#include <linux/delay.h>
30#include "drmP.h" 31#include "drmP.h"
31#include "drm.h" 32#include "drm.h"
@@ -35,8 +36,7 @@
35#include "i915_drm.h" 36#include "i915_drm.h"
36#include "i915_drv.h" 37#include "i915_drv.h"
37#include "intel_sdvo_regs.h" 38#include "intel_sdvo_regs.h"
38 39#include <linux/dmi.h>
39#undef SDVO_DEBUG
40 40
41static char *tv_format_names[] = { 41static char *tv_format_names[] = {
42 "NTSC_M" , "NTSC_J" , "NTSC_443", 42 "NTSC_M" , "NTSC_J" , "NTSC_443",
@@ -54,7 +54,7 @@ struct intel_sdvo_priv {
54 u8 slave_addr; 54 u8 slave_addr;
55 55
56 /* Register for the SDVO device: SDVOB or SDVOC */ 56 /* Register for the SDVO device: SDVOB or SDVOC */
57 int output_device; 57 int sdvo_reg;
58 58
59 /* Active outputs controlled by this SDVO output */ 59 /* Active outputs controlled by this SDVO output */
60 uint16_t controlled_output; 60 uint16_t controlled_output;
@@ -124,7 +124,7 @@ struct intel_sdvo_priv {
124 */ 124 */
125 struct intel_sdvo_encode encode; 125 struct intel_sdvo_encode encode;
126 126
127 /* DDC bus used by this SDVO output */ 127 /* DDC bus used by this SDVO encoder */
128 uint8_t ddc_bus; 128 uint8_t ddc_bus;
129 129
130 /* Mac mini hack -- use the same DDC as the analog connector */ 130 /* Mac mini hack -- use the same DDC as the analog connector */
@@ -162,22 +162,22 @@ struct intel_sdvo_priv {
162}; 162};
163 163
164static bool 164static bool
165intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags); 165intel_sdvo_output_setup(struct intel_encoder *intel_encoder, uint16_t flags);
166 166
167/** 167/**
168 * Writes the SDVOB or SDVOC with the given value, but always writes both 168 * Writes the SDVOB or SDVOC with the given value, but always writes both
169 * SDVOB and SDVOC to work around apparent hardware issues (according to 169 * SDVOB and SDVOC to work around apparent hardware issues (according to
170 * comments in the BIOS). 170 * comments in the BIOS).
171 */ 171 */
172static void intel_sdvo_write_sdvox(struct intel_output *intel_output, u32 val) 172static void intel_sdvo_write_sdvox(struct intel_encoder *intel_encoder, u32 val)
173{ 173{
174 struct drm_device *dev = intel_output->base.dev; 174 struct drm_device *dev = intel_encoder->base.dev;
175 struct drm_i915_private *dev_priv = dev->dev_private; 175 struct drm_i915_private *dev_priv = dev->dev_private;
176 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 176 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
177 u32 bval = val, cval = val; 177 u32 bval = val, cval = val;
178 int i; 178 int i;
179 179
180 if (sdvo_priv->output_device == SDVOB) { 180 if (sdvo_priv->sdvo_reg == SDVOB) {
181 cval = I915_READ(SDVOC); 181 cval = I915_READ(SDVOC);
182 } else { 182 } else {
183 bval = I915_READ(SDVOB); 183 bval = I915_READ(SDVOB);
@@ -196,10 +196,10 @@ static void intel_sdvo_write_sdvox(struct intel_output *intel_output, u32 val)
196 } 196 }
197} 197}
198 198
199static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr, 199static bool intel_sdvo_read_byte(struct intel_encoder *intel_encoder, u8 addr,
200 u8 *ch) 200 u8 *ch)
201{ 201{
202 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 202 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
203 u8 out_buf[2]; 203 u8 out_buf[2];
204 u8 buf[2]; 204 u8 buf[2];
205 int ret; 205 int ret;
@@ -222,7 +222,7 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
222 out_buf[0] = addr; 222 out_buf[0] = addr;
223 out_buf[1] = 0; 223 out_buf[1] = 0;
224 224
225 if ((ret = i2c_transfer(intel_output->i2c_bus, msgs, 2)) == 2) 225 if ((ret = i2c_transfer(intel_encoder->i2c_bus, msgs, 2)) == 2)
226 { 226 {
227 *ch = buf[0]; 227 *ch = buf[0];
228 return true; 228 return true;
@@ -232,10 +232,10 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
232 return false; 232 return false;
233} 233}
234 234
235static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr, 235static bool intel_sdvo_write_byte(struct intel_encoder *intel_encoder, int addr,
236 u8 ch) 236 u8 ch)
237{ 237{
238 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 238 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
239 u8 out_buf[2]; 239 u8 out_buf[2];
240 struct i2c_msg msgs[] = { 240 struct i2c_msg msgs[] = {
241 { 241 {
@@ -249,7 +249,7 @@ static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr,
249 out_buf[0] = addr; 249 out_buf[0] = addr;
250 out_buf[1] = ch; 250 out_buf[1] = ch;
251 251
252 if (i2c_transfer(intel_output->i2c_bus, msgs, 1) == 1) 252 if (i2c_transfer(intel_encoder->i2c_bus, msgs, 1) == 1)
253 { 253 {
254 return true; 254 return true;
255 } 255 }
@@ -353,14 +353,13 @@ static const struct _sdvo_cmd_name {
353 SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_DATA), 353 SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_DATA),
354}; 354};
355 355
356#define SDVO_NAME(dev_priv) ((dev_priv)->output_device == SDVOB ? "SDVOB" : "SDVOC") 356#define SDVO_NAME(dev_priv) ((dev_priv)->sdvo_reg == SDVOB ? "SDVOB" : "SDVOC")
357#define SDVO_PRIV(output) ((struct intel_sdvo_priv *) (output)->dev_priv) 357#define SDVO_PRIV(encoder) ((struct intel_sdvo_priv *) (encoder)->dev_priv)
358 358
359#ifdef SDVO_DEBUG 359static void intel_sdvo_debug_write(struct intel_encoder *intel_encoder, u8 cmd,
360static void intel_sdvo_debug_write(struct intel_output *intel_output, u8 cmd,
361 void *args, int args_len) 360 void *args, int args_len)
362{ 361{
363 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 362 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
364 int i; 363 int i;
365 364
366 DRM_DEBUG_KMS("%s: W: %02X ", 365 DRM_DEBUG_KMS("%s: W: %02X ",
@@ -379,26 +378,22 @@ static void intel_sdvo_debug_write(struct intel_output *intel_output, u8 cmd,
379 DRM_LOG_KMS("(%02X)", cmd); 378 DRM_LOG_KMS("(%02X)", cmd);
380 DRM_LOG_KMS("\n"); 379 DRM_LOG_KMS("\n");
381} 380}
382#else
383#define intel_sdvo_debug_write(o, c, a, l)
384#endif
385 381
386static void intel_sdvo_write_cmd(struct intel_output *intel_output, u8 cmd, 382static void intel_sdvo_write_cmd(struct intel_encoder *intel_encoder, u8 cmd,
387 void *args, int args_len) 383 void *args, int args_len)
388{ 384{
389 int i; 385 int i;
390 386
391 intel_sdvo_debug_write(intel_output, cmd, args, args_len); 387 intel_sdvo_debug_write(intel_encoder, cmd, args, args_len);
392 388
393 for (i = 0; i < args_len; i++) { 389 for (i = 0; i < args_len; i++) {
394 intel_sdvo_write_byte(intel_output, SDVO_I2C_ARG_0 - i, 390 intel_sdvo_write_byte(intel_encoder, SDVO_I2C_ARG_0 - i,
395 ((u8*)args)[i]); 391 ((u8*)args)[i]);
396 } 392 }
397 393
398 intel_sdvo_write_byte(intel_output, SDVO_I2C_OPCODE, cmd); 394 intel_sdvo_write_byte(intel_encoder, SDVO_I2C_OPCODE, cmd);
399} 395}
400 396
401#ifdef SDVO_DEBUG
402static const char *cmd_status_names[] = { 397static const char *cmd_status_names[] = {
403 "Power on", 398 "Power on",
404 "Success", 399 "Success",
@@ -409,11 +404,11 @@ static const char *cmd_status_names[] = {
409 "Scaling not supported" 404 "Scaling not supported"
410}; 405};
411 406
412static void intel_sdvo_debug_response(struct intel_output *intel_output, 407static void intel_sdvo_debug_response(struct intel_encoder *intel_encoder,
413 void *response, int response_len, 408 void *response, int response_len,
414 u8 status) 409 u8 status)
415{ 410{
416 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 411 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
417 int i; 412 int i;
418 413
419 DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(sdvo_priv)); 414 DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(sdvo_priv));
@@ -427,11 +422,8 @@ static void intel_sdvo_debug_response(struct intel_output *intel_output,
427 DRM_LOG_KMS("(??? %d)", status); 422 DRM_LOG_KMS("(??? %d)", status);
428 DRM_LOG_KMS("\n"); 423 DRM_LOG_KMS("\n");
429} 424}
430#else
431#define intel_sdvo_debug_response(o, r, l, s)
432#endif
433 425
434static u8 intel_sdvo_read_response(struct intel_output *intel_output, 426static u8 intel_sdvo_read_response(struct intel_encoder *intel_encoder,
435 void *response, int response_len) 427 void *response, int response_len)
436{ 428{
437 int i; 429 int i;
@@ -441,16 +433,16 @@ static u8 intel_sdvo_read_response(struct intel_output *intel_output,
441 while (retry--) { 433 while (retry--) {
442 /* Read the command response */ 434 /* Read the command response */
443 for (i = 0; i < response_len; i++) { 435 for (i = 0; i < response_len; i++) {
444 intel_sdvo_read_byte(intel_output, 436 intel_sdvo_read_byte(intel_encoder,
445 SDVO_I2C_RETURN_0 + i, 437 SDVO_I2C_RETURN_0 + i,
446 &((u8 *)response)[i]); 438 &((u8 *)response)[i]);
447 } 439 }
448 440
449 /* read the return status */ 441 /* read the return status */
450 intel_sdvo_read_byte(intel_output, SDVO_I2C_CMD_STATUS, 442 intel_sdvo_read_byte(intel_encoder, SDVO_I2C_CMD_STATUS,
451 &status); 443 &status);
452 444
453 intel_sdvo_debug_response(intel_output, response, response_len, 445 intel_sdvo_debug_response(intel_encoder, response, response_len,
454 status); 446 status);
455 if (status != SDVO_CMD_STATUS_PENDING) 447 if (status != SDVO_CMD_STATUS_PENDING)
456 return status; 448 return status;
@@ -472,17 +464,66 @@ static int intel_sdvo_get_pixel_multiplier(struct drm_display_mode *mode)
472} 464}
473 465
474/** 466/**
475 * Don't check status code from this as it switches the bus back to the 467 * Try to read the response after issuie the DDC switch command. But it
476 * SDVO chips which defeats the purpose of doing a bus switch in the first 468 * is noted that we must do the action of reading response and issuing DDC
477 * place. 469 * switch command in one I2C transaction. Otherwise when we try to start
470 * another I2C transaction after issuing the DDC bus switch, it will be
471 * switched to the internal SDVO register.
478 */ 472 */
479static void intel_sdvo_set_control_bus_switch(struct intel_output *intel_output, 473static void intel_sdvo_set_control_bus_switch(struct intel_encoder *intel_encoder,
480 u8 target) 474 u8 target)
481{ 475{
482 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_CONTROL_BUS_SWITCH, &target, 1); 476 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
477 u8 out_buf[2], cmd_buf[2], ret_value[2], ret;
478 struct i2c_msg msgs[] = {
479 {
480 .addr = sdvo_priv->slave_addr >> 1,
481 .flags = 0,
482 .len = 2,
483 .buf = out_buf,
484 },
485 /* the following two are to read the response */
486 {
487 .addr = sdvo_priv->slave_addr >> 1,
488 .flags = 0,
489 .len = 1,
490 .buf = cmd_buf,
491 },
492 {
493 .addr = sdvo_priv->slave_addr >> 1,
494 .flags = I2C_M_RD,
495 .len = 1,
496 .buf = ret_value,
497 },
498 };
499
500 intel_sdvo_debug_write(intel_encoder, SDVO_CMD_SET_CONTROL_BUS_SWITCH,
501 &target, 1);
502 /* write the DDC switch command argument */
503 intel_sdvo_write_byte(intel_encoder, SDVO_I2C_ARG_0, target);
504
505 out_buf[0] = SDVO_I2C_OPCODE;
506 out_buf[1] = SDVO_CMD_SET_CONTROL_BUS_SWITCH;
507 cmd_buf[0] = SDVO_I2C_CMD_STATUS;
508 cmd_buf[1] = 0;
509 ret_value[0] = 0;
510 ret_value[1] = 0;
511
512 ret = i2c_transfer(intel_encoder->i2c_bus, msgs, 3);
513 if (ret != 3) {
514 /* failure in I2C transfer */
515 DRM_DEBUG_KMS("I2c transfer returned %d\n", ret);
516 return;
517 }
518 if (ret_value[0] != SDVO_CMD_STATUS_SUCCESS) {
519 DRM_DEBUG_KMS("DDC switch command returns response %d\n",
520 ret_value[0]);
521 return;
522 }
523 return;
483} 524}
484 525
485static bool intel_sdvo_set_target_input(struct intel_output *intel_output, bool target_0, bool target_1) 526static bool intel_sdvo_set_target_input(struct intel_encoder *intel_encoder, bool target_0, bool target_1)
486{ 527{
487 struct intel_sdvo_set_target_input_args targets = {0}; 528 struct intel_sdvo_set_target_input_args targets = {0};
488 u8 status; 529 u8 status;
@@ -493,10 +534,10 @@ static bool intel_sdvo_set_target_input(struct intel_output *intel_output, bool
493 if (target_1) 534 if (target_1)
494 targets.target_1 = 1; 535 targets.target_1 = 1;
495 536
496 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_TARGET_INPUT, &targets, 537 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TARGET_INPUT, &targets,
497 sizeof(targets)); 538 sizeof(targets));
498 539
499 status = intel_sdvo_read_response(intel_output, NULL, 0); 540 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
500 541
501 return (status == SDVO_CMD_STATUS_SUCCESS); 542 return (status == SDVO_CMD_STATUS_SUCCESS);
502} 543}
@@ -507,13 +548,13 @@ static bool intel_sdvo_set_target_input(struct intel_output *intel_output, bool
507 * This function is making an assumption about the layout of the response, 548 * This function is making an assumption about the layout of the response,
508 * which should be checked against the docs. 549 * which should be checked against the docs.
509 */ 550 */
510static bool intel_sdvo_get_trained_inputs(struct intel_output *intel_output, bool *input_1, bool *input_2) 551static bool intel_sdvo_get_trained_inputs(struct intel_encoder *intel_encoder, bool *input_1, bool *input_2)
511{ 552{
512 struct intel_sdvo_get_trained_inputs_response response; 553 struct intel_sdvo_get_trained_inputs_response response;
513 u8 status; 554 u8 status;
514 555
515 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_TRAINED_INPUTS, NULL, 0); 556 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_TRAINED_INPUTS, NULL, 0);
516 status = intel_sdvo_read_response(intel_output, &response, sizeof(response)); 557 status = intel_sdvo_read_response(intel_encoder, &response, sizeof(response));
517 if (status != SDVO_CMD_STATUS_SUCCESS) 558 if (status != SDVO_CMD_STATUS_SUCCESS)
518 return false; 559 return false;
519 560
@@ -522,29 +563,29 @@ static bool intel_sdvo_get_trained_inputs(struct intel_output *intel_output, boo
522 return true; 563 return true;
523} 564}
524 565
525static bool intel_sdvo_get_active_outputs(struct intel_output *intel_output, 566static bool intel_sdvo_get_active_outputs(struct intel_encoder *intel_encoder,
526 u16 *outputs) 567 u16 *outputs)
527{ 568{
528 u8 status; 569 u8 status;
529 570
530 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_OUTPUTS, NULL, 0); 571 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_OUTPUTS, NULL, 0);
531 status = intel_sdvo_read_response(intel_output, outputs, sizeof(*outputs)); 572 status = intel_sdvo_read_response(intel_encoder, outputs, sizeof(*outputs));
532 573
533 return (status == SDVO_CMD_STATUS_SUCCESS); 574 return (status == SDVO_CMD_STATUS_SUCCESS);
534} 575}
535 576
536static bool intel_sdvo_set_active_outputs(struct intel_output *intel_output, 577static bool intel_sdvo_set_active_outputs(struct intel_encoder *intel_encoder,
537 u16 outputs) 578 u16 outputs)
538{ 579{
539 u8 status; 580 u8 status;
540 581
541 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_OUTPUTS, &outputs, 582 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_OUTPUTS, &outputs,
542 sizeof(outputs)); 583 sizeof(outputs));
543 status = intel_sdvo_read_response(intel_output, NULL, 0); 584 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
544 return (status == SDVO_CMD_STATUS_SUCCESS); 585 return (status == SDVO_CMD_STATUS_SUCCESS);
545} 586}
546 587
547static bool intel_sdvo_set_encoder_power_state(struct intel_output *intel_output, 588static bool intel_sdvo_set_encoder_power_state(struct intel_encoder *intel_encoder,
548 int mode) 589 int mode)
549{ 590{
550 u8 status, state = SDVO_ENCODER_STATE_ON; 591 u8 status, state = SDVO_ENCODER_STATE_ON;
@@ -564,24 +605,24 @@ static bool intel_sdvo_set_encoder_power_state(struct intel_output *intel_output
564 break; 605 break;
565 } 606 }
566 607
567 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ENCODER_POWER_STATE, &state, 608 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ENCODER_POWER_STATE, &state,
568 sizeof(state)); 609 sizeof(state));
569 status = intel_sdvo_read_response(intel_output, NULL, 0); 610 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
570 611
571 return (status == SDVO_CMD_STATUS_SUCCESS); 612 return (status == SDVO_CMD_STATUS_SUCCESS);
572} 613}
573 614
574static bool intel_sdvo_get_input_pixel_clock_range(struct intel_output *intel_output, 615static bool intel_sdvo_get_input_pixel_clock_range(struct intel_encoder *intel_encoder,
575 int *clock_min, 616 int *clock_min,
576 int *clock_max) 617 int *clock_max)
577{ 618{
578 struct intel_sdvo_pixel_clock_range clocks; 619 struct intel_sdvo_pixel_clock_range clocks;
579 u8 status; 620 u8 status;
580 621
581 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE, 622 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE,
582 NULL, 0); 623 NULL, 0);
583 624
584 status = intel_sdvo_read_response(intel_output, &clocks, sizeof(clocks)); 625 status = intel_sdvo_read_response(intel_encoder, &clocks, sizeof(clocks));
585 626
586 if (status != SDVO_CMD_STATUS_SUCCESS) 627 if (status != SDVO_CMD_STATUS_SUCCESS)
587 return false; 628 return false;
@@ -593,31 +634,31 @@ static bool intel_sdvo_get_input_pixel_clock_range(struct intel_output *intel_ou
593 return true; 634 return true;
594} 635}
595 636
596static bool intel_sdvo_set_target_output(struct intel_output *intel_output, 637static bool intel_sdvo_set_target_output(struct intel_encoder *intel_encoder,
597 u16 outputs) 638 u16 outputs)
598{ 639{
599 u8 status; 640 u8 status;
600 641
601 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_TARGET_OUTPUT, &outputs, 642 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TARGET_OUTPUT, &outputs,
602 sizeof(outputs)); 643 sizeof(outputs));
603 644
604 status = intel_sdvo_read_response(intel_output, NULL, 0); 645 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
605 return (status == SDVO_CMD_STATUS_SUCCESS); 646 return (status == SDVO_CMD_STATUS_SUCCESS);
606} 647}
607 648
608static bool intel_sdvo_get_timing(struct intel_output *intel_output, u8 cmd, 649static bool intel_sdvo_get_timing(struct intel_encoder *intel_encoder, u8 cmd,
609 struct intel_sdvo_dtd *dtd) 650 struct intel_sdvo_dtd *dtd)
610{ 651{
611 u8 status; 652 u8 status;
612 653
613 intel_sdvo_write_cmd(intel_output, cmd, NULL, 0); 654 intel_sdvo_write_cmd(intel_encoder, cmd, NULL, 0);
614 status = intel_sdvo_read_response(intel_output, &dtd->part1, 655 status = intel_sdvo_read_response(intel_encoder, &dtd->part1,
615 sizeof(dtd->part1)); 656 sizeof(dtd->part1));
616 if (status != SDVO_CMD_STATUS_SUCCESS) 657 if (status != SDVO_CMD_STATUS_SUCCESS)
617 return false; 658 return false;
618 659
619 intel_sdvo_write_cmd(intel_output, cmd + 1, NULL, 0); 660 intel_sdvo_write_cmd(intel_encoder, cmd + 1, NULL, 0);
620 status = intel_sdvo_read_response(intel_output, &dtd->part2, 661 status = intel_sdvo_read_response(intel_encoder, &dtd->part2,
621 sizeof(dtd->part2)); 662 sizeof(dtd->part2));
622 if (status != SDVO_CMD_STATUS_SUCCESS) 663 if (status != SDVO_CMD_STATUS_SUCCESS)
623 return false; 664 return false;
@@ -625,60 +666,60 @@ static bool intel_sdvo_get_timing(struct intel_output *intel_output, u8 cmd,
625 return true; 666 return true;
626} 667}
627 668
628static bool intel_sdvo_get_input_timing(struct intel_output *intel_output, 669static bool intel_sdvo_get_input_timing(struct intel_encoder *intel_encoder,
629 struct intel_sdvo_dtd *dtd) 670 struct intel_sdvo_dtd *dtd)
630{ 671{
631 return intel_sdvo_get_timing(intel_output, 672 return intel_sdvo_get_timing(intel_encoder,
632 SDVO_CMD_GET_INPUT_TIMINGS_PART1, dtd); 673 SDVO_CMD_GET_INPUT_TIMINGS_PART1, dtd);
633} 674}
634 675
635static bool intel_sdvo_get_output_timing(struct intel_output *intel_output, 676static bool intel_sdvo_get_output_timing(struct intel_encoder *intel_encoder,
636 struct intel_sdvo_dtd *dtd) 677 struct intel_sdvo_dtd *dtd)
637{ 678{
638 return intel_sdvo_get_timing(intel_output, 679 return intel_sdvo_get_timing(intel_encoder,
639 SDVO_CMD_GET_OUTPUT_TIMINGS_PART1, dtd); 680 SDVO_CMD_GET_OUTPUT_TIMINGS_PART1, dtd);
640} 681}
641 682
642static bool intel_sdvo_set_timing(struct intel_output *intel_output, u8 cmd, 683static bool intel_sdvo_set_timing(struct intel_encoder *intel_encoder, u8 cmd,
643 struct intel_sdvo_dtd *dtd) 684 struct intel_sdvo_dtd *dtd)
644{ 685{
645 u8 status; 686 u8 status;
646 687
647 intel_sdvo_write_cmd(intel_output, cmd, &dtd->part1, sizeof(dtd->part1)); 688 intel_sdvo_write_cmd(intel_encoder, cmd, &dtd->part1, sizeof(dtd->part1));
648 status = intel_sdvo_read_response(intel_output, NULL, 0); 689 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
649 if (status != SDVO_CMD_STATUS_SUCCESS) 690 if (status != SDVO_CMD_STATUS_SUCCESS)
650 return false; 691 return false;
651 692
652 intel_sdvo_write_cmd(intel_output, cmd + 1, &dtd->part2, sizeof(dtd->part2)); 693 intel_sdvo_write_cmd(intel_encoder, cmd + 1, &dtd->part2, sizeof(dtd->part2));
653 status = intel_sdvo_read_response(intel_output, NULL, 0); 694 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
654 if (status != SDVO_CMD_STATUS_SUCCESS) 695 if (status != SDVO_CMD_STATUS_SUCCESS)
655 return false; 696 return false;
656 697
657 return true; 698 return true;
658} 699}
659 700
660static bool intel_sdvo_set_input_timing(struct intel_output *intel_output, 701static bool intel_sdvo_set_input_timing(struct intel_encoder *intel_encoder,
661 struct intel_sdvo_dtd *dtd) 702 struct intel_sdvo_dtd *dtd)
662{ 703{
663 return intel_sdvo_set_timing(intel_output, 704 return intel_sdvo_set_timing(intel_encoder,
664 SDVO_CMD_SET_INPUT_TIMINGS_PART1, dtd); 705 SDVO_CMD_SET_INPUT_TIMINGS_PART1, dtd);
665} 706}
666 707
667static bool intel_sdvo_set_output_timing(struct intel_output *intel_output, 708static bool intel_sdvo_set_output_timing(struct intel_encoder *intel_encoder,
668 struct intel_sdvo_dtd *dtd) 709 struct intel_sdvo_dtd *dtd)
669{ 710{
670 return intel_sdvo_set_timing(intel_output, 711 return intel_sdvo_set_timing(intel_encoder,
671 SDVO_CMD_SET_OUTPUT_TIMINGS_PART1, dtd); 712 SDVO_CMD_SET_OUTPUT_TIMINGS_PART1, dtd);
672} 713}
673 714
674static bool 715static bool
675intel_sdvo_create_preferred_input_timing(struct intel_output *output, 716intel_sdvo_create_preferred_input_timing(struct intel_encoder *intel_encoder,
676 uint16_t clock, 717 uint16_t clock,
677 uint16_t width, 718 uint16_t width,
678 uint16_t height) 719 uint16_t height)
679{ 720{
680 struct intel_sdvo_preferred_input_timing_args args; 721 struct intel_sdvo_preferred_input_timing_args args;
681 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 722 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
682 uint8_t status; 723 uint8_t status;
683 724
684 memset(&args, 0, sizeof(args)); 725 memset(&args, 0, sizeof(args));
@@ -692,32 +733,33 @@ intel_sdvo_create_preferred_input_timing(struct intel_output *output,
692 sdvo_priv->sdvo_lvds_fixed_mode->vdisplay != height)) 733 sdvo_priv->sdvo_lvds_fixed_mode->vdisplay != height))
693 args.scaled = 1; 734 args.scaled = 1;
694 735
695 intel_sdvo_write_cmd(output, SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING, 736 intel_sdvo_write_cmd(intel_encoder,
737 SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING,
696 &args, sizeof(args)); 738 &args, sizeof(args));
697 status = intel_sdvo_read_response(output, NULL, 0); 739 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
698 if (status != SDVO_CMD_STATUS_SUCCESS) 740 if (status != SDVO_CMD_STATUS_SUCCESS)
699 return false; 741 return false;
700 742
701 return true; 743 return true;
702} 744}
703 745
704static bool intel_sdvo_get_preferred_input_timing(struct intel_output *output, 746static bool intel_sdvo_get_preferred_input_timing(struct intel_encoder *intel_encoder,
705 struct intel_sdvo_dtd *dtd) 747 struct intel_sdvo_dtd *dtd)
706{ 748{
707 bool status; 749 bool status;
708 750
709 intel_sdvo_write_cmd(output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1, 751 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1,
710 NULL, 0); 752 NULL, 0);
711 753
712 status = intel_sdvo_read_response(output, &dtd->part1, 754 status = intel_sdvo_read_response(intel_encoder, &dtd->part1,
713 sizeof(dtd->part1)); 755 sizeof(dtd->part1));
714 if (status != SDVO_CMD_STATUS_SUCCESS) 756 if (status != SDVO_CMD_STATUS_SUCCESS)
715 return false; 757 return false;
716 758
717 intel_sdvo_write_cmd(output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2, 759 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2,
718 NULL, 0); 760 NULL, 0);
719 761
720 status = intel_sdvo_read_response(output, &dtd->part2, 762 status = intel_sdvo_read_response(intel_encoder, &dtd->part2,
721 sizeof(dtd->part2)); 763 sizeof(dtd->part2));
722 if (status != SDVO_CMD_STATUS_SUCCESS) 764 if (status != SDVO_CMD_STATUS_SUCCESS)
723 return false; 765 return false;
@@ -725,12 +767,12 @@ static bool intel_sdvo_get_preferred_input_timing(struct intel_output *output,
725 return false; 767 return false;
726} 768}
727 769
728static int intel_sdvo_get_clock_rate_mult(struct intel_output *intel_output) 770static int intel_sdvo_get_clock_rate_mult(struct intel_encoder *intel_encoder)
729{ 771{
730 u8 response, status; 772 u8 response, status;
731 773
732 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_CLOCK_RATE_MULT, NULL, 0); 774 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_CLOCK_RATE_MULT, NULL, 0);
733 status = intel_sdvo_read_response(intel_output, &response, 1); 775 status = intel_sdvo_read_response(intel_encoder, &response, 1);
734 776
735 if (status != SDVO_CMD_STATUS_SUCCESS) { 777 if (status != SDVO_CMD_STATUS_SUCCESS) {
736 DRM_DEBUG_KMS("Couldn't get SDVO clock rate multiplier\n"); 778 DRM_DEBUG_KMS("Couldn't get SDVO clock rate multiplier\n");
@@ -742,12 +784,12 @@ static int intel_sdvo_get_clock_rate_mult(struct intel_output *intel_output)
742 return response; 784 return response;
743} 785}
744 786
745static bool intel_sdvo_set_clock_rate_mult(struct intel_output *intel_output, u8 val) 787static bool intel_sdvo_set_clock_rate_mult(struct intel_encoder *intel_encoder, u8 val)
746{ 788{
747 u8 status; 789 u8 status;
748 790
749 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1); 791 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1);
750 status = intel_sdvo_read_response(intel_output, NULL, 0); 792 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
751 if (status != SDVO_CMD_STATUS_SUCCESS) 793 if (status != SDVO_CMD_STATUS_SUCCESS)
752 return false; 794 return false;
753 795
@@ -836,13 +878,13 @@ static void intel_sdvo_get_mode_from_dtd(struct drm_display_mode * mode,
836 mode->flags |= DRM_MODE_FLAG_PVSYNC; 878 mode->flags |= DRM_MODE_FLAG_PVSYNC;
837} 879}
838 880
839static bool intel_sdvo_get_supp_encode(struct intel_output *output, 881static bool intel_sdvo_get_supp_encode(struct intel_encoder *intel_encoder,
840 struct intel_sdvo_encode *encode) 882 struct intel_sdvo_encode *encode)
841{ 883{
842 uint8_t status; 884 uint8_t status;
843 885
844 intel_sdvo_write_cmd(output, SDVO_CMD_GET_SUPP_ENCODE, NULL, 0); 886 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_SUPP_ENCODE, NULL, 0);
845 status = intel_sdvo_read_response(output, encode, sizeof(*encode)); 887 status = intel_sdvo_read_response(intel_encoder, encode, sizeof(*encode));
846 if (status != SDVO_CMD_STATUS_SUCCESS) { /* non-support means DVI */ 888 if (status != SDVO_CMD_STATUS_SUCCESS) { /* non-support means DVI */
847 memset(encode, 0, sizeof(*encode)); 889 memset(encode, 0, sizeof(*encode));
848 return false; 890 return false;
@@ -851,29 +893,30 @@ static bool intel_sdvo_get_supp_encode(struct intel_output *output,
851 return true; 893 return true;
852} 894}
853 895
854static bool intel_sdvo_set_encode(struct intel_output *output, uint8_t mode) 896static bool intel_sdvo_set_encode(struct intel_encoder *intel_encoder,
897 uint8_t mode)
855{ 898{
856 uint8_t status; 899 uint8_t status;
857 900
858 intel_sdvo_write_cmd(output, SDVO_CMD_SET_ENCODE, &mode, 1); 901 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ENCODE, &mode, 1);
859 status = intel_sdvo_read_response(output, NULL, 0); 902 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
860 903
861 return (status == SDVO_CMD_STATUS_SUCCESS); 904 return (status == SDVO_CMD_STATUS_SUCCESS);
862} 905}
863 906
864static bool intel_sdvo_set_colorimetry(struct intel_output *output, 907static bool intel_sdvo_set_colorimetry(struct intel_encoder *intel_encoder,
865 uint8_t mode) 908 uint8_t mode)
866{ 909{
867 uint8_t status; 910 uint8_t status;
868 911
869 intel_sdvo_write_cmd(output, SDVO_CMD_SET_COLORIMETRY, &mode, 1); 912 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_COLORIMETRY, &mode, 1);
870 status = intel_sdvo_read_response(output, NULL, 0); 913 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
871 914
872 return (status == SDVO_CMD_STATUS_SUCCESS); 915 return (status == SDVO_CMD_STATUS_SUCCESS);
873} 916}
874 917
875#if 0 918#if 0
876static void intel_sdvo_dump_hdmi_buf(struct intel_output *output) 919static void intel_sdvo_dump_hdmi_buf(struct intel_encoder *intel_encoder)
877{ 920{
878 int i, j; 921 int i, j;
879 uint8_t set_buf_index[2]; 922 uint8_t set_buf_index[2];
@@ -882,43 +925,45 @@ static void intel_sdvo_dump_hdmi_buf(struct intel_output *output)
882 uint8_t buf[48]; 925 uint8_t buf[48];
883 uint8_t *pos; 926 uint8_t *pos;
884 927
885 intel_sdvo_write_cmd(output, SDVO_CMD_GET_HBUF_AV_SPLIT, NULL, 0); 928 intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_AV_SPLIT, NULL, 0);
886 intel_sdvo_read_response(output, &av_split, 1); 929 intel_sdvo_read_response(encoder, &av_split, 1);
887 930
888 for (i = 0; i <= av_split; i++) { 931 for (i = 0; i <= av_split; i++) {
889 set_buf_index[0] = i; set_buf_index[1] = 0; 932 set_buf_index[0] = i; set_buf_index[1] = 0;
890 intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_INDEX, 933 intel_sdvo_write_cmd(encoder, SDVO_CMD_SET_HBUF_INDEX,
891 set_buf_index, 2); 934 set_buf_index, 2);
892 intel_sdvo_write_cmd(output, SDVO_CMD_GET_HBUF_INFO, NULL, 0); 935 intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_INFO, NULL, 0);
893 intel_sdvo_read_response(output, &buf_size, 1); 936 intel_sdvo_read_response(encoder, &buf_size, 1);
894 937
895 pos = buf; 938 pos = buf;
896 for (j = 0; j <= buf_size; j += 8) { 939 for (j = 0; j <= buf_size; j += 8) {
897 intel_sdvo_write_cmd(output, SDVO_CMD_GET_HBUF_DATA, 940 intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_DATA,
898 NULL, 0); 941 NULL, 0);
899 intel_sdvo_read_response(output, pos, 8); 942 intel_sdvo_read_response(encoder, pos, 8);
900 pos += 8; 943 pos += 8;
901 } 944 }
902 } 945 }
903} 946}
904#endif 947#endif
905 948
906static void intel_sdvo_set_hdmi_buf(struct intel_output *output, int index, 949static void intel_sdvo_set_hdmi_buf(struct intel_encoder *intel_encoder,
907 uint8_t *data, int8_t size, uint8_t tx_rate) 950 int index,
951 uint8_t *data, int8_t size, uint8_t tx_rate)
908{ 952{
909 uint8_t set_buf_index[2]; 953 uint8_t set_buf_index[2];
910 954
911 set_buf_index[0] = index; 955 set_buf_index[0] = index;
912 set_buf_index[1] = 0; 956 set_buf_index[1] = 0;
913 957
914 intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_INDEX, set_buf_index, 2); 958 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_INDEX,
959 set_buf_index, 2);
915 960
916 for (; size > 0; size -= 8) { 961 for (; size > 0; size -= 8) {
917 intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_DATA, data, 8); 962 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_DATA, data, 8);
918 data += 8; 963 data += 8;
919 } 964 }
920 965
921 intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_TXRATE, &tx_rate, 1); 966 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_TXRATE, &tx_rate, 1);
922} 967}
923 968
924static uint8_t intel_sdvo_calc_hbuf_csum(uint8_t *data, uint8_t size) 969static uint8_t intel_sdvo_calc_hbuf_csum(uint8_t *data, uint8_t size)
@@ -993,7 +1038,7 @@ struct dip_infoframe {
993 } __attribute__ ((packed)) u; 1038 } __attribute__ ((packed)) u;
994} __attribute__((packed)); 1039} __attribute__((packed));
995 1040
996static void intel_sdvo_set_avi_infoframe(struct intel_output *output, 1041static void intel_sdvo_set_avi_infoframe(struct intel_encoder *intel_encoder,
997 struct drm_display_mode * mode) 1042 struct drm_display_mode * mode)
998{ 1043{
999 struct dip_infoframe avi_if = { 1044 struct dip_infoframe avi_if = {
@@ -1004,15 +1049,16 @@ static void intel_sdvo_set_avi_infoframe(struct intel_output *output,
1004 1049
1005 avi_if.checksum = intel_sdvo_calc_hbuf_csum((uint8_t *)&avi_if, 1050 avi_if.checksum = intel_sdvo_calc_hbuf_csum((uint8_t *)&avi_if,
1006 4 + avi_if.len); 1051 4 + avi_if.len);
1007 intel_sdvo_set_hdmi_buf(output, 1, (uint8_t *)&avi_if, 4 + avi_if.len, 1052 intel_sdvo_set_hdmi_buf(intel_encoder, 1, (uint8_t *)&avi_if,
1053 4 + avi_if.len,
1008 SDVO_HBUF_TX_VSYNC); 1054 SDVO_HBUF_TX_VSYNC);
1009} 1055}
1010 1056
1011static void intel_sdvo_set_tv_format(struct intel_output *output) 1057static void intel_sdvo_set_tv_format(struct intel_encoder *intel_encoder)
1012{ 1058{
1013 1059
1014 struct intel_sdvo_tv_format format; 1060 struct intel_sdvo_tv_format format;
1015 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1061 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1016 uint32_t format_map, i; 1062 uint32_t format_map, i;
1017 uint8_t status; 1063 uint8_t status;
1018 1064
@@ -1025,10 +1071,10 @@ static void intel_sdvo_set_tv_format(struct intel_output *output)
1025 memcpy(&format, &format_map, sizeof(format_map) > sizeof(format) ? 1071 memcpy(&format, &format_map, sizeof(format_map) > sizeof(format) ?
1026 sizeof(format) : sizeof(format_map)); 1072 sizeof(format) : sizeof(format_map));
1027 1073
1028 intel_sdvo_write_cmd(output, SDVO_CMD_SET_TV_FORMAT, &format_map, 1074 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TV_FORMAT, &format_map,
1029 sizeof(format)); 1075 sizeof(format));
1030 1076
1031 status = intel_sdvo_read_response(output, NULL, 0); 1077 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
1032 if (status != SDVO_CMD_STATUS_SUCCESS) 1078 if (status != SDVO_CMD_STATUS_SUCCESS)
1033 DRM_DEBUG_KMS("%s: Failed to set TV format\n", 1079 DRM_DEBUG_KMS("%s: Failed to set TV format\n",
1034 SDVO_NAME(sdvo_priv)); 1080 SDVO_NAME(sdvo_priv));
@@ -1038,8 +1084,8 @@ static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
1038 struct drm_display_mode *mode, 1084 struct drm_display_mode *mode,
1039 struct drm_display_mode *adjusted_mode) 1085 struct drm_display_mode *adjusted_mode)
1040{ 1086{
1041 struct intel_output *output = enc_to_intel_output(encoder); 1087 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1042 struct intel_sdvo_priv *dev_priv = output->dev_priv; 1088 struct intel_sdvo_priv *dev_priv = intel_encoder->dev_priv;
1043 1089
1044 if (dev_priv->is_tv) { 1090 if (dev_priv->is_tv) {
1045 struct intel_sdvo_dtd output_dtd; 1091 struct intel_sdvo_dtd output_dtd;
@@ -1054,22 +1100,22 @@ static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
1054 1100
1055 /* Set output timings */ 1101 /* Set output timings */
1056 intel_sdvo_get_dtd_from_mode(&output_dtd, mode); 1102 intel_sdvo_get_dtd_from_mode(&output_dtd, mode);
1057 intel_sdvo_set_target_output(output, 1103 intel_sdvo_set_target_output(intel_encoder,
1058 dev_priv->controlled_output); 1104 dev_priv->controlled_output);
1059 intel_sdvo_set_output_timing(output, &output_dtd); 1105 intel_sdvo_set_output_timing(intel_encoder, &output_dtd);
1060 1106
1061 /* Set the input timing to the screen. Assume always input 0. */ 1107 /* Set the input timing to the screen. Assume always input 0. */
1062 intel_sdvo_set_target_input(output, true, false); 1108 intel_sdvo_set_target_input(intel_encoder, true, false);
1063 1109
1064 1110
1065 success = intel_sdvo_create_preferred_input_timing(output, 1111 success = intel_sdvo_create_preferred_input_timing(intel_encoder,
1066 mode->clock / 10, 1112 mode->clock / 10,
1067 mode->hdisplay, 1113 mode->hdisplay,
1068 mode->vdisplay); 1114 mode->vdisplay);
1069 if (success) { 1115 if (success) {
1070 struct intel_sdvo_dtd input_dtd; 1116 struct intel_sdvo_dtd input_dtd;
1071 1117
1072 intel_sdvo_get_preferred_input_timing(output, 1118 intel_sdvo_get_preferred_input_timing(intel_encoder,
1073 &input_dtd); 1119 &input_dtd);
1074 intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd); 1120 intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
1075 dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags; 1121 dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags;
@@ -1092,16 +1138,16 @@ static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
1092 intel_sdvo_get_dtd_from_mode(&output_dtd, 1138 intel_sdvo_get_dtd_from_mode(&output_dtd,
1093 dev_priv->sdvo_lvds_fixed_mode); 1139 dev_priv->sdvo_lvds_fixed_mode);
1094 1140
1095 intel_sdvo_set_target_output(output, 1141 intel_sdvo_set_target_output(intel_encoder,
1096 dev_priv->controlled_output); 1142 dev_priv->controlled_output);
1097 intel_sdvo_set_output_timing(output, &output_dtd); 1143 intel_sdvo_set_output_timing(intel_encoder, &output_dtd);
1098 1144
1099 /* Set the input timing to the screen. Assume always input 0. */ 1145 /* Set the input timing to the screen. Assume always input 0. */
1100 intel_sdvo_set_target_input(output, true, false); 1146 intel_sdvo_set_target_input(intel_encoder, true, false);
1101 1147
1102 1148
1103 success = intel_sdvo_create_preferred_input_timing( 1149 success = intel_sdvo_create_preferred_input_timing(
1104 output, 1150 intel_encoder,
1105 mode->clock / 10, 1151 mode->clock / 10,
1106 mode->hdisplay, 1152 mode->hdisplay,
1107 mode->vdisplay); 1153 mode->vdisplay);
@@ -1109,7 +1155,7 @@ static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
1109 if (success) { 1155 if (success) {
1110 struct intel_sdvo_dtd input_dtd; 1156 struct intel_sdvo_dtd input_dtd;
1111 1157
1112 intel_sdvo_get_preferred_input_timing(output, 1158 intel_sdvo_get_preferred_input_timing(intel_encoder,
1113 &input_dtd); 1159 &input_dtd);
1114 intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd); 1160 intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd);
1115 dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags; 1161 dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags;
@@ -1141,8 +1187,8 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
1141 struct drm_i915_private *dev_priv = dev->dev_private; 1187 struct drm_i915_private *dev_priv = dev->dev_private;
1142 struct drm_crtc *crtc = encoder->crtc; 1188 struct drm_crtc *crtc = encoder->crtc;
1143 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 1189 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
1144 struct intel_output *output = enc_to_intel_output(encoder); 1190 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1145 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1191 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1146 u32 sdvox = 0; 1192 u32 sdvox = 0;
1147 int sdvo_pixel_multiply; 1193 int sdvo_pixel_multiply;
1148 struct intel_sdvo_in_out_map in_out; 1194 struct intel_sdvo_in_out_map in_out;
@@ -1161,12 +1207,12 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
1161 in_out.in0 = sdvo_priv->controlled_output; 1207 in_out.in0 = sdvo_priv->controlled_output;
1162 in_out.in1 = 0; 1208 in_out.in1 = 0;
1163 1209
1164 intel_sdvo_write_cmd(output, SDVO_CMD_SET_IN_OUT_MAP, 1210 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_IN_OUT_MAP,
1165 &in_out, sizeof(in_out)); 1211 &in_out, sizeof(in_out));
1166 status = intel_sdvo_read_response(output, NULL, 0); 1212 status = intel_sdvo_read_response(intel_encoder, NULL, 0);
1167 1213
1168 if (sdvo_priv->is_hdmi) { 1214 if (sdvo_priv->is_hdmi) {
1169 intel_sdvo_set_avi_infoframe(output, mode); 1215 intel_sdvo_set_avi_infoframe(intel_encoder, mode);
1170 sdvox |= SDVO_AUDIO_ENABLE; 1216 sdvox |= SDVO_AUDIO_ENABLE;
1171 } 1217 }
1172 1218
@@ -1183,16 +1229,16 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
1183 */ 1229 */
1184 if (!sdvo_priv->is_tv && !sdvo_priv->is_lvds) { 1230 if (!sdvo_priv->is_tv && !sdvo_priv->is_lvds) {
1185 /* Set the output timing to the screen */ 1231 /* Set the output timing to the screen */
1186 intel_sdvo_set_target_output(output, 1232 intel_sdvo_set_target_output(intel_encoder,
1187 sdvo_priv->controlled_output); 1233 sdvo_priv->controlled_output);
1188 intel_sdvo_set_output_timing(output, &input_dtd); 1234 intel_sdvo_set_output_timing(intel_encoder, &input_dtd);
1189 } 1235 }
1190 1236
1191 /* Set the input timing to the screen. Assume always input 0. */ 1237 /* Set the input timing to the screen. Assume always input 0. */
1192 intel_sdvo_set_target_input(output, true, false); 1238 intel_sdvo_set_target_input(intel_encoder, true, false);
1193 1239
1194 if (sdvo_priv->is_tv) 1240 if (sdvo_priv->is_tv)
1195 intel_sdvo_set_tv_format(output); 1241 intel_sdvo_set_tv_format(intel_encoder);
1196 1242
1197 /* We would like to use intel_sdvo_create_preferred_input_timing() to 1243 /* We would like to use intel_sdvo_create_preferred_input_timing() to
1198 * provide the device with a timing it can support, if it supports that 1244 * provide the device with a timing it can support, if it supports that
@@ -1200,29 +1246,29 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
1200 * output the preferred timing, and we don't support that currently. 1246 * output the preferred timing, and we don't support that currently.
1201 */ 1247 */
1202#if 0 1248#if 0
1203 success = intel_sdvo_create_preferred_input_timing(output, clock, 1249 success = intel_sdvo_create_preferred_input_timing(encoder, clock,
1204 width, height); 1250 width, height);
1205 if (success) { 1251 if (success) {
1206 struct intel_sdvo_dtd *input_dtd; 1252 struct intel_sdvo_dtd *input_dtd;
1207 1253
1208 intel_sdvo_get_preferred_input_timing(output, &input_dtd); 1254 intel_sdvo_get_preferred_input_timing(encoder, &input_dtd);
1209 intel_sdvo_set_input_timing(output, &input_dtd); 1255 intel_sdvo_set_input_timing(encoder, &input_dtd);
1210 } 1256 }
1211#else 1257#else
1212 intel_sdvo_set_input_timing(output, &input_dtd); 1258 intel_sdvo_set_input_timing(intel_encoder, &input_dtd);
1213#endif 1259#endif
1214 1260
1215 switch (intel_sdvo_get_pixel_multiplier(mode)) { 1261 switch (intel_sdvo_get_pixel_multiplier(mode)) {
1216 case 1: 1262 case 1:
1217 intel_sdvo_set_clock_rate_mult(output, 1263 intel_sdvo_set_clock_rate_mult(intel_encoder,
1218 SDVO_CLOCK_RATE_MULT_1X); 1264 SDVO_CLOCK_RATE_MULT_1X);
1219 break; 1265 break;
1220 case 2: 1266 case 2:
1221 intel_sdvo_set_clock_rate_mult(output, 1267 intel_sdvo_set_clock_rate_mult(intel_encoder,
1222 SDVO_CLOCK_RATE_MULT_2X); 1268 SDVO_CLOCK_RATE_MULT_2X);
1223 break; 1269 break;
1224 case 4: 1270 case 4:
1225 intel_sdvo_set_clock_rate_mult(output, 1271 intel_sdvo_set_clock_rate_mult(intel_encoder,
1226 SDVO_CLOCK_RATE_MULT_4X); 1272 SDVO_CLOCK_RATE_MULT_4X);
1227 break; 1273 break;
1228 } 1274 }
@@ -1233,8 +1279,8 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
1233 SDVO_VSYNC_ACTIVE_HIGH | 1279 SDVO_VSYNC_ACTIVE_HIGH |
1234 SDVO_HSYNC_ACTIVE_HIGH; 1280 SDVO_HSYNC_ACTIVE_HIGH;
1235 } else { 1281 } else {
1236 sdvox |= I915_READ(sdvo_priv->output_device); 1282 sdvox |= I915_READ(sdvo_priv->sdvo_reg);
1237 switch (sdvo_priv->output_device) { 1283 switch (sdvo_priv->sdvo_reg) {
1238 case SDVOB: 1284 case SDVOB:
1239 sdvox &= SDVOB_PRESERVE_MASK; 1285 sdvox &= SDVOB_PRESERVE_MASK;
1240 break; 1286 break;
@@ -1258,26 +1304,26 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
1258 1304
1259 if (sdvo_priv->sdvo_flags & SDVO_NEED_TO_STALL) 1305 if (sdvo_priv->sdvo_flags & SDVO_NEED_TO_STALL)
1260 sdvox |= SDVO_STALL_SELECT; 1306 sdvox |= SDVO_STALL_SELECT;
1261 intel_sdvo_write_sdvox(output, sdvox); 1307 intel_sdvo_write_sdvox(intel_encoder, sdvox);
1262} 1308}
1263 1309
1264static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode) 1310static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
1265{ 1311{
1266 struct drm_device *dev = encoder->dev; 1312 struct drm_device *dev = encoder->dev;
1267 struct drm_i915_private *dev_priv = dev->dev_private; 1313 struct drm_i915_private *dev_priv = dev->dev_private;
1268 struct intel_output *intel_output = enc_to_intel_output(encoder); 1314 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1269 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1315 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1270 u32 temp; 1316 u32 temp;
1271 1317
1272 if (mode != DRM_MODE_DPMS_ON) { 1318 if (mode != DRM_MODE_DPMS_ON) {
1273 intel_sdvo_set_active_outputs(intel_output, 0); 1319 intel_sdvo_set_active_outputs(intel_encoder, 0);
1274 if (0) 1320 if (0)
1275 intel_sdvo_set_encoder_power_state(intel_output, mode); 1321 intel_sdvo_set_encoder_power_state(intel_encoder, mode);
1276 1322
1277 if (mode == DRM_MODE_DPMS_OFF) { 1323 if (mode == DRM_MODE_DPMS_OFF) {
1278 temp = I915_READ(sdvo_priv->output_device); 1324 temp = I915_READ(sdvo_priv->sdvo_reg);
1279 if ((temp & SDVO_ENABLE) != 0) { 1325 if ((temp & SDVO_ENABLE) != 0) {
1280 intel_sdvo_write_sdvox(intel_output, temp & ~SDVO_ENABLE); 1326 intel_sdvo_write_sdvox(intel_encoder, temp & ~SDVO_ENABLE);
1281 } 1327 }
1282 } 1328 }
1283 } else { 1329 } else {
@@ -1285,13 +1331,13 @@ static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
1285 int i; 1331 int i;
1286 u8 status; 1332 u8 status;
1287 1333
1288 temp = I915_READ(sdvo_priv->output_device); 1334 temp = I915_READ(sdvo_priv->sdvo_reg);
1289 if ((temp & SDVO_ENABLE) == 0) 1335 if ((temp & SDVO_ENABLE) == 0)
1290 intel_sdvo_write_sdvox(intel_output, temp | SDVO_ENABLE); 1336 intel_sdvo_write_sdvox(intel_encoder, temp | SDVO_ENABLE);
1291 for (i = 0; i < 2; i++) 1337 for (i = 0; i < 2; i++)
1292 intel_wait_for_vblank(dev); 1338 intel_wait_for_vblank(dev);
1293 1339
1294 status = intel_sdvo_get_trained_inputs(intel_output, &input1, 1340 status = intel_sdvo_get_trained_inputs(intel_encoder, &input1,
1295 &input2); 1341 &input2);
1296 1342
1297 1343
@@ -1305,8 +1351,8 @@ static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
1305 } 1351 }
1306 1352
1307 if (0) 1353 if (0)
1308 intel_sdvo_set_encoder_power_state(intel_output, mode); 1354 intel_sdvo_set_encoder_power_state(intel_encoder, mode);
1309 intel_sdvo_set_active_outputs(intel_output, sdvo_priv->controlled_output); 1355 intel_sdvo_set_active_outputs(intel_encoder, sdvo_priv->controlled_output);
1310 } 1356 }
1311 return; 1357 return;
1312} 1358}
@@ -1315,22 +1361,22 @@ static void intel_sdvo_save(struct drm_connector *connector)
1315{ 1361{
1316 struct drm_device *dev = connector->dev; 1362 struct drm_device *dev = connector->dev;
1317 struct drm_i915_private *dev_priv = dev->dev_private; 1363 struct drm_i915_private *dev_priv = dev->dev_private;
1318 struct intel_output *intel_output = to_intel_output(connector); 1364 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1319 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1365 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1320 int o; 1366 int o;
1321 1367
1322 sdvo_priv->save_sdvo_mult = intel_sdvo_get_clock_rate_mult(intel_output); 1368 sdvo_priv->save_sdvo_mult = intel_sdvo_get_clock_rate_mult(intel_encoder);
1323 intel_sdvo_get_active_outputs(intel_output, &sdvo_priv->save_active_outputs); 1369 intel_sdvo_get_active_outputs(intel_encoder, &sdvo_priv->save_active_outputs);
1324 1370
1325 if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) { 1371 if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) {
1326 intel_sdvo_set_target_input(intel_output, true, false); 1372 intel_sdvo_set_target_input(intel_encoder, true, false);
1327 intel_sdvo_get_input_timing(intel_output, 1373 intel_sdvo_get_input_timing(intel_encoder,
1328 &sdvo_priv->save_input_dtd_1); 1374 &sdvo_priv->save_input_dtd_1);
1329 } 1375 }
1330 1376
1331 if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) { 1377 if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) {
1332 intel_sdvo_set_target_input(intel_output, false, true); 1378 intel_sdvo_set_target_input(intel_encoder, false, true);
1333 intel_sdvo_get_input_timing(intel_output, 1379 intel_sdvo_get_input_timing(intel_encoder,
1334 &sdvo_priv->save_input_dtd_2); 1380 &sdvo_priv->save_input_dtd_2);
1335 } 1381 }
1336 1382
@@ -1339,8 +1385,8 @@ static void intel_sdvo_save(struct drm_connector *connector)
1339 u16 this_output = (1 << o); 1385 u16 this_output = (1 << o);
1340 if (sdvo_priv->caps.output_flags & this_output) 1386 if (sdvo_priv->caps.output_flags & this_output)
1341 { 1387 {
1342 intel_sdvo_set_target_output(intel_output, this_output); 1388 intel_sdvo_set_target_output(intel_encoder, this_output);
1343 intel_sdvo_get_output_timing(intel_output, 1389 intel_sdvo_get_output_timing(intel_encoder,
1344 &sdvo_priv->save_output_dtd[o]); 1390 &sdvo_priv->save_output_dtd[o]);
1345 } 1391 }
1346 } 1392 }
@@ -1348,66 +1394,66 @@ static void intel_sdvo_save(struct drm_connector *connector)
1348 /* XXX: Save TV format/enhancements. */ 1394 /* XXX: Save TV format/enhancements. */
1349 } 1395 }
1350 1396
1351 sdvo_priv->save_SDVOX = I915_READ(sdvo_priv->output_device); 1397 sdvo_priv->save_SDVOX = I915_READ(sdvo_priv->sdvo_reg);
1352} 1398}
1353 1399
1354static void intel_sdvo_restore(struct drm_connector *connector) 1400static void intel_sdvo_restore(struct drm_connector *connector)
1355{ 1401{
1356 struct drm_device *dev = connector->dev; 1402 struct drm_device *dev = connector->dev;
1357 struct intel_output *intel_output = to_intel_output(connector); 1403 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1358 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1404 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1359 int o; 1405 int o;
1360 int i; 1406 int i;
1361 bool input1, input2; 1407 bool input1, input2;
1362 u8 status; 1408 u8 status;
1363 1409
1364 intel_sdvo_set_active_outputs(intel_output, 0); 1410 intel_sdvo_set_active_outputs(intel_encoder, 0);
1365 1411
1366 for (o = SDVO_OUTPUT_FIRST; o <= SDVO_OUTPUT_LAST; o++) 1412 for (o = SDVO_OUTPUT_FIRST; o <= SDVO_OUTPUT_LAST; o++)
1367 { 1413 {
1368 u16 this_output = (1 << o); 1414 u16 this_output = (1 << o);
1369 if (sdvo_priv->caps.output_flags & this_output) { 1415 if (sdvo_priv->caps.output_flags & this_output) {
1370 intel_sdvo_set_target_output(intel_output, this_output); 1416 intel_sdvo_set_target_output(intel_encoder, this_output);
1371 intel_sdvo_set_output_timing(intel_output, &sdvo_priv->save_output_dtd[o]); 1417 intel_sdvo_set_output_timing(intel_encoder, &sdvo_priv->save_output_dtd[o]);
1372 } 1418 }
1373 } 1419 }
1374 1420
1375 if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) { 1421 if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) {
1376 intel_sdvo_set_target_input(intel_output, true, false); 1422 intel_sdvo_set_target_input(intel_encoder, true, false);
1377 intel_sdvo_set_input_timing(intel_output, &sdvo_priv->save_input_dtd_1); 1423 intel_sdvo_set_input_timing(intel_encoder, &sdvo_priv->save_input_dtd_1);
1378 } 1424 }
1379 1425
1380 if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) { 1426 if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) {
1381 intel_sdvo_set_target_input(intel_output, false, true); 1427 intel_sdvo_set_target_input(intel_encoder, false, true);
1382 intel_sdvo_set_input_timing(intel_output, &sdvo_priv->save_input_dtd_2); 1428 intel_sdvo_set_input_timing(intel_encoder, &sdvo_priv->save_input_dtd_2);
1383 } 1429 }
1384 1430
1385 intel_sdvo_set_clock_rate_mult(intel_output, sdvo_priv->save_sdvo_mult); 1431 intel_sdvo_set_clock_rate_mult(intel_encoder, sdvo_priv->save_sdvo_mult);
1386 1432
1387 if (sdvo_priv->is_tv) { 1433 if (sdvo_priv->is_tv) {
1388 /* XXX: Restore TV format/enhancements. */ 1434 /* XXX: Restore TV format/enhancements. */
1389 } 1435 }
1390 1436
1391 intel_sdvo_write_sdvox(intel_output, sdvo_priv->save_SDVOX); 1437 intel_sdvo_write_sdvox(intel_encoder, sdvo_priv->save_SDVOX);
1392 1438
1393 if (sdvo_priv->save_SDVOX & SDVO_ENABLE) 1439 if (sdvo_priv->save_SDVOX & SDVO_ENABLE)
1394 { 1440 {
1395 for (i = 0; i < 2; i++) 1441 for (i = 0; i < 2; i++)
1396 intel_wait_for_vblank(dev); 1442 intel_wait_for_vblank(dev);
1397 status = intel_sdvo_get_trained_inputs(intel_output, &input1, &input2); 1443 status = intel_sdvo_get_trained_inputs(intel_encoder, &input1, &input2);
1398 if (status == SDVO_CMD_STATUS_SUCCESS && !input1) 1444 if (status == SDVO_CMD_STATUS_SUCCESS && !input1)
1399 DRM_DEBUG_KMS("First %s output reported failure to " 1445 DRM_DEBUG_KMS("First %s output reported failure to "
1400 "sync\n", SDVO_NAME(sdvo_priv)); 1446 "sync\n", SDVO_NAME(sdvo_priv));
1401 } 1447 }
1402 1448
1403 intel_sdvo_set_active_outputs(intel_output, sdvo_priv->save_active_outputs); 1449 intel_sdvo_set_active_outputs(intel_encoder, sdvo_priv->save_active_outputs);
1404} 1450}
1405 1451
1406static int intel_sdvo_mode_valid(struct drm_connector *connector, 1452static int intel_sdvo_mode_valid(struct drm_connector *connector,
1407 struct drm_display_mode *mode) 1453 struct drm_display_mode *mode)
1408{ 1454{
1409 struct intel_output *intel_output = to_intel_output(connector); 1455 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1410 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1456 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1411 1457
1412 if (mode->flags & DRM_MODE_FLAG_DBLSCAN) 1458 if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
1413 return MODE_NO_DBLESCAN; 1459 return MODE_NO_DBLESCAN;
@@ -1432,12 +1478,12 @@ static int intel_sdvo_mode_valid(struct drm_connector *connector,
1432 return MODE_OK; 1478 return MODE_OK;
1433} 1479}
1434 1480
1435static bool intel_sdvo_get_capabilities(struct intel_output *intel_output, struct intel_sdvo_caps *caps) 1481static bool intel_sdvo_get_capabilities(struct intel_encoder *intel_encoder, struct intel_sdvo_caps *caps)
1436{ 1482{
1437 u8 status; 1483 u8 status;
1438 1484
1439 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_DEVICE_CAPS, NULL, 0); 1485 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_DEVICE_CAPS, NULL, 0);
1440 status = intel_sdvo_read_response(intel_output, caps, sizeof(*caps)); 1486 status = intel_sdvo_read_response(intel_encoder, caps, sizeof(*caps));
1441 if (status != SDVO_CMD_STATUS_SUCCESS) 1487 if (status != SDVO_CMD_STATUS_SUCCESS)
1442 return false; 1488 return false;
1443 1489
@@ -1447,22 +1493,22 @@ static bool intel_sdvo_get_capabilities(struct intel_output *intel_output, struc
1447struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB) 1493struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB)
1448{ 1494{
1449 struct drm_connector *connector = NULL; 1495 struct drm_connector *connector = NULL;
1450 struct intel_output *iout = NULL; 1496 struct intel_encoder *iout = NULL;
1451 struct intel_sdvo_priv *sdvo; 1497 struct intel_sdvo_priv *sdvo;
1452 1498
1453 /* find the sdvo connector */ 1499 /* find the sdvo connector */
1454 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1500 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1455 iout = to_intel_output(connector); 1501 iout = to_intel_encoder(connector);
1456 1502
1457 if (iout->type != INTEL_OUTPUT_SDVO) 1503 if (iout->type != INTEL_OUTPUT_SDVO)
1458 continue; 1504 continue;
1459 1505
1460 sdvo = iout->dev_priv; 1506 sdvo = iout->dev_priv;
1461 1507
1462 if (sdvo->output_device == SDVOB && sdvoB) 1508 if (sdvo->sdvo_reg == SDVOB && sdvoB)
1463 return connector; 1509 return connector;
1464 1510
1465 if (sdvo->output_device == SDVOC && !sdvoB) 1511 if (sdvo->sdvo_reg == SDVOC && !sdvoB)
1466 return connector; 1512 return connector;
1467 1513
1468 } 1514 }
@@ -1474,16 +1520,16 @@ int intel_sdvo_supports_hotplug(struct drm_connector *connector)
1474{ 1520{
1475 u8 response[2]; 1521 u8 response[2];
1476 u8 status; 1522 u8 status;
1477 struct intel_output *intel_output; 1523 struct intel_encoder *intel_encoder;
1478 DRM_DEBUG_KMS("\n"); 1524 DRM_DEBUG_KMS("\n");
1479 1525
1480 if (!connector) 1526 if (!connector)
1481 return 0; 1527 return 0;
1482 1528
1483 intel_output = to_intel_output(connector); 1529 intel_encoder = to_intel_encoder(connector);
1484 1530
1485 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0); 1531 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
1486 status = intel_sdvo_read_response(intel_output, &response, 2); 1532 status = intel_sdvo_read_response(intel_encoder, &response, 2);
1487 1533
1488 if (response[0] !=0) 1534 if (response[0] !=0)
1489 return 1; 1535 return 1;
@@ -1495,30 +1541,30 @@ void intel_sdvo_set_hotplug(struct drm_connector *connector, int on)
1495{ 1541{
1496 u8 response[2]; 1542 u8 response[2];
1497 u8 status; 1543 u8 status;
1498 struct intel_output *intel_output = to_intel_output(connector); 1544 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1499 1545
1500 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0); 1546 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
1501 intel_sdvo_read_response(intel_output, &response, 2); 1547 intel_sdvo_read_response(intel_encoder, &response, 2);
1502 1548
1503 if (on) { 1549 if (on) {
1504 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0); 1550 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
1505 status = intel_sdvo_read_response(intel_output, &response, 2); 1551 status = intel_sdvo_read_response(intel_encoder, &response, 2);
1506 1552
1507 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2); 1553 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
1508 } else { 1554 } else {
1509 response[0] = 0; 1555 response[0] = 0;
1510 response[1] = 0; 1556 response[1] = 0;
1511 intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2); 1557 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
1512 } 1558 }
1513 1559
1514 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0); 1560 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
1515 intel_sdvo_read_response(intel_output, &response, 2); 1561 intel_sdvo_read_response(intel_encoder, &response, 2);
1516} 1562}
1517 1563
1518static bool 1564static bool
1519intel_sdvo_multifunc_encoder(struct intel_output *intel_output) 1565intel_sdvo_multifunc_encoder(struct intel_encoder *intel_encoder)
1520{ 1566{
1521 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1567 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1522 int caps = 0; 1568 int caps = 0;
1523 1569
1524 if (sdvo_priv->caps.output_flags & 1570 if (sdvo_priv->caps.output_flags &
@@ -1552,11 +1598,11 @@ static struct drm_connector *
1552intel_find_analog_connector(struct drm_device *dev) 1598intel_find_analog_connector(struct drm_device *dev)
1553{ 1599{
1554 struct drm_connector *connector; 1600 struct drm_connector *connector;
1555 struct intel_output *intel_output; 1601 struct intel_encoder *intel_encoder;
1556 1602
1557 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1603 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1558 intel_output = to_intel_output(connector); 1604 intel_encoder = to_intel_encoder(connector);
1559 if (intel_output->type == INTEL_OUTPUT_ANALOG) 1605 if (intel_encoder->type == INTEL_OUTPUT_ANALOG)
1560 return connector; 1606 return connector;
1561 } 1607 }
1562 return NULL; 1608 return NULL;
@@ -1581,21 +1627,47 @@ intel_analog_is_connected(struct drm_device *dev)
1581enum drm_connector_status 1627enum drm_connector_status
1582intel_sdvo_hdmi_sink_detect(struct drm_connector *connector, u16 response) 1628intel_sdvo_hdmi_sink_detect(struct drm_connector *connector, u16 response)
1583{ 1629{
1584 struct intel_output *intel_output = to_intel_output(connector); 1630 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1585 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1631 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1586 enum drm_connector_status status = connector_status_connected; 1632 enum drm_connector_status status = connector_status_connected;
1587 struct edid *edid = NULL; 1633 struct edid *edid = NULL;
1588 1634
1589 edid = drm_get_edid(&intel_output->base, 1635 edid = drm_get_edid(&intel_encoder->base,
1590 intel_output->ddc_bus); 1636 intel_encoder->ddc_bus);
1591 1637
1638 /* This is only applied to SDVO cards with multiple outputs */
1639 if (edid == NULL && intel_sdvo_multifunc_encoder(intel_encoder)) {
1640 uint8_t saved_ddc, temp_ddc;
1641 saved_ddc = sdvo_priv->ddc_bus;
1642 temp_ddc = sdvo_priv->ddc_bus >> 1;
1643 /*
1644 * Don't use the 1 as the argument of DDC bus switch to get
1645 * the EDID. It is used for SDVO SPD ROM.
1646 */
1647 while(temp_ddc > 1) {
1648 sdvo_priv->ddc_bus = temp_ddc;
1649 edid = drm_get_edid(&intel_encoder->base,
1650 intel_encoder->ddc_bus);
1651 if (edid) {
1652 /*
1653 * When we can get the EDID, maybe it is the
1654 * correct DDC bus. Update it.
1655 */
1656 sdvo_priv->ddc_bus = temp_ddc;
1657 break;
1658 }
1659 temp_ddc >>= 1;
1660 }
1661 if (edid == NULL)
1662 sdvo_priv->ddc_bus = saved_ddc;
1663 }
1592 /* when there is no edid and no monitor is connected with VGA 1664 /* when there is no edid and no monitor is connected with VGA
1593 * port, try to use the CRT ddc to read the EDID for DVI-connector 1665 * port, try to use the CRT ddc to read the EDID for DVI-connector
1594 */ 1666 */
1595 if (edid == NULL && 1667 if (edid == NULL &&
1596 sdvo_priv->analog_ddc_bus && 1668 sdvo_priv->analog_ddc_bus &&
1597 !intel_analog_is_connected(intel_output->base.dev)) 1669 !intel_analog_is_connected(intel_encoder->base.dev))
1598 edid = drm_get_edid(&intel_output->base, 1670 edid = drm_get_edid(&intel_encoder->base,
1599 sdvo_priv->analog_ddc_bus); 1671 sdvo_priv->analog_ddc_bus);
1600 if (edid != NULL) { 1672 if (edid != NULL) {
1601 /* Don't report the output as connected if it's a DVI-I 1673 /* Don't report the output as connected if it's a DVI-I
@@ -1610,7 +1682,7 @@ intel_sdvo_hdmi_sink_detect(struct drm_connector *connector, u16 response)
1610 } 1682 }
1611 1683
1612 kfree(edid); 1684 kfree(edid);
1613 intel_output->base.display_info.raw_edid = NULL; 1685 intel_encoder->base.display_info.raw_edid = NULL;
1614 1686
1615 } else if (response & (SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_TMDS1)) 1687 } else if (response & (SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_TMDS1))
1616 status = connector_status_disconnected; 1688 status = connector_status_disconnected;
@@ -1622,12 +1694,16 @@ static enum drm_connector_status intel_sdvo_detect(struct drm_connector *connect
1622{ 1694{
1623 uint16_t response; 1695 uint16_t response;
1624 u8 status; 1696 u8 status;
1625 struct intel_output *intel_output = to_intel_output(connector); 1697 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1626 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1698 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1627 1699
1628 intel_sdvo_write_cmd(intel_output, 1700 intel_sdvo_write_cmd(intel_encoder,
1629 SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0); 1701 SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0);
1630 status = intel_sdvo_read_response(intel_output, &response, 2); 1702 if (sdvo_priv->is_tv) {
1703 /* add 30ms delay when the output type is SDVO-TV */
1704 mdelay(30);
1705 }
1706 status = intel_sdvo_read_response(intel_encoder, &response, 2);
1631 1707
1632 DRM_DEBUG_KMS("SDVO response %d %d\n", response & 0xff, response >> 8); 1708 DRM_DEBUG_KMS("SDVO response %d %d\n", response & 0xff, response >> 8);
1633 1709
@@ -1637,10 +1713,10 @@ static enum drm_connector_status intel_sdvo_detect(struct drm_connector *connect
1637 if (response == 0) 1713 if (response == 0)
1638 return connector_status_disconnected; 1714 return connector_status_disconnected;
1639 1715
1640 if (intel_sdvo_multifunc_encoder(intel_output) && 1716 if (intel_sdvo_multifunc_encoder(intel_encoder) &&
1641 sdvo_priv->attached_output != response) { 1717 sdvo_priv->attached_output != response) {
1642 if (sdvo_priv->controlled_output != response && 1718 if (sdvo_priv->controlled_output != response &&
1643 intel_sdvo_output_setup(intel_output, response) != true) 1719 intel_sdvo_output_setup(intel_encoder, response) != true)
1644 return connector_status_unknown; 1720 return connector_status_unknown;
1645 sdvo_priv->attached_output = response; 1721 sdvo_priv->attached_output = response;
1646 } 1722 }
@@ -1649,12 +1725,12 @@ static enum drm_connector_status intel_sdvo_detect(struct drm_connector *connect
1649 1725
1650static void intel_sdvo_get_ddc_modes(struct drm_connector *connector) 1726static void intel_sdvo_get_ddc_modes(struct drm_connector *connector)
1651{ 1727{
1652 struct intel_output *intel_output = to_intel_output(connector); 1728 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1653 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1729 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1654 int num_modes; 1730 int num_modes;
1655 1731
1656 /* set the bus switch and get the modes */ 1732 /* set the bus switch and get the modes */
1657 num_modes = intel_ddc_get_modes(intel_output); 1733 num_modes = intel_ddc_get_modes(intel_encoder);
1658 1734
1659 /* 1735 /*
1660 * Mac mini hack. On this device, the DVI-I connector shares one DDC 1736 * Mac mini hack. On this device, the DVI-I connector shares one DDC
@@ -1664,17 +1740,17 @@ static void intel_sdvo_get_ddc_modes(struct drm_connector *connector)
1664 */ 1740 */
1665 if (num_modes == 0 && 1741 if (num_modes == 0 &&
1666 sdvo_priv->analog_ddc_bus && 1742 sdvo_priv->analog_ddc_bus &&
1667 !intel_analog_is_connected(intel_output->base.dev)) { 1743 !intel_analog_is_connected(intel_encoder->base.dev)) {
1668 struct i2c_adapter *digital_ddc_bus; 1744 struct i2c_adapter *digital_ddc_bus;
1669 1745
1670 /* Switch to the analog ddc bus and try that 1746 /* Switch to the analog ddc bus and try that
1671 */ 1747 */
1672 digital_ddc_bus = intel_output->ddc_bus; 1748 digital_ddc_bus = intel_encoder->ddc_bus;
1673 intel_output->ddc_bus = sdvo_priv->analog_ddc_bus; 1749 intel_encoder->ddc_bus = sdvo_priv->analog_ddc_bus;
1674 1750
1675 (void) intel_ddc_get_modes(intel_output); 1751 (void) intel_ddc_get_modes(intel_encoder);
1676 1752
1677 intel_output->ddc_bus = digital_ddc_bus; 1753 intel_encoder->ddc_bus = digital_ddc_bus;
1678 } 1754 }
1679} 1755}
1680 1756
@@ -1745,7 +1821,7 @@ struct drm_display_mode sdvo_tv_modes[] = {
1745 1821
1746static void intel_sdvo_get_tv_modes(struct drm_connector *connector) 1822static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
1747{ 1823{
1748 struct intel_output *output = to_intel_output(connector); 1824 struct intel_encoder *output = to_intel_encoder(connector);
1749 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1825 struct intel_sdvo_priv *sdvo_priv = output->dev_priv;
1750 struct intel_sdvo_sdtv_resolution_request tv_res; 1826 struct intel_sdvo_sdtv_resolution_request tv_res;
1751 uint32_t reply = 0, format_map = 0; 1827 uint32_t reply = 0, format_map = 0;
@@ -1787,9 +1863,9 @@ static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
1787 1863
1788static void intel_sdvo_get_lvds_modes(struct drm_connector *connector) 1864static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
1789{ 1865{
1790 struct intel_output *intel_output = to_intel_output(connector); 1866 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1791 struct drm_i915_private *dev_priv = connector->dev->dev_private; 1867 struct drm_i915_private *dev_priv = connector->dev->dev_private;
1792 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1868 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1793 struct drm_display_mode *newmode; 1869 struct drm_display_mode *newmode;
1794 1870
1795 /* 1871 /*
@@ -1797,7 +1873,7 @@ static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
1797 * Assume that the preferred modes are 1873 * Assume that the preferred modes are
1798 * arranged in priority order. 1874 * arranged in priority order.
1799 */ 1875 */
1800 intel_ddc_get_modes(intel_output); 1876 intel_ddc_get_modes(intel_encoder);
1801 if (list_empty(&connector->probed_modes) == false) 1877 if (list_empty(&connector->probed_modes) == false)
1802 goto end; 1878 goto end;
1803 1879
@@ -1826,7 +1902,7 @@ end:
1826 1902
1827static int intel_sdvo_get_modes(struct drm_connector *connector) 1903static int intel_sdvo_get_modes(struct drm_connector *connector)
1828{ 1904{
1829 struct intel_output *output = to_intel_output(connector); 1905 struct intel_encoder *output = to_intel_encoder(connector);
1830 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1906 struct intel_sdvo_priv *sdvo_priv = output->dev_priv;
1831 1907
1832 if (sdvo_priv->is_tv) 1908 if (sdvo_priv->is_tv)
@@ -1844,8 +1920,8 @@ static int intel_sdvo_get_modes(struct drm_connector *connector)
1844static 1920static
1845void intel_sdvo_destroy_enhance_property(struct drm_connector *connector) 1921void intel_sdvo_destroy_enhance_property(struct drm_connector *connector)
1846{ 1922{
1847 struct intel_output *intel_output = to_intel_output(connector); 1923 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1848 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1924 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1849 struct drm_device *dev = connector->dev; 1925 struct drm_device *dev = connector->dev;
1850 1926
1851 if (sdvo_priv->is_tv) { 1927 if (sdvo_priv->is_tv) {
@@ -1882,13 +1958,13 @@ void intel_sdvo_destroy_enhance_property(struct drm_connector *connector)
1882 1958
1883static void intel_sdvo_destroy(struct drm_connector *connector) 1959static void intel_sdvo_destroy(struct drm_connector *connector)
1884{ 1960{
1885 struct intel_output *intel_output = to_intel_output(connector); 1961 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1886 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1962 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1887 1963
1888 if (intel_output->i2c_bus) 1964 if (intel_encoder->i2c_bus)
1889 intel_i2c_destroy(intel_output->i2c_bus); 1965 intel_i2c_destroy(intel_encoder->i2c_bus);
1890 if (intel_output->ddc_bus) 1966 if (intel_encoder->ddc_bus)
1891 intel_i2c_destroy(intel_output->ddc_bus); 1967 intel_i2c_destroy(intel_encoder->ddc_bus);
1892 if (sdvo_priv->analog_ddc_bus) 1968 if (sdvo_priv->analog_ddc_bus)
1893 intel_i2c_destroy(sdvo_priv->analog_ddc_bus); 1969 intel_i2c_destroy(sdvo_priv->analog_ddc_bus);
1894 1970
@@ -1906,7 +1982,7 @@ static void intel_sdvo_destroy(struct drm_connector *connector)
1906 drm_sysfs_connector_remove(connector); 1982 drm_sysfs_connector_remove(connector);
1907 drm_connector_cleanup(connector); 1983 drm_connector_cleanup(connector);
1908 1984
1909 kfree(intel_output); 1985 kfree(intel_encoder);
1910} 1986}
1911 1987
1912static int 1988static int
@@ -1914,9 +1990,9 @@ intel_sdvo_set_property(struct drm_connector *connector,
1914 struct drm_property *property, 1990 struct drm_property *property,
1915 uint64_t val) 1991 uint64_t val)
1916{ 1992{
1917 struct intel_output *intel_output = to_intel_output(connector); 1993 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
1918 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1994 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
1919 struct drm_encoder *encoder = &intel_output->enc; 1995 struct drm_encoder *encoder = &intel_encoder->enc;
1920 struct drm_crtc *crtc = encoder->crtc; 1996 struct drm_crtc *crtc = encoder->crtc;
1921 int ret = 0; 1997 int ret = 0;
1922 bool changed = false; 1998 bool changed = false;
@@ -2024,8 +2100,8 @@ intel_sdvo_set_property(struct drm_connector *connector,
2024 sdvo_priv->cur_brightness = temp_value; 2100 sdvo_priv->cur_brightness = temp_value;
2025 } 2101 }
2026 if (cmd) { 2102 if (cmd) {
2027 intel_sdvo_write_cmd(intel_output, cmd, &temp_value, 2); 2103 intel_sdvo_write_cmd(intel_encoder, cmd, &temp_value, 2);
2028 status = intel_sdvo_read_response(intel_output, 2104 status = intel_sdvo_read_response(intel_encoder,
2029 NULL, 0); 2105 NULL, 0);
2030 if (status != SDVO_CMD_STATUS_SUCCESS) { 2106 if (status != SDVO_CMD_STATUS_SUCCESS) {
2031 DRM_DEBUG_KMS("Incorrect SDVO command \n"); 2107 DRM_DEBUG_KMS("Incorrect SDVO command \n");
@@ -2120,7 +2196,7 @@ intel_sdvo_select_ddc_bus(struct intel_sdvo_priv *dev_priv)
2120} 2196}
2121 2197
2122static bool 2198static bool
2123intel_sdvo_get_digital_encoding_mode(struct intel_output *output) 2199intel_sdvo_get_digital_encoding_mode(struct intel_encoder *output)
2124{ 2200{
2125 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 2201 struct intel_sdvo_priv *sdvo_priv = output->dev_priv;
2126 uint8_t status; 2202 uint8_t status;
@@ -2134,42 +2210,42 @@ intel_sdvo_get_digital_encoding_mode(struct intel_output *output)
2134 return true; 2210 return true;
2135} 2211}
2136 2212
2137static struct intel_output * 2213static struct intel_encoder *
2138intel_sdvo_chan_to_intel_output(struct intel_i2c_chan *chan) 2214intel_sdvo_chan_to_intel_encoder(struct intel_i2c_chan *chan)
2139{ 2215{
2140 struct drm_device *dev = chan->drm_dev; 2216 struct drm_device *dev = chan->drm_dev;
2141 struct drm_connector *connector; 2217 struct drm_connector *connector;
2142 struct intel_output *intel_output = NULL; 2218 struct intel_encoder *intel_encoder = NULL;
2143 2219
2144 list_for_each_entry(connector, 2220 list_for_each_entry(connector,
2145 &dev->mode_config.connector_list, head) { 2221 &dev->mode_config.connector_list, head) {
2146 if (to_intel_output(connector)->ddc_bus == &chan->adapter) { 2222 if (to_intel_encoder(connector)->ddc_bus == &chan->adapter) {
2147 intel_output = to_intel_output(connector); 2223 intel_encoder = to_intel_encoder(connector);
2148 break; 2224 break;
2149 } 2225 }
2150 } 2226 }
2151 return intel_output; 2227 return intel_encoder;
2152} 2228}
2153 2229
2154static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap, 2230static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap,
2155 struct i2c_msg msgs[], int num) 2231 struct i2c_msg msgs[], int num)
2156{ 2232{
2157 struct intel_output *intel_output; 2233 struct intel_encoder *intel_encoder;
2158 struct intel_sdvo_priv *sdvo_priv; 2234 struct intel_sdvo_priv *sdvo_priv;
2159 struct i2c_algo_bit_data *algo_data; 2235 struct i2c_algo_bit_data *algo_data;
2160 const struct i2c_algorithm *algo; 2236 const struct i2c_algorithm *algo;
2161 2237
2162 algo_data = (struct i2c_algo_bit_data *)i2c_adap->algo_data; 2238 algo_data = (struct i2c_algo_bit_data *)i2c_adap->algo_data;
2163 intel_output = 2239 intel_encoder =
2164 intel_sdvo_chan_to_intel_output( 2240 intel_sdvo_chan_to_intel_encoder(
2165 (struct intel_i2c_chan *)(algo_data->data)); 2241 (struct intel_i2c_chan *)(algo_data->data));
2166 if (intel_output == NULL) 2242 if (intel_encoder == NULL)
2167 return -EINVAL; 2243 return -EINVAL;
2168 2244
2169 sdvo_priv = intel_output->dev_priv; 2245 sdvo_priv = intel_encoder->dev_priv;
2170 algo = intel_output->i2c_bus->algo; 2246 algo = intel_encoder->i2c_bus->algo;
2171 2247
2172 intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus); 2248 intel_sdvo_set_control_bus_switch(intel_encoder, sdvo_priv->ddc_bus);
2173 return algo->master_xfer(i2c_adap, msgs, num); 2249 return algo->master_xfer(i2c_adap, msgs, num);
2174} 2250}
2175 2251
@@ -2178,12 +2254,12 @@ static struct i2c_algorithm intel_sdvo_i2c_bit_algo = {
2178}; 2254};
2179 2255
2180static u8 2256static u8
2181intel_sdvo_get_slave_addr(struct drm_device *dev, int output_device) 2257intel_sdvo_get_slave_addr(struct drm_device *dev, int sdvo_reg)
2182{ 2258{
2183 struct drm_i915_private *dev_priv = dev->dev_private; 2259 struct drm_i915_private *dev_priv = dev->dev_private;
2184 struct sdvo_device_mapping *my_mapping, *other_mapping; 2260 struct sdvo_device_mapping *my_mapping, *other_mapping;
2185 2261
2186 if (output_device == SDVOB) { 2262 if (sdvo_reg == SDVOB) {
2187 my_mapping = &dev_priv->sdvo_mappings[0]; 2263 my_mapping = &dev_priv->sdvo_mappings[0];
2188 other_mapping = &dev_priv->sdvo_mappings[1]; 2264 other_mapping = &dev_priv->sdvo_mappings[1];
2189 } else { 2265 } else {
@@ -2208,22 +2284,41 @@ intel_sdvo_get_slave_addr(struct drm_device *dev, int output_device)
2208 /* No SDVO device info is found for another DVO port, 2284 /* No SDVO device info is found for another DVO port,
2209 * so use mapping assumption we had before BIOS parsing. 2285 * so use mapping assumption we had before BIOS parsing.
2210 */ 2286 */
2211 if (output_device == SDVOB) 2287 if (sdvo_reg == SDVOB)
2212 return 0x70; 2288 return 0x70;
2213 else 2289 else
2214 return 0x72; 2290 return 0x72;
2215} 2291}
2216 2292
2293static int intel_sdvo_bad_tv_callback(const struct dmi_system_id *id)
2294{
2295 DRM_DEBUG_KMS("Ignoring bad SDVO TV connector for %s\n", id->ident);
2296 return 1;
2297}
2298
2299static struct dmi_system_id intel_sdvo_bad_tv[] = {
2300 {
2301 .callback = intel_sdvo_bad_tv_callback,
2302 .ident = "IntelG45/ICH10R/DME1737",
2303 .matches = {
2304 DMI_MATCH(DMI_SYS_VENDOR, "IBM CORPORATION"),
2305 DMI_MATCH(DMI_PRODUCT_NAME, "4800784"),
2306 },
2307 },
2308
2309 { } /* terminating entry */
2310};
2311
2217static bool 2312static bool
2218intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags) 2313intel_sdvo_output_setup(struct intel_encoder *intel_encoder, uint16_t flags)
2219{ 2314{
2220 struct drm_connector *connector = &intel_output->base; 2315 struct drm_connector *connector = &intel_encoder->base;
2221 struct drm_encoder *encoder = &intel_output->enc; 2316 struct drm_encoder *encoder = &intel_encoder->enc;
2222 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 2317 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
2223 bool ret = true, registered = false; 2318 bool ret = true, registered = false;
2224 2319
2225 sdvo_priv->is_tv = false; 2320 sdvo_priv->is_tv = false;
2226 intel_output->needs_tv_clock = false; 2321 intel_encoder->needs_tv_clock = false;
2227 sdvo_priv->is_lvds = false; 2322 sdvo_priv->is_lvds = false;
2228 2323
2229 if (device_is_registered(&connector->kdev)) { 2324 if (device_is_registered(&connector->kdev)) {
@@ -2241,48 +2336,57 @@ intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags)
2241 encoder->encoder_type = DRM_MODE_ENCODER_TMDS; 2336 encoder->encoder_type = DRM_MODE_ENCODER_TMDS;
2242 connector->connector_type = DRM_MODE_CONNECTOR_DVID; 2337 connector->connector_type = DRM_MODE_CONNECTOR_DVID;
2243 2338
2244 if (intel_sdvo_get_supp_encode(intel_output, 2339 if (intel_sdvo_get_supp_encode(intel_encoder,
2245 &sdvo_priv->encode) && 2340 &sdvo_priv->encode) &&
2246 intel_sdvo_get_digital_encoding_mode(intel_output) && 2341 intel_sdvo_get_digital_encoding_mode(intel_encoder) &&
2247 sdvo_priv->is_hdmi) { 2342 sdvo_priv->is_hdmi) {
2248 /* enable hdmi encoding mode if supported */ 2343 /* enable hdmi encoding mode if supported */
2249 intel_sdvo_set_encode(intel_output, SDVO_ENCODE_HDMI); 2344 intel_sdvo_set_encode(intel_encoder, SDVO_ENCODE_HDMI);
2250 intel_sdvo_set_colorimetry(intel_output, 2345 intel_sdvo_set_colorimetry(intel_encoder,
2251 SDVO_COLORIMETRY_RGB256); 2346 SDVO_COLORIMETRY_RGB256);
2252 connector->connector_type = DRM_MODE_CONNECTOR_HDMIA; 2347 connector->connector_type = DRM_MODE_CONNECTOR_HDMIA;
2253 intel_output->clone_mask = 2348 intel_encoder->clone_mask =
2254 (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2349 (1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
2255 (1 << INTEL_ANALOG_CLONE_BIT); 2350 (1 << INTEL_ANALOG_CLONE_BIT);
2256 } 2351 }
2257 } else if (flags & SDVO_OUTPUT_SVID0) { 2352 } else if ((flags & SDVO_OUTPUT_SVID0) &&
2353 !dmi_check_system(intel_sdvo_bad_tv)) {
2258 2354
2259 sdvo_priv->controlled_output = SDVO_OUTPUT_SVID0; 2355 sdvo_priv->controlled_output = SDVO_OUTPUT_SVID0;
2260 encoder->encoder_type = DRM_MODE_ENCODER_TVDAC; 2356 encoder->encoder_type = DRM_MODE_ENCODER_TVDAC;
2261 connector->connector_type = DRM_MODE_CONNECTOR_SVIDEO; 2357 connector->connector_type = DRM_MODE_CONNECTOR_SVIDEO;
2262 sdvo_priv->is_tv = true; 2358 sdvo_priv->is_tv = true;
2263 intel_output->needs_tv_clock = true; 2359 intel_encoder->needs_tv_clock = true;
2264 intel_output->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT; 2360 intel_encoder->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT;
2265 } else if (flags & SDVO_OUTPUT_RGB0) { 2361 } else if (flags & SDVO_OUTPUT_RGB0) {
2266 2362
2267 sdvo_priv->controlled_output = SDVO_OUTPUT_RGB0; 2363 sdvo_priv->controlled_output = SDVO_OUTPUT_RGB0;
2268 encoder->encoder_type = DRM_MODE_ENCODER_DAC; 2364 encoder->encoder_type = DRM_MODE_ENCODER_DAC;
2269 connector->connector_type = DRM_MODE_CONNECTOR_VGA; 2365 connector->connector_type = DRM_MODE_CONNECTOR_VGA;
2270 intel_output->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2366 intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
2271 (1 << INTEL_ANALOG_CLONE_BIT); 2367 (1 << INTEL_ANALOG_CLONE_BIT);
2272 } else if (flags & SDVO_OUTPUT_RGB1) { 2368 } else if (flags & SDVO_OUTPUT_RGB1) {
2273 2369
2274 sdvo_priv->controlled_output = SDVO_OUTPUT_RGB1; 2370 sdvo_priv->controlled_output = SDVO_OUTPUT_RGB1;
2275 encoder->encoder_type = DRM_MODE_ENCODER_DAC; 2371 encoder->encoder_type = DRM_MODE_ENCODER_DAC;
2276 connector->connector_type = DRM_MODE_CONNECTOR_VGA; 2372 connector->connector_type = DRM_MODE_CONNECTOR_VGA;
2277 intel_output->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2373 intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
2278 (1 << INTEL_ANALOG_CLONE_BIT); 2374 (1 << INTEL_ANALOG_CLONE_BIT);
2375 } else if (flags & SDVO_OUTPUT_CVBS0) {
2376
2377 sdvo_priv->controlled_output = SDVO_OUTPUT_CVBS0;
2378 encoder->encoder_type = DRM_MODE_ENCODER_TVDAC;
2379 connector->connector_type = DRM_MODE_CONNECTOR_SVIDEO;
2380 sdvo_priv->is_tv = true;
2381 intel_encoder->needs_tv_clock = true;
2382 intel_encoder->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT;
2279 } else if (flags & SDVO_OUTPUT_LVDS0) { 2383 } else if (flags & SDVO_OUTPUT_LVDS0) {
2280 2384
2281 sdvo_priv->controlled_output = SDVO_OUTPUT_LVDS0; 2385 sdvo_priv->controlled_output = SDVO_OUTPUT_LVDS0;
2282 encoder->encoder_type = DRM_MODE_ENCODER_LVDS; 2386 encoder->encoder_type = DRM_MODE_ENCODER_LVDS;
2283 connector->connector_type = DRM_MODE_CONNECTOR_LVDS; 2387 connector->connector_type = DRM_MODE_CONNECTOR_LVDS;
2284 sdvo_priv->is_lvds = true; 2388 sdvo_priv->is_lvds = true;
2285 intel_output->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) | 2389 intel_encoder->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) |
2286 (1 << INTEL_SDVO_LVDS_CLONE_BIT); 2390 (1 << INTEL_SDVO_LVDS_CLONE_BIT);
2287 } else if (flags & SDVO_OUTPUT_LVDS1) { 2391 } else if (flags & SDVO_OUTPUT_LVDS1) {
2288 2392
@@ -2290,7 +2394,7 @@ intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags)
2290 encoder->encoder_type = DRM_MODE_ENCODER_LVDS; 2394 encoder->encoder_type = DRM_MODE_ENCODER_LVDS;
2291 connector->connector_type = DRM_MODE_CONNECTOR_LVDS; 2395 connector->connector_type = DRM_MODE_CONNECTOR_LVDS;
2292 sdvo_priv->is_lvds = true; 2396 sdvo_priv->is_lvds = true;
2293 intel_output->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) | 2397 intel_encoder->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) |
2294 (1 << INTEL_SDVO_LVDS_CLONE_BIT); 2398 (1 << INTEL_SDVO_LVDS_CLONE_BIT);
2295 } else { 2399 } else {
2296 2400
@@ -2303,7 +2407,7 @@ intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags)
2303 bytes[0], bytes[1]); 2407 bytes[0], bytes[1]);
2304 ret = false; 2408 ret = false;
2305 } 2409 }
2306 intel_output->crtc_mask = (1 << 0) | (1 << 1); 2410 intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
2307 2411
2308 if (ret && registered) 2412 if (ret && registered)
2309 ret = drm_sysfs_connector_add(connector) == 0 ? true : false; 2413 ret = drm_sysfs_connector_add(connector) == 0 ? true : false;
@@ -2315,18 +2419,18 @@ intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags)
2315 2419
2316static void intel_sdvo_tv_create_property(struct drm_connector *connector) 2420static void intel_sdvo_tv_create_property(struct drm_connector *connector)
2317{ 2421{
2318 struct intel_output *intel_output = to_intel_output(connector); 2422 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
2319 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 2423 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
2320 struct intel_sdvo_tv_format format; 2424 struct intel_sdvo_tv_format format;
2321 uint32_t format_map, i; 2425 uint32_t format_map, i;
2322 uint8_t status; 2426 uint8_t status;
2323 2427
2324 intel_sdvo_set_target_output(intel_output, 2428 intel_sdvo_set_target_output(intel_encoder,
2325 sdvo_priv->controlled_output); 2429 sdvo_priv->controlled_output);
2326 2430
2327 intel_sdvo_write_cmd(intel_output, 2431 intel_sdvo_write_cmd(intel_encoder,
2328 SDVO_CMD_GET_SUPPORTED_TV_FORMATS, NULL, 0); 2432 SDVO_CMD_GET_SUPPORTED_TV_FORMATS, NULL, 0);
2329 status = intel_sdvo_read_response(intel_output, 2433 status = intel_sdvo_read_response(intel_encoder,
2330 &format, sizeof(format)); 2434 &format, sizeof(format));
2331 if (status != SDVO_CMD_STATUS_SUCCESS) 2435 if (status != SDVO_CMD_STATUS_SUCCESS)
2332 return; 2436 return;
@@ -2364,16 +2468,16 @@ static void intel_sdvo_tv_create_property(struct drm_connector *connector)
2364 2468
2365static void intel_sdvo_create_enhance_property(struct drm_connector *connector) 2469static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2366{ 2470{
2367 struct intel_output *intel_output = to_intel_output(connector); 2471 struct intel_encoder *intel_encoder = to_intel_encoder(connector);
2368 struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 2472 struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv;
2369 struct intel_sdvo_enhancements_reply sdvo_data; 2473 struct intel_sdvo_enhancements_reply sdvo_data;
2370 struct drm_device *dev = connector->dev; 2474 struct drm_device *dev = connector->dev;
2371 uint8_t status; 2475 uint8_t status;
2372 uint16_t response, data_value[2]; 2476 uint16_t response, data_value[2];
2373 2477
2374 intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS, 2478 intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS,
2375 NULL, 0); 2479 NULL, 0);
2376 status = intel_sdvo_read_response(intel_output, &sdvo_data, 2480 status = intel_sdvo_read_response(intel_encoder, &sdvo_data,
2377 sizeof(sdvo_data)); 2481 sizeof(sdvo_data));
2378 if (status != SDVO_CMD_STATUS_SUCCESS) { 2482 if (status != SDVO_CMD_STATUS_SUCCESS) {
2379 DRM_DEBUG_KMS(" incorrect response is returned\n"); 2483 DRM_DEBUG_KMS(" incorrect response is returned\n");
@@ -2389,18 +2493,18 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2389 * property 2493 * property
2390 */ 2494 */
2391 if (sdvo_data.overscan_h) { 2495 if (sdvo_data.overscan_h) {
2392 intel_sdvo_write_cmd(intel_output, 2496 intel_sdvo_write_cmd(intel_encoder,
2393 SDVO_CMD_GET_MAX_OVERSCAN_H, NULL, 0); 2497 SDVO_CMD_GET_MAX_OVERSCAN_H, NULL, 0);
2394 status = intel_sdvo_read_response(intel_output, 2498 status = intel_sdvo_read_response(intel_encoder,
2395 &data_value, 4); 2499 &data_value, 4);
2396 if (status != SDVO_CMD_STATUS_SUCCESS) { 2500 if (status != SDVO_CMD_STATUS_SUCCESS) {
2397 DRM_DEBUG_KMS("Incorrect SDVO max " 2501 DRM_DEBUG_KMS("Incorrect SDVO max "
2398 "h_overscan\n"); 2502 "h_overscan\n");
2399 return; 2503 return;
2400 } 2504 }
2401 intel_sdvo_write_cmd(intel_output, 2505 intel_sdvo_write_cmd(intel_encoder,
2402 SDVO_CMD_GET_OVERSCAN_H, NULL, 0); 2506 SDVO_CMD_GET_OVERSCAN_H, NULL, 0);
2403 status = intel_sdvo_read_response(intel_output, 2507 status = intel_sdvo_read_response(intel_encoder,
2404 &response, 2); 2508 &response, 2);
2405 if (status != SDVO_CMD_STATUS_SUCCESS) { 2509 if (status != SDVO_CMD_STATUS_SUCCESS) {
2406 DRM_DEBUG_KMS("Incorrect SDVO h_overscan\n"); 2510 DRM_DEBUG_KMS("Incorrect SDVO h_overscan\n");
@@ -2430,18 +2534,18 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2430 data_value[0], data_value[1], response); 2534 data_value[0], data_value[1], response);
2431 } 2535 }
2432 if (sdvo_data.overscan_v) { 2536 if (sdvo_data.overscan_v) {
2433 intel_sdvo_write_cmd(intel_output, 2537 intel_sdvo_write_cmd(intel_encoder,
2434 SDVO_CMD_GET_MAX_OVERSCAN_V, NULL, 0); 2538 SDVO_CMD_GET_MAX_OVERSCAN_V, NULL, 0);
2435 status = intel_sdvo_read_response(intel_output, 2539 status = intel_sdvo_read_response(intel_encoder,
2436 &data_value, 4); 2540 &data_value, 4);
2437 if (status != SDVO_CMD_STATUS_SUCCESS) { 2541 if (status != SDVO_CMD_STATUS_SUCCESS) {
2438 DRM_DEBUG_KMS("Incorrect SDVO max " 2542 DRM_DEBUG_KMS("Incorrect SDVO max "
2439 "v_overscan\n"); 2543 "v_overscan\n");
2440 return; 2544 return;
2441 } 2545 }
2442 intel_sdvo_write_cmd(intel_output, 2546 intel_sdvo_write_cmd(intel_encoder,
2443 SDVO_CMD_GET_OVERSCAN_V, NULL, 0); 2547 SDVO_CMD_GET_OVERSCAN_V, NULL, 0);
2444 status = intel_sdvo_read_response(intel_output, 2548 status = intel_sdvo_read_response(intel_encoder,
2445 &response, 2); 2549 &response, 2);
2446 if (status != SDVO_CMD_STATUS_SUCCESS) { 2550 if (status != SDVO_CMD_STATUS_SUCCESS) {
2447 DRM_DEBUG_KMS("Incorrect SDVO v_overscan\n"); 2551 DRM_DEBUG_KMS("Incorrect SDVO v_overscan\n");
@@ -2471,17 +2575,17 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2471 data_value[0], data_value[1], response); 2575 data_value[0], data_value[1], response);
2472 } 2576 }
2473 if (sdvo_data.position_h) { 2577 if (sdvo_data.position_h) {
2474 intel_sdvo_write_cmd(intel_output, 2578 intel_sdvo_write_cmd(intel_encoder,
2475 SDVO_CMD_GET_MAX_POSITION_H, NULL, 0); 2579 SDVO_CMD_GET_MAX_POSITION_H, NULL, 0);
2476 status = intel_sdvo_read_response(intel_output, 2580 status = intel_sdvo_read_response(intel_encoder,
2477 &data_value, 4); 2581 &data_value, 4);
2478 if (status != SDVO_CMD_STATUS_SUCCESS) { 2582 if (status != SDVO_CMD_STATUS_SUCCESS) {
2479 DRM_DEBUG_KMS("Incorrect SDVO Max h_pos\n"); 2583 DRM_DEBUG_KMS("Incorrect SDVO Max h_pos\n");
2480 return; 2584 return;
2481 } 2585 }
2482 intel_sdvo_write_cmd(intel_output, 2586 intel_sdvo_write_cmd(intel_encoder,
2483 SDVO_CMD_GET_POSITION_H, NULL, 0); 2587 SDVO_CMD_GET_POSITION_H, NULL, 0);
2484 status = intel_sdvo_read_response(intel_output, 2588 status = intel_sdvo_read_response(intel_encoder,
2485 &response, 2); 2589 &response, 2);
2486 if (status != SDVO_CMD_STATUS_SUCCESS) { 2590 if (status != SDVO_CMD_STATUS_SUCCESS) {
2487 DRM_DEBUG_KMS("Incorrect SDVO get h_postion\n"); 2591 DRM_DEBUG_KMS("Incorrect SDVO get h_postion\n");
@@ -2502,17 +2606,17 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2502 data_value[0], data_value[1], response); 2606 data_value[0], data_value[1], response);
2503 } 2607 }
2504 if (sdvo_data.position_v) { 2608 if (sdvo_data.position_v) {
2505 intel_sdvo_write_cmd(intel_output, 2609 intel_sdvo_write_cmd(intel_encoder,
2506 SDVO_CMD_GET_MAX_POSITION_V, NULL, 0); 2610 SDVO_CMD_GET_MAX_POSITION_V, NULL, 0);
2507 status = intel_sdvo_read_response(intel_output, 2611 status = intel_sdvo_read_response(intel_encoder,
2508 &data_value, 4); 2612 &data_value, 4);
2509 if (status != SDVO_CMD_STATUS_SUCCESS) { 2613 if (status != SDVO_CMD_STATUS_SUCCESS) {
2510 DRM_DEBUG_KMS("Incorrect SDVO Max v_pos\n"); 2614 DRM_DEBUG_KMS("Incorrect SDVO Max v_pos\n");
2511 return; 2615 return;
2512 } 2616 }
2513 intel_sdvo_write_cmd(intel_output, 2617 intel_sdvo_write_cmd(intel_encoder,
2514 SDVO_CMD_GET_POSITION_V, NULL, 0); 2618 SDVO_CMD_GET_POSITION_V, NULL, 0);
2515 status = intel_sdvo_read_response(intel_output, 2619 status = intel_sdvo_read_response(intel_encoder,
2516 &response, 2); 2620 &response, 2);
2517 if (status != SDVO_CMD_STATUS_SUCCESS) { 2621 if (status != SDVO_CMD_STATUS_SUCCESS) {
2518 DRM_DEBUG_KMS("Incorrect SDVO get v_postion\n"); 2622 DRM_DEBUG_KMS("Incorrect SDVO get v_postion\n");
@@ -2535,17 +2639,17 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2535 } 2639 }
2536 if (sdvo_priv->is_tv) { 2640 if (sdvo_priv->is_tv) {
2537 if (sdvo_data.saturation) { 2641 if (sdvo_data.saturation) {
2538 intel_sdvo_write_cmd(intel_output, 2642 intel_sdvo_write_cmd(intel_encoder,
2539 SDVO_CMD_GET_MAX_SATURATION, NULL, 0); 2643 SDVO_CMD_GET_MAX_SATURATION, NULL, 0);
2540 status = intel_sdvo_read_response(intel_output, 2644 status = intel_sdvo_read_response(intel_encoder,
2541 &data_value, 4); 2645 &data_value, 4);
2542 if (status != SDVO_CMD_STATUS_SUCCESS) { 2646 if (status != SDVO_CMD_STATUS_SUCCESS) {
2543 DRM_DEBUG_KMS("Incorrect SDVO Max sat\n"); 2647 DRM_DEBUG_KMS("Incorrect SDVO Max sat\n");
2544 return; 2648 return;
2545 } 2649 }
2546 intel_sdvo_write_cmd(intel_output, 2650 intel_sdvo_write_cmd(intel_encoder,
2547 SDVO_CMD_GET_SATURATION, NULL, 0); 2651 SDVO_CMD_GET_SATURATION, NULL, 0);
2548 status = intel_sdvo_read_response(intel_output, 2652 status = intel_sdvo_read_response(intel_encoder,
2549 &response, 2); 2653 &response, 2);
2550 if (status != SDVO_CMD_STATUS_SUCCESS) { 2654 if (status != SDVO_CMD_STATUS_SUCCESS) {
2551 DRM_DEBUG_KMS("Incorrect SDVO get sat\n"); 2655 DRM_DEBUG_KMS("Incorrect SDVO get sat\n");
@@ -2567,17 +2671,17 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2567 data_value[0], data_value[1], response); 2671 data_value[0], data_value[1], response);
2568 } 2672 }
2569 if (sdvo_data.contrast) { 2673 if (sdvo_data.contrast) {
2570 intel_sdvo_write_cmd(intel_output, 2674 intel_sdvo_write_cmd(intel_encoder,
2571 SDVO_CMD_GET_MAX_CONTRAST, NULL, 0); 2675 SDVO_CMD_GET_MAX_CONTRAST, NULL, 0);
2572 status = intel_sdvo_read_response(intel_output, 2676 status = intel_sdvo_read_response(intel_encoder,
2573 &data_value, 4); 2677 &data_value, 4);
2574 if (status != SDVO_CMD_STATUS_SUCCESS) { 2678 if (status != SDVO_CMD_STATUS_SUCCESS) {
2575 DRM_DEBUG_KMS("Incorrect SDVO Max contrast\n"); 2679 DRM_DEBUG_KMS("Incorrect SDVO Max contrast\n");
2576 return; 2680 return;
2577 } 2681 }
2578 intel_sdvo_write_cmd(intel_output, 2682 intel_sdvo_write_cmd(intel_encoder,
2579 SDVO_CMD_GET_CONTRAST, NULL, 0); 2683 SDVO_CMD_GET_CONTRAST, NULL, 0);
2580 status = intel_sdvo_read_response(intel_output, 2684 status = intel_sdvo_read_response(intel_encoder,
2581 &response, 2); 2685 &response, 2);
2582 if (status != SDVO_CMD_STATUS_SUCCESS) { 2686 if (status != SDVO_CMD_STATUS_SUCCESS) {
2583 DRM_DEBUG_KMS("Incorrect SDVO get contrast\n"); 2687 DRM_DEBUG_KMS("Incorrect SDVO get contrast\n");
@@ -2598,17 +2702,17 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2598 data_value[0], data_value[1], response); 2702 data_value[0], data_value[1], response);
2599 } 2703 }
2600 if (sdvo_data.hue) { 2704 if (sdvo_data.hue) {
2601 intel_sdvo_write_cmd(intel_output, 2705 intel_sdvo_write_cmd(intel_encoder,
2602 SDVO_CMD_GET_MAX_HUE, NULL, 0); 2706 SDVO_CMD_GET_MAX_HUE, NULL, 0);
2603 status = intel_sdvo_read_response(intel_output, 2707 status = intel_sdvo_read_response(intel_encoder,
2604 &data_value, 4); 2708 &data_value, 4);
2605 if (status != SDVO_CMD_STATUS_SUCCESS) { 2709 if (status != SDVO_CMD_STATUS_SUCCESS) {
2606 DRM_DEBUG_KMS("Incorrect SDVO Max hue\n"); 2710 DRM_DEBUG_KMS("Incorrect SDVO Max hue\n");
2607 return; 2711 return;
2608 } 2712 }
2609 intel_sdvo_write_cmd(intel_output, 2713 intel_sdvo_write_cmd(intel_encoder,
2610 SDVO_CMD_GET_HUE, NULL, 0); 2714 SDVO_CMD_GET_HUE, NULL, 0);
2611 status = intel_sdvo_read_response(intel_output, 2715 status = intel_sdvo_read_response(intel_encoder,
2612 &response, 2); 2716 &response, 2);
2613 if (status != SDVO_CMD_STATUS_SUCCESS) { 2717 if (status != SDVO_CMD_STATUS_SUCCESS) {
2614 DRM_DEBUG_KMS("Incorrect SDVO get hue\n"); 2718 DRM_DEBUG_KMS("Incorrect SDVO get hue\n");
@@ -2631,17 +2735,17 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2631 } 2735 }
2632 if (sdvo_priv->is_tv || sdvo_priv->is_lvds) { 2736 if (sdvo_priv->is_tv || sdvo_priv->is_lvds) {
2633 if (sdvo_data.brightness) { 2737 if (sdvo_data.brightness) {
2634 intel_sdvo_write_cmd(intel_output, 2738 intel_sdvo_write_cmd(intel_encoder,
2635 SDVO_CMD_GET_MAX_BRIGHTNESS, NULL, 0); 2739 SDVO_CMD_GET_MAX_BRIGHTNESS, NULL, 0);
2636 status = intel_sdvo_read_response(intel_output, 2740 status = intel_sdvo_read_response(intel_encoder,
2637 &data_value, 4); 2741 &data_value, 4);
2638 if (status != SDVO_CMD_STATUS_SUCCESS) { 2742 if (status != SDVO_CMD_STATUS_SUCCESS) {
2639 DRM_DEBUG_KMS("Incorrect SDVO Max bright\n"); 2743 DRM_DEBUG_KMS("Incorrect SDVO Max bright\n");
2640 return; 2744 return;
2641 } 2745 }
2642 intel_sdvo_write_cmd(intel_output, 2746 intel_sdvo_write_cmd(intel_encoder,
2643 SDVO_CMD_GET_BRIGHTNESS, NULL, 0); 2747 SDVO_CMD_GET_BRIGHTNESS, NULL, 0);
2644 status = intel_sdvo_read_response(intel_output, 2748 status = intel_sdvo_read_response(intel_encoder,
2645 &response, 2); 2749 &response, 2);
2646 if (status != SDVO_CMD_STATUS_SUCCESS) { 2750 if (status != SDVO_CMD_STATUS_SUCCESS) {
2647 DRM_DEBUG_KMS("Incorrect SDVO get brigh\n"); 2751 DRM_DEBUG_KMS("Incorrect SDVO get brigh\n");
@@ -2666,78 +2770,81 @@ static void intel_sdvo_create_enhance_property(struct drm_connector *connector)
2666 return; 2770 return;
2667} 2771}
2668 2772
2669bool intel_sdvo_init(struct drm_device *dev, int output_device) 2773bool intel_sdvo_init(struct drm_device *dev, int sdvo_reg)
2670{ 2774{
2775 struct drm_i915_private *dev_priv = dev->dev_private;
2671 struct drm_connector *connector; 2776 struct drm_connector *connector;
2672 struct intel_output *intel_output; 2777 struct intel_encoder *intel_encoder;
2673 struct intel_sdvo_priv *sdvo_priv; 2778 struct intel_sdvo_priv *sdvo_priv;
2674 2779
2675 u8 ch[0x40]; 2780 u8 ch[0x40];
2676 int i; 2781 int i;
2677 2782
2678 intel_output = kcalloc(sizeof(struct intel_output)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL); 2783 intel_encoder = kcalloc(sizeof(struct intel_encoder)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL);
2679 if (!intel_output) { 2784 if (!intel_encoder) {
2680 return false; 2785 return false;
2681 } 2786 }
2682 2787
2683 sdvo_priv = (struct intel_sdvo_priv *)(intel_output + 1); 2788 sdvo_priv = (struct intel_sdvo_priv *)(intel_encoder + 1);
2684 sdvo_priv->output_device = output_device; 2789 sdvo_priv->sdvo_reg = sdvo_reg;
2685 2790
2686 intel_output->dev_priv = sdvo_priv; 2791 intel_encoder->dev_priv = sdvo_priv;
2687 intel_output->type = INTEL_OUTPUT_SDVO; 2792 intel_encoder->type = INTEL_OUTPUT_SDVO;
2688 2793
2689 /* setup the DDC bus. */ 2794 /* setup the DDC bus. */
2690 if (output_device == SDVOB) 2795 if (sdvo_reg == SDVOB)
2691 intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB"); 2796 intel_encoder->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB");
2692 else 2797 else
2693 intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC"); 2798 intel_encoder->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC");
2694 2799
2695 if (!intel_output->i2c_bus) 2800 if (!intel_encoder->i2c_bus)
2696 goto err_inteloutput; 2801 goto err_inteloutput;
2697 2802
2698 sdvo_priv->slave_addr = intel_sdvo_get_slave_addr(dev, output_device); 2803 sdvo_priv->slave_addr = intel_sdvo_get_slave_addr(dev, sdvo_reg);
2699 2804
2700 /* Save the bit-banging i2c functionality for use by the DDC wrapper */ 2805 /* Save the bit-banging i2c functionality for use by the DDC wrapper */
2701 intel_sdvo_i2c_bit_algo.functionality = intel_output->i2c_bus->algo->functionality; 2806 intel_sdvo_i2c_bit_algo.functionality = intel_encoder->i2c_bus->algo->functionality;
2702 2807
2703 /* Read the regs to test if we can talk to the device */ 2808 /* Read the regs to test if we can talk to the device */
2704 for (i = 0; i < 0x40; i++) { 2809 for (i = 0; i < 0x40; i++) {
2705 if (!intel_sdvo_read_byte(intel_output, i, &ch[i])) { 2810 if (!intel_sdvo_read_byte(intel_encoder, i, &ch[i])) {
2706 DRM_DEBUG_KMS("No SDVO device found on SDVO%c\n", 2811 DRM_DEBUG_KMS("No SDVO device found on SDVO%c\n",
2707 output_device == SDVOB ? 'B' : 'C'); 2812 sdvo_reg == SDVOB ? 'B' : 'C');
2708 goto err_i2c; 2813 goto err_i2c;
2709 } 2814 }
2710 } 2815 }
2711 2816
2712 /* setup the DDC bus. */ 2817 /* setup the DDC bus. */
2713 if (output_device == SDVOB) { 2818 if (sdvo_reg == SDVOB) {
2714 intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS"); 2819 intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS");
2715 sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, GPIOA, 2820 sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, GPIOA,
2716 "SDVOB/VGA DDC BUS"); 2821 "SDVOB/VGA DDC BUS");
2822 dev_priv->hotplug_supported_mask |= SDVOB_HOTPLUG_INT_STATUS;
2717 } else { 2823 } else {
2718 intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS"); 2824 intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS");
2719 sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, GPIOA, 2825 sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, GPIOA,
2720 "SDVOC/VGA DDC BUS"); 2826 "SDVOC/VGA DDC BUS");
2827 dev_priv->hotplug_supported_mask |= SDVOC_HOTPLUG_INT_STATUS;
2721 } 2828 }
2722 2829
2723 if (intel_output->ddc_bus == NULL) 2830 if (intel_encoder->ddc_bus == NULL)
2724 goto err_i2c; 2831 goto err_i2c;
2725 2832
2726 /* Wrap with our custom algo which switches to DDC mode */ 2833 /* Wrap with our custom algo which switches to DDC mode */
2727 intel_output->ddc_bus->algo = &intel_sdvo_i2c_bit_algo; 2834 intel_encoder->ddc_bus->algo = &intel_sdvo_i2c_bit_algo;
2728 2835
2729 /* In defaut case sdvo lvds is false */ 2836 /* In default case sdvo lvds is false */
2730 intel_sdvo_get_capabilities(intel_output, &sdvo_priv->caps); 2837 intel_sdvo_get_capabilities(intel_encoder, &sdvo_priv->caps);
2731 2838
2732 if (intel_sdvo_output_setup(intel_output, 2839 if (intel_sdvo_output_setup(intel_encoder,
2733 sdvo_priv->caps.output_flags) != true) { 2840 sdvo_priv->caps.output_flags) != true) {
2734 DRM_DEBUG_KMS("SDVO output failed to setup on SDVO%c\n", 2841 DRM_DEBUG_KMS("SDVO output failed to setup on SDVO%c\n",
2735 output_device == SDVOB ? 'B' : 'C'); 2842 sdvo_reg == SDVOB ? 'B' : 'C');
2736 goto err_i2c; 2843 goto err_i2c;
2737 } 2844 }
2738 2845
2739 2846
2740 connector = &intel_output->base; 2847 connector = &intel_encoder->base;
2741 drm_connector_init(dev, connector, &intel_sdvo_connector_funcs, 2848 drm_connector_init(dev, connector, &intel_sdvo_connector_funcs,
2742 connector->connector_type); 2849 connector->connector_type);
2743 2850
@@ -2746,12 +2853,12 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
2746 connector->doublescan_allowed = 0; 2853 connector->doublescan_allowed = 0;
2747 connector->display_info.subpixel_order = SubPixelHorizontalRGB; 2854 connector->display_info.subpixel_order = SubPixelHorizontalRGB;
2748 2855
2749 drm_encoder_init(dev, &intel_output->enc, 2856 drm_encoder_init(dev, &intel_encoder->enc,
2750 &intel_sdvo_enc_funcs, intel_output->enc.encoder_type); 2857 &intel_sdvo_enc_funcs, intel_encoder->enc.encoder_type);
2751 2858
2752 drm_encoder_helper_add(&intel_output->enc, &intel_sdvo_helper_funcs); 2859 drm_encoder_helper_add(&intel_encoder->enc, &intel_sdvo_helper_funcs);
2753 2860
2754 drm_mode_connector_attach_encoder(&intel_output->base, &intel_output->enc); 2861 drm_mode_connector_attach_encoder(&intel_encoder->base, &intel_encoder->enc);
2755 if (sdvo_priv->is_tv) 2862 if (sdvo_priv->is_tv)
2756 intel_sdvo_tv_create_property(connector); 2863 intel_sdvo_tv_create_property(connector);
2757 2864
@@ -2763,9 +2870,9 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
2763 intel_sdvo_select_ddc_bus(sdvo_priv); 2870 intel_sdvo_select_ddc_bus(sdvo_priv);
2764 2871
2765 /* Set the input timing to the screen. Assume always input 0. */ 2872 /* Set the input timing to the screen. Assume always input 0. */
2766 intel_sdvo_set_target_input(intel_output, true, false); 2873 intel_sdvo_set_target_input(intel_encoder, true, false);
2767 2874
2768 intel_sdvo_get_input_pixel_clock_range(intel_output, 2875 intel_sdvo_get_input_pixel_clock_range(intel_encoder,
2769 &sdvo_priv->pixel_clock_min, 2876 &sdvo_priv->pixel_clock_min,
2770 &sdvo_priv->pixel_clock_max); 2877 &sdvo_priv->pixel_clock_max);
2771 2878
@@ -2792,12 +2899,12 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
2792err_i2c: 2899err_i2c:
2793 if (sdvo_priv->analog_ddc_bus != NULL) 2900 if (sdvo_priv->analog_ddc_bus != NULL)
2794 intel_i2c_destroy(sdvo_priv->analog_ddc_bus); 2901 intel_i2c_destroy(sdvo_priv->analog_ddc_bus);
2795 if (intel_output->ddc_bus != NULL) 2902 if (intel_encoder->ddc_bus != NULL)
2796 intel_i2c_destroy(intel_output->ddc_bus); 2903 intel_i2c_destroy(intel_encoder->ddc_bus);
2797 if (intel_output->i2c_bus != NULL) 2904 if (intel_encoder->i2c_bus != NULL)
2798 intel_i2c_destroy(intel_output->i2c_bus); 2905 intel_i2c_destroy(intel_encoder->i2c_bus);
2799err_inteloutput: 2906err_inteloutput:
2800 kfree(intel_output); 2907 kfree(intel_encoder);
2801 2908
2802 return false; 2909 return false;
2803} 2910}
generated by cgit v1.2.2 (git 2.25.0) at 2025-07-13 01:32:52 -0400