2 * Copyright 2006 Dave Airlie <airlied@linux.ie>
3 * Copyright © 2006-2009 Intel Corporation
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
25 * Eric Anholt <eric@anholt.net>
26 * Jesse Barnes <jesse.barnes@intel.com>
29 #include <linux/i2c.h>
30 #include <linux/slab.h>
31 #include <linux/delay.h>
36 #include "intel_drv.h"
41 struct intel_encoder base
;
47 enum hdmi_force_audio force_audio
;
48 void (*write_infoframe
)(struct drm_encoder
*encoder
,
49 struct dip_infoframe
*frame
);
52 static struct intel_hdmi
*enc_to_intel_hdmi(struct drm_encoder
*encoder
)
54 return container_of(encoder
, struct intel_hdmi
, base
.base
);
57 static struct intel_hdmi
*intel_attached_hdmi(struct drm_connector
*connector
)
59 return container_of(intel_attached_encoder(connector
),
60 struct intel_hdmi
, base
);
63 void intel_dip_infoframe_csum(struct dip_infoframe
*frame
)
65 uint8_t *data
= (uint8_t *)frame
;
72 for (i
= 0; i
< frame
->len
+ DIP_HEADER_SIZE
; i
++)
75 frame
->checksum
= 0x100 - sum
;
78 static u32
intel_infoframe_index(struct dip_infoframe
*frame
)
82 switch (frame
->type
) {
84 flags
|= VIDEO_DIP_SELECT_AVI
;
87 flags
|= VIDEO_DIP_SELECT_SPD
;
90 DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame
->type
);
97 static u32
intel_infoframe_enable(struct dip_infoframe
*frame
)
101 switch (frame
->type
) {
103 flags
|= VIDEO_DIP_ENABLE_AVI
;
106 flags
|= VIDEO_DIP_ENABLE_SPD
;
109 DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame
->type
);
116 static u32
intel_infoframe_frequency(struct dip_infoframe
*frame
)
120 switch (frame
->type
) {
123 flags
|= VIDEO_DIP_FREQ_VSYNC
;
126 DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame
->type
);
133 static void i9xx_write_infoframe(struct drm_encoder
*encoder
,
134 struct dip_infoframe
*frame
)
136 uint32_t *data
= (uint32_t *)frame
;
137 struct drm_device
*dev
= encoder
->dev
;
138 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
139 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
140 u32 val
= I915_READ(VIDEO_DIP_CTL
);
141 unsigned i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
144 /* XXX first guess at handling video port, is this corrent? */
145 val
&= ~VIDEO_DIP_PORT_MASK
;
146 if (intel_hdmi
->sdvox_reg
== SDVOB
)
147 val
|= VIDEO_DIP_PORT_B
;
148 else if (intel_hdmi
->sdvox_reg
== SDVOC
)
149 val
|= VIDEO_DIP_PORT_C
;
153 val
&= ~(VIDEO_DIP_SELECT_MASK
| 0xf); /* clear DIP data offset */
154 val
|= intel_infoframe_index(frame
);
156 val
|= VIDEO_DIP_ENABLE
;
158 I915_WRITE(VIDEO_DIP_CTL
, val
);
160 for (i
= 0; i
< len
; i
+= 4) {
161 I915_WRITE(VIDEO_DIP_DATA
, *data
);
165 val
|= intel_infoframe_enable(frame
);
166 val
|= intel_infoframe_frequency(frame
);
168 I915_WRITE(VIDEO_DIP_CTL
, val
);
171 static void ironlake_write_infoframe(struct drm_encoder
*encoder
,
172 struct dip_infoframe
*frame
)
174 uint32_t *data
= (uint32_t *)frame
;
175 struct drm_device
*dev
= encoder
->dev
;
176 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
177 struct drm_crtc
*crtc
= encoder
->crtc
;
178 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
179 int reg
= TVIDEO_DIP_CTL(intel_crtc
->pipe
);
180 unsigned i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
181 u32 val
= I915_READ(reg
);
183 intel_wait_for_vblank(dev
, intel_crtc
->pipe
);
185 val
&= ~(VIDEO_DIP_SELECT_MASK
| 0xf); /* clear DIP data offset */
186 val
|= intel_infoframe_index(frame
);
188 val
|= VIDEO_DIP_ENABLE
;
190 I915_WRITE(reg
, val
);
192 for (i
= 0; i
< len
; i
+= 4) {
193 I915_WRITE(TVIDEO_DIP_DATA(intel_crtc
->pipe
), *data
);
197 val
|= intel_infoframe_enable(frame
);
198 val
|= intel_infoframe_frequency(frame
);
200 I915_WRITE(reg
, val
);
203 static void vlv_write_infoframe(struct drm_encoder
*encoder
,
204 struct dip_infoframe
*frame
)
206 uint32_t *data
= (uint32_t *)frame
;
207 struct drm_device
*dev
= encoder
->dev
;
208 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
209 struct drm_crtc
*crtc
= encoder
->crtc
;
210 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
211 int reg
= VLV_TVIDEO_DIP_CTL(intel_crtc
->pipe
);
212 unsigned i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
213 u32 val
= I915_READ(reg
);
215 intel_wait_for_vblank(dev
, intel_crtc
->pipe
);
217 val
&= ~(VIDEO_DIP_SELECT_MASK
| 0xf); /* clear DIP data offset */
218 val
|= intel_infoframe_index(frame
);
220 val
|= VIDEO_DIP_ENABLE
;
222 I915_WRITE(reg
, val
);
224 for (i
= 0; i
< len
; i
+= 4) {
225 I915_WRITE(VLV_TVIDEO_DIP_DATA(intel_crtc
->pipe
), *data
);
229 val
|= intel_infoframe_enable(frame
);
230 val
|= intel_infoframe_frequency(frame
);
232 I915_WRITE(reg
, val
);
235 static void intel_set_infoframe(struct drm_encoder
*encoder
,
236 struct dip_infoframe
*frame
)
238 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
240 if (!intel_hdmi
->has_hdmi_sink
)
243 intel_dip_infoframe_csum(frame
);
244 intel_hdmi
->write_infoframe(encoder
, frame
);
247 static void intel_hdmi_set_avi_infoframe(struct drm_encoder
*encoder
,
248 struct drm_display_mode
*adjusted_mode
)
250 struct dip_infoframe avi_if
= {
251 .type
= DIP_TYPE_AVI
,
252 .ver
= DIP_VERSION_AVI
,
256 if (adjusted_mode
->flags
& DRM_MODE_FLAG_DBLCLK
)
257 avi_if
.body
.avi
.YQ_CN_PR
|= DIP_AVI_PR_2
;
259 intel_set_infoframe(encoder
, &avi_if
);
262 static void intel_hdmi_set_spd_infoframe(struct drm_encoder
*encoder
)
264 struct dip_infoframe spd_if
;
266 memset(&spd_if
, 0, sizeof(spd_if
));
267 spd_if
.type
= DIP_TYPE_SPD
;
268 spd_if
.ver
= DIP_VERSION_SPD
;
269 spd_if
.len
= DIP_LEN_SPD
;
270 strcpy(spd_if
.body
.spd
.vn
, "Intel");
271 strcpy(spd_if
.body
.spd
.pd
, "Integrated gfx");
272 spd_if
.body
.spd
.sdi
= DIP_SPD_PC
;
274 intel_set_infoframe(encoder
, &spd_if
);
277 static void intel_hdmi_mode_set(struct drm_encoder
*encoder
,
278 struct drm_display_mode
*mode
,
279 struct drm_display_mode
*adjusted_mode
)
281 struct drm_device
*dev
= encoder
->dev
;
282 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
283 struct drm_crtc
*crtc
= encoder
->crtc
;
284 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
285 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
288 sdvox
= SDVO_ENCODING_HDMI
| SDVO_BORDER_ENABLE
;
289 if (!HAS_PCH_SPLIT(dev
))
290 sdvox
|= intel_hdmi
->color_range
;
291 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PVSYNC
)
292 sdvox
|= SDVO_VSYNC_ACTIVE_HIGH
;
293 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PHSYNC
)
294 sdvox
|= SDVO_HSYNC_ACTIVE_HIGH
;
296 if (intel_crtc
->bpp
> 24)
297 sdvox
|= COLOR_FORMAT_12bpc
;
299 sdvox
|= COLOR_FORMAT_8bpc
;
301 /* Required on CPT */
302 if (intel_hdmi
->has_hdmi_sink
&& HAS_PCH_CPT(dev
))
303 sdvox
|= HDMI_MODE_SELECT
;
305 if (intel_hdmi
->has_audio
) {
306 DRM_DEBUG_DRIVER("Enabling HDMI audio on pipe %c\n",
307 pipe_name(intel_crtc
->pipe
));
308 sdvox
|= SDVO_AUDIO_ENABLE
;
309 sdvox
|= SDVO_NULL_PACKETS_DURING_VSYNC
;
310 intel_write_eld(encoder
, adjusted_mode
);
313 if (HAS_PCH_CPT(dev
))
314 sdvox
|= PORT_TRANS_SEL_CPT(intel_crtc
->pipe
);
315 else if (intel_crtc
->pipe
== 1)
316 sdvox
|= SDVO_PIPE_B_SELECT
;
318 I915_WRITE(intel_hdmi
->sdvox_reg
, sdvox
);
319 POSTING_READ(intel_hdmi
->sdvox_reg
);
321 intel_hdmi_set_avi_infoframe(encoder
, adjusted_mode
);
322 intel_hdmi_set_spd_infoframe(encoder
);
325 static void intel_hdmi_dpms(struct drm_encoder
*encoder
, int mode
)
327 struct drm_device
*dev
= encoder
->dev
;
328 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
329 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
331 u32 enable_bits
= SDVO_ENABLE
;
333 if (intel_hdmi
->has_audio
)
334 enable_bits
|= SDVO_AUDIO_ENABLE
;
336 temp
= I915_READ(intel_hdmi
->sdvox_reg
);
338 /* HW workaround, need to toggle enable bit off and on for 12bpc, but
339 * we do this anyway which shows more stable in testing.
341 if (HAS_PCH_SPLIT(dev
)) {
342 I915_WRITE(intel_hdmi
->sdvox_reg
, temp
& ~SDVO_ENABLE
);
343 POSTING_READ(intel_hdmi
->sdvox_reg
);
346 if (mode
!= DRM_MODE_DPMS_ON
) {
347 temp
&= ~enable_bits
;
352 I915_WRITE(intel_hdmi
->sdvox_reg
, temp
);
353 POSTING_READ(intel_hdmi
->sdvox_reg
);
355 /* HW workaround, need to write this twice for issue that may result
356 * in first write getting masked.
358 if (HAS_PCH_SPLIT(dev
)) {
359 I915_WRITE(intel_hdmi
->sdvox_reg
, temp
);
360 POSTING_READ(intel_hdmi
->sdvox_reg
);
364 static int intel_hdmi_mode_valid(struct drm_connector
*connector
,
365 struct drm_display_mode
*mode
)
367 if (mode
->clock
> 165000)
368 return MODE_CLOCK_HIGH
;
369 if (mode
->clock
< 20000)
370 return MODE_CLOCK_LOW
;
372 if (mode
->flags
& DRM_MODE_FLAG_DBLSCAN
)
373 return MODE_NO_DBLESCAN
;
378 static bool intel_hdmi_mode_fixup(struct drm_encoder
*encoder
,
379 struct drm_display_mode
*mode
,
380 struct drm_display_mode
*adjusted_mode
)
385 static enum drm_connector_status
386 intel_hdmi_detect(struct drm_connector
*connector
, bool force
)
388 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
389 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
391 enum drm_connector_status status
= connector_status_disconnected
;
393 intel_hdmi
->has_hdmi_sink
= false;
394 intel_hdmi
->has_audio
= false;
395 edid
= drm_get_edid(connector
,
396 intel_gmbus_get_adapter(dev_priv
,
397 intel_hdmi
->ddc_bus
));
400 if (edid
->input
& DRM_EDID_INPUT_DIGITAL
) {
401 status
= connector_status_connected
;
402 if (intel_hdmi
->force_audio
!= HDMI_AUDIO_OFF_DVI
)
403 intel_hdmi
->has_hdmi_sink
=
404 drm_detect_hdmi_monitor(edid
);
405 intel_hdmi
->has_audio
= drm_detect_monitor_audio(edid
);
407 connector
->display_info
.raw_edid
= NULL
;
411 if (status
== connector_status_connected
) {
412 if (intel_hdmi
->force_audio
!= HDMI_AUDIO_AUTO
)
413 intel_hdmi
->has_audio
=
414 (intel_hdmi
->force_audio
== HDMI_AUDIO_ON
);
420 static int intel_hdmi_get_modes(struct drm_connector
*connector
)
422 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
423 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
425 /* We should parse the EDID data and find out if it's an HDMI sink so
426 * we can send audio to it.
429 return intel_ddc_get_modes(connector
,
430 intel_gmbus_get_adapter(dev_priv
,
431 intel_hdmi
->ddc_bus
));
435 intel_hdmi_detect_audio(struct drm_connector
*connector
)
437 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
438 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
440 bool has_audio
= false;
442 edid
= drm_get_edid(connector
,
443 intel_gmbus_get_adapter(dev_priv
,
444 intel_hdmi
->ddc_bus
));
446 if (edid
->input
& DRM_EDID_INPUT_DIGITAL
)
447 has_audio
= drm_detect_monitor_audio(edid
);
449 connector
->display_info
.raw_edid
= NULL
;
457 intel_hdmi_set_property(struct drm_connector
*connector
,
458 struct drm_property
*property
,
461 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
462 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
465 ret
= drm_connector_property_set_value(connector
, property
, val
);
469 if (property
== dev_priv
->force_audio_property
) {
470 enum hdmi_force_audio i
= val
;
473 if (i
== intel_hdmi
->force_audio
)
476 intel_hdmi
->force_audio
= i
;
478 if (i
== HDMI_AUDIO_AUTO
)
479 has_audio
= intel_hdmi_detect_audio(connector
);
481 has_audio
= (i
== HDMI_AUDIO_ON
);
483 if (i
== HDMI_AUDIO_OFF_DVI
)
484 intel_hdmi
->has_hdmi_sink
= 0;
486 intel_hdmi
->has_audio
= has_audio
;
490 if (property
== dev_priv
->broadcast_rgb_property
) {
491 if (val
== !!intel_hdmi
->color_range
)
494 intel_hdmi
->color_range
= val
? SDVO_COLOR_RANGE_16_235
: 0;
501 if (intel_hdmi
->base
.base
.crtc
) {
502 struct drm_crtc
*crtc
= intel_hdmi
->base
.base
.crtc
;
503 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
511 static void intel_hdmi_destroy(struct drm_connector
*connector
)
513 drm_sysfs_connector_remove(connector
);
514 drm_connector_cleanup(connector
);
518 static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs
= {
519 .dpms
= intel_hdmi_dpms
,
520 .mode_fixup
= intel_hdmi_mode_fixup
,
521 .prepare
= intel_encoder_prepare
,
522 .mode_set
= intel_hdmi_mode_set
,
523 .commit
= intel_encoder_commit
,
526 static const struct drm_connector_funcs intel_hdmi_connector_funcs
= {
527 .dpms
= drm_helper_connector_dpms
,
528 .detect
= intel_hdmi_detect
,
529 .fill_modes
= drm_helper_probe_single_connector_modes
,
530 .set_property
= intel_hdmi_set_property
,
531 .destroy
= intel_hdmi_destroy
,
534 static const struct drm_connector_helper_funcs intel_hdmi_connector_helper_funcs
= {
535 .get_modes
= intel_hdmi_get_modes
,
536 .mode_valid
= intel_hdmi_mode_valid
,
537 .best_encoder
= intel_best_encoder
,
540 static const struct drm_encoder_funcs intel_hdmi_enc_funcs
= {
541 .destroy
= intel_encoder_destroy
,
545 intel_hdmi_add_properties(struct intel_hdmi
*intel_hdmi
, struct drm_connector
*connector
)
547 intel_attach_force_audio_property(connector
);
548 intel_attach_broadcast_rgb_property(connector
);
551 void intel_hdmi_init(struct drm_device
*dev
, int sdvox_reg
)
553 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
554 struct drm_connector
*connector
;
555 struct intel_encoder
*intel_encoder
;
556 struct intel_connector
*intel_connector
;
557 struct intel_hdmi
*intel_hdmi
;
560 intel_hdmi
= kzalloc(sizeof(struct intel_hdmi
), GFP_KERNEL
);
564 intel_connector
= kzalloc(sizeof(struct intel_connector
), GFP_KERNEL
);
565 if (!intel_connector
) {
570 intel_encoder
= &intel_hdmi
->base
;
571 drm_encoder_init(dev
, &intel_encoder
->base
, &intel_hdmi_enc_funcs
,
572 DRM_MODE_ENCODER_TMDS
);
574 connector
= &intel_connector
->base
;
575 drm_connector_init(dev
, connector
, &intel_hdmi_connector_funcs
,
576 DRM_MODE_CONNECTOR_HDMIA
);
577 drm_connector_helper_add(connector
, &intel_hdmi_connector_helper_funcs
);
579 intel_encoder
->type
= INTEL_OUTPUT_HDMI
;
581 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
582 connector
->interlace_allowed
= 1;
583 connector
->doublescan_allowed
= 0;
584 intel_encoder
->crtc_mask
= (1 << 0) | (1 << 1) | (1 << 2);
586 /* Set up the DDC bus. */
587 if (sdvox_reg
== SDVOB
) {
588 intel_encoder
->clone_mask
= (1 << INTEL_HDMIB_CLONE_BIT
);
589 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPB
;
590 dev_priv
->hotplug_supported_mask
|= HDMIB_HOTPLUG_INT_STATUS
;
591 } else if (sdvox_reg
== SDVOC
) {
592 intel_encoder
->clone_mask
= (1 << INTEL_HDMIC_CLONE_BIT
);
593 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPC
;
594 dev_priv
->hotplug_supported_mask
|= HDMIC_HOTPLUG_INT_STATUS
;
595 } else if (sdvox_reg
== HDMIB
) {
596 intel_encoder
->clone_mask
= (1 << INTEL_HDMID_CLONE_BIT
);
597 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPB
;
598 dev_priv
->hotplug_supported_mask
|= HDMIB_HOTPLUG_INT_STATUS
;
599 } else if (sdvox_reg
== HDMIC
) {
600 intel_encoder
->clone_mask
= (1 << INTEL_HDMIE_CLONE_BIT
);
601 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPC
;
602 dev_priv
->hotplug_supported_mask
|= HDMIC_HOTPLUG_INT_STATUS
;
603 } else if (sdvox_reg
== HDMID
) {
604 intel_encoder
->clone_mask
= (1 << INTEL_HDMIF_CLONE_BIT
);
605 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPD
;
606 dev_priv
->hotplug_supported_mask
|= HDMID_HOTPLUG_INT_STATUS
;
609 intel_hdmi
->sdvox_reg
= sdvox_reg
;
611 if (!HAS_PCH_SPLIT(dev
)) {
612 intel_hdmi
->write_infoframe
= i9xx_write_infoframe
;
613 I915_WRITE(VIDEO_DIP_CTL
, 0);
614 } else if (IS_VALLEYVIEW(dev
)) {
615 intel_hdmi
->write_infoframe
= vlv_write_infoframe
;
617 I915_WRITE(VLV_TVIDEO_DIP_CTL(i
), 0);
619 intel_hdmi
->write_infoframe
= ironlake_write_infoframe
;
621 I915_WRITE(TVIDEO_DIP_CTL(i
), 0);
624 drm_encoder_helper_add(&intel_encoder
->base
, &intel_hdmi_helper_funcs
);
626 intel_hdmi_add_properties(intel_hdmi
, connector
);
628 intel_connector_attach_encoder(intel_connector
, intel_encoder
);
629 drm_sysfs_connector_add(connector
);
631 /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
632 * 0xd. Failure to do so will result in spurious interrupts being
633 * generated on the port when a cable is not attached.
635 if (IS_G4X(dev
) && !IS_GM45(dev
)) {
636 u32 temp
= I915_READ(PEG_BAND_GAP_DATA
);
637 I915_WRITE(PEG_BAND_GAP_DATA
, (temp
& ~0xf) | 0xd);