| 74,7 → 74,7 |
|---|
| struct i2c_adapter ddc; |
| |
| /* Register for the SDVO device: SDVOB or SDVOC */ |
| uint32_t sdvo_reg; |
| i915_reg_t sdvo_reg; |
| |
| /* Active outputs controlled by this SDVO output */ |
| uint16_t controlled_output; |
| 120,8 → 120,7 |
|---|
| */ |
| bool is_tv; |
| |
| /* On different gens SDVOB is at different places. */ |
| bool is_sdvob; |
| enum port port; |
| |
| /* This is for current tv format name */ |
| int tv_format_index; |
| 245,7 → 244,7 |
|---|
| u32 bval = val, cval = val; |
| int i; |
| |
| if (intel_sdvo->sdvo_reg == PCH_SDVOB) { |
| if (HAS_PCH_SPLIT(dev_priv)) { |
| I915_WRITE(intel_sdvo->sdvo_reg, val); |
| POSTING_READ(intel_sdvo->sdvo_reg); |
| /* |
| 259,7 → 258,7 |
|---|
| return; |
| } |
| |
| if (intel_sdvo->sdvo_reg == GEN3_SDVOB) |
| if (intel_sdvo->port == PORT_B) |
| cval = I915_READ(GEN3_SDVOC); |
| else |
| bval = I915_READ(GEN3_SDVOB); |
| 422,7 → 421,7 |
|---|
| SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_DATA), |
| }; |
| |
| #define SDVO_NAME(svdo) ((svdo)->is_sdvob ? "SDVOB" : "SDVOC") |
| #define SDVO_NAME(svdo) ((svdo)->port == PORT_B ? "SDVOB" : "SDVOC") |
| |
| static void intel_sdvo_debug_write(struct intel_sdvo *intel_sdvo, u8 cmd, |
| const void *args, int args_len) |
| 1282,14 → 1281,10 |
|---|
| sdvox |= SDVO_BORDER_ENABLE; |
| } else { |
| sdvox = I915_READ(intel_sdvo->sdvo_reg); |
| switch (intel_sdvo->sdvo_reg) { |
| case GEN3_SDVOB: |
| if (intel_sdvo->port == PORT_B) |
| sdvox &= SDVOB_PRESERVE_MASK; |
| break; |
| case GEN3_SDVOC: |
| else |
| sdvox &= SDVOC_PRESERVE_MASK; |
| break; |
| } |
| sdvox |= (9 << 19) | SDVO_BORDER_ENABLE; |
| } |
| |
| 1464,6 → 1459,13 |
|---|
| * matching DP port to be enabled on transcoder A. |
| */ |
| if (HAS_PCH_IBX(dev_priv) && crtc->pipe == PIPE_B) { |
| /* |
| * We get CPU/PCH FIFO underruns on the other pipe when |
| * doing the workaround. Sweep them under the rug. |
| */ |
| intel_set_cpu_fifo_underrun_reporting(dev_priv, PIPE_A, false); |
| intel_set_pch_fifo_underrun_reporting(dev_priv, PIPE_A, false); |
| |
| temp &= ~SDVO_PIPE_B_SELECT; |
| temp |= SDVO_ENABLE; |
| intel_sdvo_write_sdvox(intel_sdvo, temp); |
| 1470,6 → 1472,10 |
|---|
| |
| temp &= ~SDVO_ENABLE; |
| intel_sdvo_write_sdvox(intel_sdvo, temp); |
| |
| intel_wait_for_vblank_if_active(dev_priv->dev, PIPE_A); |
| intel_set_cpu_fifo_underrun_reporting(dev_priv, PIPE_A, true); |
| intel_set_pch_fifo_underrun_reporting(dev_priv, PIPE_A, true); |
| } |
| } |
| |
| 2251,7 → 2257,7 |
|---|
| { |
| struct sdvo_device_mapping *mapping; |
| |
| if (sdvo->is_sdvob) |
| if (sdvo->port == PORT_B) |
| mapping = &(dev_priv->sdvo_mappings[0]); |
| else |
| mapping = &(dev_priv->sdvo_mappings[1]); |
| 2269,7 → 2275,7 |
|---|
| struct sdvo_device_mapping *mapping; |
| u8 pin; |
| |
| if (sdvo->is_sdvob) |
| if (sdvo->port == PORT_B) |
| mapping = &dev_priv->sdvo_mappings[0]; |
| else |
| mapping = &dev_priv->sdvo_mappings[1]; |
| 2307,7 → 2313,7 |
|---|
| struct drm_i915_private *dev_priv = dev->dev_private; |
| struct sdvo_device_mapping *my_mapping, *other_mapping; |
| |
| if (sdvo->is_sdvob) { |
| if (sdvo->port == PORT_B) { |
| my_mapping = &dev_priv->sdvo_mappings[0]; |
| other_mapping = &dev_priv->sdvo_mappings[1]; |
| } else { |
| 2332,7 → 2338,7 |
|---|
| /* No SDVO device info is found for another DVO port, |
| * so use mapping assumption we had before BIOS parsing. |
| */ |
| if (sdvo->is_sdvob) |
| if (sdvo->port == PORT_B) |
| return 0x70; |
| else |
| return 0x72; |
| 2939,18 → 2945,31 |
|---|
| return i2c_add_adapter(&sdvo->ddc) == 0; |
| } |
| |
| bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob) |
| static void assert_sdvo_port_valid(const struct drm_i915_private *dev_priv, |
| enum port port) |
| { |
| if (HAS_PCH_SPLIT(dev_priv)) |
| WARN_ON(port != PORT_B); |
| else |
| WARN_ON(port != PORT_B && port != PORT_C); |
| } |
| |
| bool intel_sdvo_init(struct drm_device *dev, |
| i915_reg_t sdvo_reg, enum port port) |
| { |
| struct drm_i915_private *dev_priv = dev->dev_private; |
| struct intel_encoder *intel_encoder; |
| struct intel_sdvo *intel_sdvo; |
| int i; |
| |
| assert_sdvo_port_valid(dev_priv, port); |
| |
| intel_sdvo = kzalloc(sizeof(*intel_sdvo), GFP_KERNEL); |
| if (!intel_sdvo) |
| return false; |
| |
| intel_sdvo->sdvo_reg = sdvo_reg; |
| intel_sdvo->is_sdvob = is_sdvob; |
| intel_sdvo->port = port; |
| intel_sdvo->slave_addr = intel_sdvo_get_slave_addr(dev, intel_sdvo) >> 1; |
| intel_sdvo_select_i2c_bus(dev_priv, intel_sdvo); |
| if (!intel_sdvo_init_ddc_proxy(intel_sdvo, dev)) |
| 2959,7 → 2978,8 |
|---|
| /* encoder type will be decided later */ |
| intel_encoder = &intel_sdvo->base; |
| intel_encoder->type = INTEL_OUTPUT_SDVO; |
| drm_encoder_init(dev, &intel_encoder->base, &intel_sdvo_enc_funcs, 0); |
| drm_encoder_init(dev, &intel_encoder->base, &intel_sdvo_enc_funcs, 0, |
| NULL); |
| |
| /* Read the regs to test if we can talk to the device */ |
| for (i = 0; i < 0x40; i++) { |
| 3000,8 → 3020,10 |
|---|
| * hotplug lines. |
| */ |
| if (intel_sdvo->hotplug_active) { |
| intel_encoder->hpd_pin = |
| intel_sdvo->is_sdvob ? HPD_SDVO_B : HPD_SDVO_C; |
| if (intel_sdvo->port == PORT_B) |
| intel_encoder->hpd_pin = HPD_SDVO_B; |
| else |
| intel_encoder->hpd_pin = HPD_SDVO_C; |
| } |
| |
| /* |