summaryrefslogtreecommitdiff
path: root/linux-core/intel_sdvo.c
diff options
context:
space:
mode:
authorDave Airlie <airlied@redhat.com>2008-06-02 12:58:10 +1000
committerDave Airlie <airlied@redhat.com>2008-06-02 12:58:10 +1000
commiteba6cdc936cb33d929997ccb9bade6f75bb40670 (patch)
tree8fc95131e711155fe4e5613e5c0029cf71054e5e /linux-core/intel_sdvo.c
parentefb48c6cf7bbb57e7b2ea6ce7671905e84384963 (diff)
parent7fec6c0e2a2457925b88ed3bd70d9defde77b81b (diff)
Merge branch 'modesetting-101-encoders' into modesetting-101
Diffstat (limited to 'linux-core/intel_sdvo.c')
-rw-r--r--linux-core/intel_sdvo.c411
1 files changed, 214 insertions, 197 deletions
diff --git a/linux-core/intel_sdvo.c b/linux-core/intel_sdvo.c
index f4b1c6ef..9ae0d567 100644
--- a/linux-core/intel_sdvo.c
+++ b/linux-core/intel_sdvo.c
@@ -60,11 +60,10 @@ struct intel_sdvo_priv {
* SDVOB and SDVOC to work around apparent hardware issues (according to
* comments in the BIOS).
*/
-void intel_sdvo_write_sdvox(struct drm_output *output, u32 val)
+void intel_sdvo_write_sdvox(struct intel_output *intel_output, u32 val)
{
- struct drm_device *dev = output->dev;
+ struct drm_device *dev = intel_output->base.dev;
struct drm_i915_private *dev_priv = dev->dev_private;
- struct intel_output *intel_output = to_intel_output(output);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
u32 bval = val, cval = val;
int i;
@@ -88,10 +87,9 @@ void intel_sdvo_write_sdvox(struct drm_output *output, u32 val)
}
}
-static bool intel_sdvo_read_byte(struct drm_output *output, u8 addr,
+static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
u8 *ch)
{
- struct intel_output *intel_output = to_intel_output(output);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
u8 out_buf[2];
u8 buf[2];
@@ -126,10 +124,9 @@ static bool intel_sdvo_read_byte(struct drm_output *output, u8 addr,
return false;
}
-static bool intel_sdvo_write_byte(struct drm_output *output, int addr,
+static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr,
u8 ch)
{
- struct intel_output *intel_output = to_intel_output(output);
u8 out_buf[2];
struct i2c_msg msgs[] = {
{
@@ -198,10 +195,9 @@ const static struct _sdvo_cmd_name {
#define SDVO_NAME(dev_priv) ((dev_priv)->output_device == SDVOB ? "SDVOB" : "SDVOC")
#define SDVO_PRIV(output) ((struct intel_sdvo_priv *) (output)->dev_priv)
-static void intel_sdvo_write_cmd(struct drm_output *output, u8 cmd,
+static void intel_sdvo_write_cmd(struct intel_output *intel_output, u8 cmd,
void *args, int args_len)
{
- struct intel_output *intel_output = to_intel_output(output);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
int i;
@@ -223,10 +219,10 @@ static void intel_sdvo_write_cmd(struct drm_output *output, u8 cmd,
}
for (i = 0; i < args_len; i++) {
- intel_sdvo_write_byte(output, SDVO_I2C_ARG_0 - i, ((u8*)args)[i]);
+ intel_sdvo_write_byte(intel_output, SDVO_I2C_ARG_0 - i, ((u8*)args)[i]);
}
- intel_sdvo_write_byte(output, SDVO_I2C_OPCODE, cmd);
+ intel_sdvo_write_byte(intel_output, SDVO_I2C_OPCODE, cmd);
}
static const char *cmd_status_names[] = {
@@ -239,10 +235,9 @@ static const char *cmd_status_names[] = {
"Scaling not supported"
};
-static u8 intel_sdvo_read_response(struct drm_output *output, void *response,
+static u8 intel_sdvo_read_response(struct intel_output *intel_output, void *response,
int response_len)
{
- struct intel_output *intel_output = to_intel_output(output);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
int i;
u8 status;
@@ -251,12 +246,12 @@ static u8 intel_sdvo_read_response(struct drm_output *output, void *response,
while (retry--) {
/* Read the command response */
for (i = 0; i < response_len; i++) {
- intel_sdvo_read_byte(output, SDVO_I2C_RETURN_0 + i,
+ intel_sdvo_read_byte(intel_output, SDVO_I2C_RETURN_0 + i,
&((u8 *)response)[i]);
}
/* read the return status */
- intel_sdvo_read_byte(output, SDVO_I2C_CMD_STATUS, &status);
+ intel_sdvo_read_byte(intel_output, SDVO_I2C_CMD_STATUS, &status);
if (1) {
DRM_DEBUG("%s: R: ", SDVO_NAME(sdvo_priv));
@@ -295,12 +290,12 @@ int intel_sdvo_get_pixel_multiplier(struct drm_display_mode *mode)
* SDVO chips which defeats the purpose of doing a bus switch in the first
* place.
*/
-void intel_sdvo_set_control_bus_switch(struct drm_output *output, u8 target)
+void intel_sdvo_set_control_bus_switch(struct intel_output *intel_output, u8 target)
{
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_CONTROL_BUS_SWITCH, &target, 1);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_CONTROL_BUS_SWITCH, &target, 1);
}
-static bool intel_sdvo_set_target_input(struct drm_output *output, bool target_0, bool target_1)
+static bool intel_sdvo_set_target_input(struct intel_output *intel_output, bool target_0, bool target_1)
{
struct intel_sdvo_set_target_input_args targets = {0};
u8 status;
@@ -311,10 +306,10 @@ static bool intel_sdvo_set_target_input(struct drm_output *output, bool target_0
if (target_1)
targets.target_1 = 1;
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_TARGET_INPUT, &targets,
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_TARGET_INPUT, &targets,
sizeof(targets));
- status = intel_sdvo_read_response(output, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, NULL, 0);
return (status == SDVO_CMD_STATUS_SUCCESS);
}
@@ -325,13 +320,13 @@ static bool intel_sdvo_set_target_input(struct drm_output *output, bool target_0
* This function is making an assumption about the layout of the response,
* which should be checked against the docs.
*/
-static bool intel_sdvo_get_trained_inputs(struct drm_output *output, bool *input_1, bool *input_2)
+static bool intel_sdvo_get_trained_inputs(struct intel_output *intel_output, bool *input_1, bool *input_2)
{
struct intel_sdvo_get_trained_inputs_response response;
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_TRAINED_INPUTS, NULL, 0);
- status = intel_sdvo_read_response(output, &response, sizeof(response));
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_TRAINED_INPUTS, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, &response, sizeof(response));
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
@@ -340,29 +335,29 @@ static bool intel_sdvo_get_trained_inputs(struct drm_output *output, bool *input
return true;
}
-static bool intel_sdvo_get_active_outputs(struct drm_output *output,
+static bool intel_sdvo_get_active_outputs(struct intel_output *intel_output,
u16 *outputs)
{
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_ACTIVE_OUTPUTS, NULL, 0);
- status = intel_sdvo_read_response(output, outputs, sizeof(*outputs));
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_OUTPUTS, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, outputs, sizeof(*outputs));
return (status == SDVO_CMD_STATUS_SUCCESS);
}
-static bool intel_sdvo_set_active_outputs(struct drm_output *output,
+static bool intel_sdvo_set_active_outputs(struct intel_output *intel_output,
u16 outputs)
{
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_ACTIVE_OUTPUTS, &outputs,
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_OUTPUTS, &outputs,
sizeof(outputs));
- status = intel_sdvo_read_response(output, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, NULL, 0);
return (status == SDVO_CMD_STATUS_SUCCESS);
}
-static bool intel_sdvo_set_encoder_power_state(struct drm_output *output,
+static bool intel_sdvo_set_encoder_power_state(struct intel_output *intel_output,
int mode)
{
u8 status, state = SDVO_ENCODER_STATE_ON;
@@ -382,24 +377,24 @@ static bool intel_sdvo_set_encoder_power_state(struct drm_output *output,
break;
}
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_ENCODER_POWER_STATE, &state,
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ENCODER_POWER_STATE, &state,
sizeof(state));
- status = intel_sdvo_read_response(output, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, NULL, 0);
return (status == SDVO_CMD_STATUS_SUCCESS);
}
-static bool intel_sdvo_get_input_pixel_clock_range(struct drm_output *output,
+static bool intel_sdvo_get_input_pixel_clock_range(struct intel_output *intel_output,
int *clock_min,
int *clock_max)
{
struct intel_sdvo_pixel_clock_range clocks;
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE,
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE,
NULL, 0);
- status = intel_sdvo_read_response(output, &clocks, sizeof(clocks));
+ status = intel_sdvo_read_response(intel_output, &clocks, sizeof(clocks));
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
@@ -411,31 +406,31 @@ static bool intel_sdvo_get_input_pixel_clock_range(struct drm_output *output,
return true;
}
-static bool intel_sdvo_set_target_output(struct drm_output *output,
+static bool intel_sdvo_set_target_output(struct intel_output *intel_output,
u16 outputs)
{
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_TARGET_OUTPUT, &outputs,
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_TARGET_OUTPUT, &outputs,
sizeof(outputs));
- status = intel_sdvo_read_response(output, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, NULL, 0);
return (status == SDVO_CMD_STATUS_SUCCESS);
}
-static bool intel_sdvo_get_timing(struct drm_output *output, u8 cmd,
+static bool intel_sdvo_get_timing(struct intel_output *intel_output, u8 cmd,
struct intel_sdvo_dtd *dtd)
{
u8 status;
- intel_sdvo_write_cmd(output, cmd, NULL, 0);
- status = intel_sdvo_read_response(output, &dtd->part1,
+ intel_sdvo_write_cmd(intel_output, cmd, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, &dtd->part1,
sizeof(dtd->part1));
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
- intel_sdvo_write_cmd(output, cmd + 1, NULL, 0);
- status = intel_sdvo_read_response(output, &dtd->part2,
+ intel_sdvo_write_cmd(intel_output, cmd + 1, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, &dtd->part2,
sizeof(dtd->part2));
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
@@ -443,71 +438,70 @@ static bool intel_sdvo_get_timing(struct drm_output *output, u8 cmd,
return true;
}
-static bool intel_sdvo_get_input_timing(struct drm_output *output,
+static bool intel_sdvo_get_input_timing(struct intel_output *intel_output,
struct intel_sdvo_dtd *dtd)
{
- return intel_sdvo_get_timing(output,
+ return intel_sdvo_get_timing(intel_output,
SDVO_CMD_GET_INPUT_TIMINGS_PART1, dtd);
}
-static bool intel_sdvo_get_output_timing(struct drm_output *output,
+static bool intel_sdvo_get_output_timing(struct intel_output *intel_output,
struct intel_sdvo_dtd *dtd)
{
- return intel_sdvo_get_timing(output,
+ return intel_sdvo_get_timing(intel_output,
SDVO_CMD_GET_OUTPUT_TIMINGS_PART1, dtd);
}
-static bool intel_sdvo_set_timing(struct drm_output *output, u8 cmd,
+static bool intel_sdvo_set_timing(struct intel_output *intel_output, u8 cmd,
struct intel_sdvo_dtd *dtd)
{
u8 status;
- intel_sdvo_write_cmd(output, cmd, &dtd->part1, sizeof(dtd->part1));
- status = intel_sdvo_read_response(output, NULL, 0);
+ intel_sdvo_write_cmd(intel_output, cmd, &dtd->part1, sizeof(dtd->part1));
+ status = intel_sdvo_read_response(intel_output, NULL, 0);
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
- intel_sdvo_write_cmd(output, cmd + 1, &dtd->part2, sizeof(dtd->part2));
- status = intel_sdvo_read_response(output, NULL, 0);
+ intel_sdvo_write_cmd(intel_output, cmd + 1, &dtd->part2, sizeof(dtd->part2));
+ status = intel_sdvo_read_response(intel_output, NULL, 0);
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
return true;
}
-static bool intel_sdvo_set_input_timing(struct drm_output *output,
+static bool intel_sdvo_set_input_timing(struct intel_output *intel_output,
struct intel_sdvo_dtd *dtd)
{
- return intel_sdvo_set_timing(output,
+ return intel_sdvo_set_timing(intel_output,
SDVO_CMD_SET_INPUT_TIMINGS_PART1, dtd);
}
-static bool intel_sdvo_set_output_timing(struct drm_output *output,
+static bool intel_sdvo_set_output_timing(struct intel_output *intel_output,
struct intel_sdvo_dtd *dtd)
{
- return intel_sdvo_set_timing(output,
+ return intel_sdvo_set_timing(intel_output,
SDVO_CMD_SET_OUTPUT_TIMINGS_PART1, dtd);
}
#if 0
-static bool intel_sdvo_get_preferred_input_timing(struct drm_output *output,
+static bool intel_sdvo_get_preferred_input_timing(struct intel_output *intel_output,
struct intel_sdvo_dtd *dtd)
{
- struct intel_output *intel_output = to_intel_output(output);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1,
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1,
NULL, 0);
- status = intel_sdvo_read_response(output, &dtd->part1,
+ status = intel_sdvo_read_response(intel_output, &dtd->part1,
sizeof(dtd->part1));
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2,
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2,
NULL, 0);
- status = intel_sdvo_read_response(output, &dtd->part2,
+ status = intel_sdvo_read_response(intel_output, &dtd->part2,
sizeof(dtd->part2));
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
@@ -516,12 +510,12 @@ static bool intel_sdvo_get_preferred_input_timing(struct drm_output *output,
}
#endif
-static int intel_sdvo_get_clock_rate_mult(struct drm_output *output)
+static int intel_sdvo_get_clock_rate_mult(struct intel_output *intel_output)
{
u8 response, status;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_CLOCK_RATE_MULT, NULL, 0);
- status = intel_sdvo_read_response(output, &response, 1);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_CLOCK_RATE_MULT, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, &response, 1);
if (status != SDVO_CMD_STATUS_SUCCESS) {
DRM_DEBUG("Couldn't get SDVO clock rate multiplier\n");
@@ -533,19 +527,19 @@ static int intel_sdvo_get_clock_rate_mult(struct drm_output *output)
return response;
}
-static bool intel_sdvo_set_clock_rate_mult(struct drm_output *output, u8 val)
+static bool intel_sdvo_set_clock_rate_mult(struct intel_output *intel_output, u8 val)
{
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1);
- status = intel_sdvo_read_response(output, NULL, 0);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1);
+ status = intel_sdvo_read_response(intel_output, NULL, 0);
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
return true;
}
-static bool intel_sdvo_mode_fixup(struct drm_output *output,
+static bool intel_sdvo_mode_fixup(struct drm_encoder *encoder,
struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
@@ -556,15 +550,15 @@ static bool intel_sdvo_mode_fixup(struct drm_output *output,
return true;
}
-static void intel_sdvo_mode_set(struct drm_output *output,
+static void intel_sdvo_mode_set(struct drm_encoder *encoder,
struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
- struct drm_device *dev = output->dev;
+ struct drm_device *dev = encoder->dev;
struct drm_i915_private *dev_priv = dev->dev_private;
- struct drm_crtc *crtc = output->crtc;
+ struct drm_crtc *crtc = encoder->crtc;
struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
- struct intel_output *intel_output = to_intel_output(output);
+ struct intel_output *intel_output = enc_to_intel_output(encoder);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
u16 width, height;
u16 h_blank_len, h_sync_len, v_blank_len, v_sync_len;
@@ -618,11 +612,11 @@ static void intel_sdvo_mode_set(struct drm_output *output,
output_dtd.part2.reserved = 0;
/* Set the output timing to the screen */
- intel_sdvo_set_target_output(output, sdvo_priv->active_outputs);
- intel_sdvo_set_output_timing(output, &output_dtd);
+ intel_sdvo_set_target_output(intel_output, sdvo_priv->active_outputs);
+ intel_sdvo_set_output_timing(intel_output, &output_dtd);
/* Set the input timing to the screen. Assume always input 0. */
- intel_sdvo_set_target_input(output, true, false);
+ intel_sdvo_set_target_input(intel_output, true, false);
/* We would like to use i830_sdvo_create_preferred_input_timing() to
* provide the device with a timing it can support, if it supports that
@@ -630,29 +624,29 @@ static void intel_sdvo_mode_set(struct drm_output *output,
* output the preferred timing, and we don't support that currently.
*/
#if 0
- success = intel_sdvo_create_preferred_input_timing(output, clock,
+ success = intel_sdvo_create_preferred_input_timing(intel_output, clock,
width, height);
if (success) {
struct intel_sdvo_dtd *input_dtd;
- intel_sdvo_get_preferred_input_timing(output, &input_dtd);
- intel_sdvo_set_input_timing(output, &input_dtd);
+ intel_sdvo_get_preferred_input_timing(intel_output, &input_dtd);
+ intel_sdvo_set_input_timing(intel_output, &input_dtd);
}
#else
- intel_sdvo_set_input_timing(output, &output_dtd);
+ intel_sdvo_set_input_timing(intel_output, &output_dtd);
#endif
switch (intel_sdvo_get_pixel_multiplier(mode)) {
case 1:
- intel_sdvo_set_clock_rate_mult(output,
+ intel_sdvo_set_clock_rate_mult(intel_output,
SDVO_CLOCK_RATE_MULT_1X);
break;
case 2:
- intel_sdvo_set_clock_rate_mult(output,
+ intel_sdvo_set_clock_rate_mult(intel_output,
SDVO_CLOCK_RATE_MULT_2X);
break;
case 4:
- intel_sdvo_set_clock_rate_mult(output,
+ intel_sdvo_set_clock_rate_mult(intel_output,
SDVO_CLOCK_RATE_MULT_4X);
break;
}
@@ -686,26 +680,26 @@ static void intel_sdvo_mode_set(struct drm_output *output,
sdvox |= (sdvo_pixel_multiply - 1) << SDVO_PORT_MULTIPLY_SHIFT;
}
- intel_sdvo_write_sdvox(output, sdvox);
+ intel_sdvo_write_sdvox(intel_output, sdvox);
}
-static void intel_sdvo_dpms(struct drm_output *output, int mode)
+static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
{
- struct drm_device *dev = output->dev;
+ struct drm_device *dev = encoder->dev;
struct drm_i915_private *dev_priv = dev->dev_private;
- struct intel_output *intel_output = to_intel_output(output);
+ struct intel_output *intel_output = enc_to_intel_output(encoder);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
u32 temp;
if (mode != DPMSModeOn) {
- intel_sdvo_set_active_outputs(output, 0);
+ intel_sdvo_set_active_outputs(intel_output, 0);
if (0)
- intel_sdvo_set_encoder_power_state(output, mode);
+ intel_sdvo_set_encoder_power_state(intel_output, mode);
if (mode == DPMSModeOff) {
temp = I915_READ(sdvo_priv->output_device);
if ((temp & SDVO_ENABLE) != 0) {
- intel_sdvo_write_sdvox(output, temp & ~SDVO_ENABLE);
+ intel_sdvo_write_sdvox(intel_output, temp & ~SDVO_ENABLE);
}
}
} else {
@@ -715,11 +709,11 @@ static void intel_sdvo_dpms(struct drm_output *output, int mode)
temp = I915_READ(sdvo_priv->output_device);
if ((temp & SDVO_ENABLE) == 0)
- intel_sdvo_write_sdvox(output, temp | SDVO_ENABLE);
+ intel_sdvo_write_sdvox(intel_output, temp | SDVO_ENABLE);
for (i = 0; i < 2; i++)
intel_wait_for_vblank(dev);
- status = intel_sdvo_get_trained_inputs(output, &input1,
+ status = intel_sdvo_get_trained_inputs(intel_output, &input1,
&input2);
@@ -733,32 +727,32 @@ static void intel_sdvo_dpms(struct drm_output *output, int mode)
}
if (0)
- intel_sdvo_set_encoder_power_state(output, mode);
- intel_sdvo_set_active_outputs(output, sdvo_priv->active_outputs);
+ intel_sdvo_set_encoder_power_state(intel_output, mode);
+ intel_sdvo_set_active_outputs(intel_output, sdvo_priv->active_outputs);
}
return;
}
-static void intel_sdvo_save(struct drm_output *output)
+static void intel_sdvo_save(struct drm_connector *connector)
{
- struct drm_device *dev = output->dev;
+ struct drm_device *dev = connector->dev;
struct drm_i915_private *dev_priv = dev->dev_private;
- struct intel_output *intel_output = to_intel_output(output);
+ struct intel_output *intel_output = to_intel_output(connector);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
int o;
- sdvo_priv->save_sdvo_mult = intel_sdvo_get_clock_rate_mult(output);
- intel_sdvo_get_active_outputs(output, &sdvo_priv->save_active_outputs);
+ sdvo_priv->save_sdvo_mult = intel_sdvo_get_clock_rate_mult(intel_output);
+ intel_sdvo_get_active_outputs(intel_output, &sdvo_priv->save_active_outputs);
if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) {
- intel_sdvo_set_target_input(output, true, false);
- intel_sdvo_get_input_timing(output,
+ intel_sdvo_set_target_input(intel_output, true, false);
+ intel_sdvo_get_input_timing(intel_output,
&sdvo_priv->save_input_dtd_1);
}
if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) {
- intel_sdvo_set_target_input(output, false, true);
- intel_sdvo_get_input_timing(output,
+ intel_sdvo_set_target_input(intel_output, false, true);
+ intel_sdvo_get_input_timing(intel_output,
&sdvo_priv->save_input_dtd_2);
}
@@ -767,8 +761,8 @@ static void intel_sdvo_save(struct drm_output *output)
u16 this_output = (1 << o);
if (sdvo_priv->caps.output_flags & this_output)
{
- intel_sdvo_set_target_output(output, this_output);
- intel_sdvo_get_output_timing(output,
+ intel_sdvo_set_target_output(intel_output, this_output);
+ intel_sdvo_get_output_timing(intel_output,
&sdvo_priv->save_output_dtd[o]);
}
}
@@ -776,39 +770,39 @@ static void intel_sdvo_save(struct drm_output *output)
sdvo_priv->save_SDVOX = I915_READ(sdvo_priv->output_device);
}
-static void intel_sdvo_restore(struct drm_output *output)
+static void intel_sdvo_restore(struct drm_connector *connector)
{
- struct drm_device *dev = output->dev;
+ struct drm_device *dev = connector->dev;
struct drm_i915_private *dev_priv = dev->dev_private;
- struct intel_output *intel_output = to_intel_output(output);
+ struct intel_output *intel_output = to_intel_output(connector);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
int o;
int i;
bool input1, input2;
u8 status;
- intel_sdvo_set_active_outputs(output, 0);
+ intel_sdvo_set_active_outputs(intel_output, 0);
for (o = SDVO_OUTPUT_FIRST; o <= SDVO_OUTPUT_LAST; o++)
{
u16 this_output = (1 << o);
if (sdvo_priv->caps.output_flags & this_output) {
- intel_sdvo_set_target_output(output, this_output);
- intel_sdvo_set_output_timing(output, &sdvo_priv->save_output_dtd[o]);
+ intel_sdvo_set_target_output(intel_output, this_output);
+ intel_sdvo_set_output_timing(intel_output, &sdvo_priv->save_output_dtd[o]);
}
}
if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) {
- intel_sdvo_set_target_input(output, true, false);
- intel_sdvo_set_input_timing(output, &sdvo_priv->save_input_dtd_1);
+ intel_sdvo_set_target_input(intel_output, true, false);
+ intel_sdvo_set_input_timing(intel_output, &sdvo_priv->save_input_dtd_1);
}
if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) {
- intel_sdvo_set_target_input(output, false, true);
- intel_sdvo_set_input_timing(output, &sdvo_priv->save_input_dtd_2);
+ intel_sdvo_set_target_input(intel_output, false, true);
+ intel_sdvo_set_input_timing(intel_output, &sdvo_priv->save_input_dtd_2);
}
- intel_sdvo_set_clock_rate_mult(output, sdvo_priv->save_sdvo_mult);
+ intel_sdvo_set_clock_rate_mult(intel_output, sdvo_priv->save_sdvo_mult);
I915_WRITE(sdvo_priv->output_device, sdvo_priv->save_SDVOX);
@@ -816,19 +810,19 @@ static void intel_sdvo_restore(struct drm_output *output)
{
for (i = 0; i < 2; i++)
intel_wait_for_vblank(dev);
- status = intel_sdvo_get_trained_inputs(output, &input1, &input2);
+ status = intel_sdvo_get_trained_inputs(intel_output, &input1, &input2);
if (status == SDVO_CMD_STATUS_SUCCESS && !input1)
DRM_DEBUG("First %s output reported failure to sync\n",
SDVO_NAME(sdvo_priv));
}
- intel_sdvo_set_active_outputs(output, sdvo_priv->save_active_outputs);
+ intel_sdvo_set_active_outputs(intel_output, sdvo_priv->save_active_outputs);
}
-static int intel_sdvo_mode_valid(struct drm_output *output,
+static int intel_sdvo_mode_valid(struct drm_connector *connector,
struct drm_display_mode *mode)
{
- struct intel_output *intel_output = to_intel_output(output);
+ struct intel_output *intel_output = to_intel_output(connector);
struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
if (mode->flags & V_DBLSCAN)
@@ -843,27 +837,27 @@ static int intel_sdvo_mode_valid(struct drm_output *output,
return MODE_OK;
}
-static bool intel_sdvo_get_capabilities(struct drm_output *output, struct intel_sdvo_caps *caps)
+static bool intel_sdvo_get_capabilities(struct intel_output *intel_output, struct intel_sdvo_caps *caps)
{
u8 status;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_DEVICE_CAPS, NULL, 0);
- status = intel_sdvo_read_response(output, caps, sizeof(*caps));
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_DEVICE_CAPS, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, caps, sizeof(*caps));
if (status != SDVO_CMD_STATUS_SUCCESS)
return false;
return true;
}
-struct drm_output* intel_sdvo_find(struct drm_device *dev, int sdvoB)
+struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB)
{
- struct drm_output *output = 0;
- struct intel_output *iout = 0;
+ struct drm_connector *connector = NULL;
+ struct intel_output *iout = NULL;
struct intel_sdvo_priv *sdvo;
- /* find the sdvo output */
- list_for_each_entry(output, &dev->mode_config.output_list, head) {
- iout = to_intel_output(output);
+ /* find the sdvo connector */
+ list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+ iout = to_intel_output(connector);
if (iout->type != INTEL_OUTPUT_SDVO)
continue;
@@ -871,27 +865,30 @@ struct drm_output* intel_sdvo_find(struct drm_device *dev, int sdvoB)
sdvo = iout->dev_priv;
if (sdvo->output_device == SDVOB && sdvoB)
- return output;
+ return connector;
if (sdvo->output_device == SDVOC && !sdvoB)
- return output;
+ return connector;
- }
-
- return 0;
+ }
+
+ return NULL;
}
-int intel_sdvo_supports_hotplug(struct drm_output *output)
+int intel_sdvo_supports_hotplug(struct drm_connector *connector)
{
u8 response[2];
u8 status;
+ struct intel_output *intel_output;
DRM_DEBUG("\n");
- if (!output)
+ if (!connector)
return 0;
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
- status = intel_sdvo_read_response(output, &response, 2);
+ intel_output = to_intel_output(connector);
+
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, &response, 2);
if (response[0] !=0)
return 1;
@@ -899,51 +896,55 @@ int intel_sdvo_supports_hotplug(struct drm_output *output)
return 0;
}
-void intel_sdvo_set_hotplug(struct drm_output *output, int on)
+void intel_sdvo_set_hotplug(struct drm_connector *connector, int on)
{
u8 response[2];
u8 status;
+ struct intel_output *intel_output = to_intel_output(connector);
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
- intel_sdvo_read_response(output, &response, 2);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
+ intel_sdvo_read_response(intel_output, &response, 2);
if (on) {
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
- status = intel_sdvo_read_response(output, &response, 2);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, &response, 2);
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
} else {
response[0] = 0;
response[1] = 0;
- intel_sdvo_write_cmd(output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
}
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
- intel_sdvo_read_response(output, &response, 2);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
+ intel_sdvo_read_response(intel_output, &response, 2);
}
-static enum drm_output_status intel_sdvo_detect(struct drm_output *output)
+static enum drm_connector_status intel_sdvo_detect(struct drm_connector *connector)
{
u8 response[2];
u8 status;
+ struct intel_output *intel_output = to_intel_output(connector);
- intel_sdvo_write_cmd(output, SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0);
- status = intel_sdvo_read_response(output, &response, 2);
+ intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0);
+ status = intel_sdvo_read_response(intel_output, &response, 2);
DRM_DEBUG("SDVO response %d %d\n", response[0], response[1]);
if ((response[0] != 0) || (response[1] != 0))
- return output_status_connected;
+ return connector_status_connected;
else
- return output_status_disconnected;
+ return connector_status_disconnected;
}
-static int intel_sdvo_get_modes(struct drm_output *output)
+static int intel_sdvo_get_modes(struct drm_connector *connector)
{
+ struct intel_output *intel_output = to_intel_output(connector);
+
/* set the bus switch and get the modes */
- intel_sdvo_set_control_bus_switch(output, SDVO_CONTROL_BUS_DDC2);
- intel_ddc_get_modes(output);
+ intel_sdvo_set_control_bus_switch(intel_output, SDVO_CONTROL_BUS_DDC2);
+ intel_ddc_get_modes(intel_output);
- if (list_empty(&output->probed_modes))
+ if (list_empty(&connector->probed_modes))
return 0;
return 1;
#if 0
@@ -959,60 +960,75 @@ static int intel_sdvo_get_modes(struct drm_output *output)
#endif
}
-static void intel_sdvo_destroy(struct drm_output *output)
+static void intel_sdvo_destroy(struct drm_connector *connector)
{
- struct intel_output *intel_output = to_intel_output(output);
+ struct intel_output *intel_output = to_intel_output(connector);
if (intel_output->i2c_bus)
intel_i2c_destroy(intel_output->i2c_bus);
- drm_output_cleanup(output);
+ drm_connector_cleanup(connector);
kfree(intel_output);
}
-static const struct drm_output_helper_funcs intel_sdvo_helper_funcs = {
+static const struct drm_encoder_helper_funcs intel_sdvo_helper_funcs = {
+ .dpms = intel_sdvo_dpms,
.mode_fixup = intel_sdvo_mode_fixup,
- .prepare = intel_output_prepare,
+ .prepare = intel_encoder_prepare,
.mode_set = intel_sdvo_mode_set,
- .commit = intel_output_commit,
+ .commit = intel_encoder_commit,
};
-static const struct drm_output_funcs intel_sdvo_output_funcs = {
- .dpms = intel_sdvo_dpms,
+static const struct drm_connector_funcs intel_sdvo_connector_funcs = {
.save = intel_sdvo_save,
.restore = intel_sdvo_restore,
.detect = intel_sdvo_detect,
- .get_modes = intel_sdvo_get_modes,
+ .fill_modes = drm_helper_probe_single_connector_modes,
.destroy = intel_sdvo_destroy,
+};
+
+static const struct drm_connector_helper_funcs intel_sdvo_connector_helper_funcs = {
+ .get_modes = intel_sdvo_get_modes,
.mode_valid = intel_sdvo_mode_valid,
+ .best_encoder = intel_best_encoder,
};
+void intel_sdvo_enc_destroy(struct drm_encoder *encoder)
+{
+ drm_encoder_cleanup(encoder);
+}
+
+static const struct drm_encoder_funcs intel_sdvo_enc_funcs = {
+ .destroy = intel_sdvo_enc_destroy,
+};
+
+
void intel_sdvo_init(struct drm_device *dev, int output_device)
{
- struct drm_output *output;
+ struct drm_connector *connector;
struct intel_output *intel_output;
struct intel_sdvo_priv *sdvo_priv;
struct intel_i2c_chan *i2cbus = NULL;
int connector_type;
u8 ch[0x40];
int i;
- int output_type, output_id;
+ int encoder_type, output_id;
intel_output = kcalloc(sizeof(struct intel_output)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL);
if (!intel_output) {
return;
}
- output = &intel_output->base;
-
- drm_output_init(dev, output, &intel_sdvo_output_funcs,
- DRM_MODE_OUTPUT_NONE);
+ connector = &intel_output->base;
+ drm_connector_init(dev, connector, &intel_sdvo_connector_funcs,
+ DRM_MODE_CONNECTOR_Unknown);
+ drm_connector_helper_add(connector, &intel_sdvo_connector_helper_funcs);
sdvo_priv = (struct intel_sdvo_priv *)(intel_output + 1);
intel_output->type = INTEL_OUTPUT_SDVO;
- drm_output_helper_add(output, &intel_sdvo_helper_funcs);
- output->interlace_allowed = 0;
- output->doublescan_allowed = 0;
+
+ connector->interlace_allowed = 0;
+ connector->doublescan_allowed = 0;
/* setup the DDC bus. */
if (output_device == SDVOB)
@@ -1021,7 +1037,7 @@ void intel_sdvo_init(struct drm_device *dev, int output_device)
i2cbus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC");
if (i2cbus == NULL) {
- intel_sdvo_destroy(output);
+ intel_sdvo_destroy(connector);
return;
}
@@ -1042,15 +1058,15 @@ void intel_sdvo_init(struct drm_device *dev, int output_device)
/* Read the regs to test if we can talk to the device */
for (i = 0; i < 0x40; i++) {
- if (!intel_sdvo_read_byte(output, i, &ch[i])) {
+ if (!intel_sdvo_read_byte(intel_output, i, &ch[i])) {
DRM_DEBUG("No SDVO device found on SDVO%c\n",
output_device == SDVOB ? 'B' : 'C');
- intel_sdvo_destroy(output);
+ intel_sdvo_destroy(connector);
return;
}
}
- intel_sdvo_get_capabilities(output, &sdvo_priv->caps);
+ intel_sdvo_get_capabilities(intel_output, &sdvo_priv->caps);
memset(&sdvo_priv->active_outputs, 0, sizeof(sdvo_priv->active_outputs));
@@ -1058,30 +1074,30 @@ void intel_sdvo_init(struct drm_device *dev, int output_device)
if (sdvo_priv->caps.output_flags & SDVO_OUTPUT_RGB0)
{
sdvo_priv->active_outputs = SDVO_OUTPUT_RGB0;
- output->display_info.subpixel_order = SubPixelHorizontalRGB;
- output_type = DRM_MODE_OUTPUT_DAC;
- connector_type = ConnectorVGA;
+ connector->display_info.subpixel_order = SubPixelHorizontalRGB;
+ encoder_type = DRM_MODE_ENCODER_DAC;
+ connector_type = DRM_MODE_CONNECTOR_VGA;
}
else if (sdvo_priv->caps.output_flags & SDVO_OUTPUT_RGB1)
{
sdvo_priv->active_outputs = SDVO_OUTPUT_RGB1;
- output->display_info.subpixel_order = SubPixelHorizontalRGB;
- output_type = DRM_MODE_OUTPUT_DAC;
- connector_type = ConnectorVGA;
+ connector->display_info.subpixel_order = SubPixelHorizontalRGB;
+ encoder_type = DRM_MODE_ENCODER_DAC;
+ connector_type = DRM_MODE_CONNECTOR_VGA;
}
else if (sdvo_priv->caps.output_flags & SDVO_OUTPUT_TMDS0)
{
sdvo_priv->active_outputs = SDVO_OUTPUT_TMDS0;
- output->display_info.subpixel_order = SubPixelHorizontalRGB;
- output_type = DRM_MODE_OUTPUT_TMDS;
- connector_type = ConnectorDVID;
+ connector->display_info.subpixel_order = SubPixelHorizontalRGB;
+ encoder_type = DRM_MODE_ENCODER_TMDS;
+ connector_type = DRM_MODE_CONNECTOR_DVID;
}
else if (sdvo_priv->caps.output_flags & SDVO_OUTPUT_TMDS1)
{
sdvo_priv->active_outputs = SDVO_OUTPUT_TMDS1;
- output->display_info.subpixel_order = SubPixelHorizontalRGB;
- output_type = DRM_MODE_OUTPUT_TMDS;
- connector_type = ConnectorDVID;
+ connector->display_info.subpixel_order = SubPixelHorizontalRGB;
+ encoder_type = DRM_MODE_ENCODER_TMDS;
+ connector_type = DRM_MODE_CONNECTOR_DVID;
}
else
{
@@ -1091,19 +1107,21 @@ void intel_sdvo_init(struct drm_device *dev, int output_device)
DRM_DEBUG("%s: No active RGB or TMDS outputs (0x%02x%02x)\n",
SDVO_NAME(sdvo_priv),
bytes[0], bytes[1]);
- intel_sdvo_destroy(output);
+ intel_sdvo_destroy(connector);
return;
}
- output->output_type = output_type;
- output->output_type_id = output_id;
+ drm_encoder_init(dev, &intel_output->enc, &intel_sdvo_enc_funcs, encoder_type);
+ drm_encoder_helper_add(&intel_output->enc, &intel_sdvo_helper_funcs);
+ connector->connector_type = connector_type;
- drm_sysfs_output_add(output);
+ drm_mode_connector_attach_encoder(&intel_output->base, &intel_output->enc);
+ drm_sysfs_connector_add(connector);
/* Set the input timing to the screen. Assume always input 0. */
- intel_sdvo_set_target_input(output, true, false);
+ intel_sdvo_set_target_input(intel_output, true, false);
- intel_sdvo_get_input_pixel_clock_range(output,
+ intel_sdvo_get_input_pixel_clock_range(intel_output,
&sdvo_priv->pixel_clock_min,
&sdvo_priv->pixel_clock_max);
@@ -1127,5 +1145,4 @@ void intel_sdvo_init(struct drm_device *dev, int output_device)
intel_output->ddc_bus = i2cbus;
- drm_output_attach_property(output, dev->mode_config.connector_type_property, connector_type);
}