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"
40 struct intel_hdmi
*enc_to_intel_hdmi(struct drm_encoder
*encoder
)
42 return container_of(encoder
, struct intel_hdmi
, base
.base
);
45 static struct intel_hdmi
*intel_attached_hdmi(struct drm_connector
*connector
)
47 return container_of(intel_attached_encoder(connector
),
48 struct intel_hdmi
, base
);
51 void intel_dip_infoframe_csum(struct dip_infoframe
*frame
)
53 uint8_t *data
= (uint8_t *)frame
;
60 for (i
= 0; i
< frame
->len
+ DIP_HEADER_SIZE
; i
++)
63 frame
->checksum
= 0x100 - sum
;
66 static u32
g4x_infoframe_index(struct dip_infoframe
*frame
)
68 switch (frame
->type
) {
70 return VIDEO_DIP_SELECT_AVI
;
72 return VIDEO_DIP_SELECT_SPD
;
74 DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame
->type
);
79 static u32
g4x_infoframe_enable(struct dip_infoframe
*frame
)
81 switch (frame
->type
) {
83 return VIDEO_DIP_ENABLE_AVI
;
85 return VIDEO_DIP_ENABLE_SPD
;
87 DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame
->type
);
92 static u32
hsw_infoframe_enable(struct dip_infoframe
*frame
)
94 switch (frame
->type
) {
96 return VIDEO_DIP_ENABLE_AVI_HSW
;
98 return VIDEO_DIP_ENABLE_SPD_HSW
;
100 DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame
->type
);
105 static u32
hsw_infoframe_data_reg(struct dip_infoframe
*frame
, enum pipe pipe
)
107 switch (frame
->type
) {
109 return HSW_TVIDEO_DIP_AVI_DATA(pipe
);
111 return HSW_TVIDEO_DIP_SPD_DATA(pipe
);
113 DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame
->type
);
118 static void g4x_write_infoframe(struct drm_encoder
*encoder
,
119 struct dip_infoframe
*frame
)
121 uint32_t *data
= (uint32_t *)frame
;
122 struct drm_device
*dev
= encoder
->dev
;
123 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
124 u32 val
= I915_READ(VIDEO_DIP_CTL
);
125 unsigned i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
127 WARN(!(val
& VIDEO_DIP_ENABLE
), "Writing DIP with CTL reg disabled\n");
129 val
&= ~(VIDEO_DIP_SELECT_MASK
| 0xf); /* clear DIP data offset */
130 val
|= g4x_infoframe_index(frame
);
132 val
&= ~g4x_infoframe_enable(frame
);
134 I915_WRITE(VIDEO_DIP_CTL
, val
);
136 for (i
= 0; i
< len
; i
+= 4) {
137 I915_WRITE(VIDEO_DIP_DATA
, *data
);
141 val
|= g4x_infoframe_enable(frame
);
142 val
&= ~VIDEO_DIP_FREQ_MASK
;
143 val
|= VIDEO_DIP_FREQ_VSYNC
;
145 I915_WRITE(VIDEO_DIP_CTL
, val
);
148 static void ibx_write_infoframe(struct drm_encoder
*encoder
,
149 struct dip_infoframe
*frame
)
151 uint32_t *data
= (uint32_t *)frame
;
152 struct drm_device
*dev
= encoder
->dev
;
153 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
154 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
155 int reg
= TVIDEO_DIP_CTL(intel_crtc
->pipe
);
156 unsigned i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
157 u32 val
= I915_READ(reg
);
159 WARN(!(val
& VIDEO_DIP_ENABLE
), "Writing DIP with CTL reg disabled\n");
161 val
&= ~(VIDEO_DIP_SELECT_MASK
| 0xf); /* clear DIP data offset */
162 val
|= g4x_infoframe_index(frame
);
164 val
&= ~g4x_infoframe_enable(frame
);
166 I915_WRITE(reg
, val
);
168 for (i
= 0; i
< len
; i
+= 4) {
169 I915_WRITE(TVIDEO_DIP_DATA(intel_crtc
->pipe
), *data
);
173 val
|= g4x_infoframe_enable(frame
);
174 val
&= ~VIDEO_DIP_FREQ_MASK
;
175 val
|= VIDEO_DIP_FREQ_VSYNC
;
177 I915_WRITE(reg
, val
);
180 static void cpt_write_infoframe(struct drm_encoder
*encoder
,
181 struct dip_infoframe
*frame
)
183 uint32_t *data
= (uint32_t *)frame
;
184 struct drm_device
*dev
= encoder
->dev
;
185 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
186 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
187 int reg
= TVIDEO_DIP_CTL(intel_crtc
->pipe
);
188 unsigned i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
189 u32 val
= I915_READ(reg
);
191 WARN(!(val
& VIDEO_DIP_ENABLE
), "Writing DIP with CTL reg disabled\n");
193 val
&= ~(VIDEO_DIP_SELECT_MASK
| 0xf); /* clear DIP data offset */
194 val
|= g4x_infoframe_index(frame
);
196 /* The DIP control register spec says that we need to update the AVI
197 * infoframe without clearing its enable bit */
198 if (frame
->type
!= DIP_TYPE_AVI
)
199 val
&= ~g4x_infoframe_enable(frame
);
201 I915_WRITE(reg
, val
);
203 for (i
= 0; i
< len
; i
+= 4) {
204 I915_WRITE(TVIDEO_DIP_DATA(intel_crtc
->pipe
), *data
);
208 val
|= g4x_infoframe_enable(frame
);
209 val
&= ~VIDEO_DIP_FREQ_MASK
;
210 val
|= VIDEO_DIP_FREQ_VSYNC
;
212 I915_WRITE(reg
, val
);
215 static void vlv_write_infoframe(struct drm_encoder
*encoder
,
216 struct dip_infoframe
*frame
)
218 uint32_t *data
= (uint32_t *)frame
;
219 struct drm_device
*dev
= encoder
->dev
;
220 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
221 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
222 int reg
= VLV_TVIDEO_DIP_CTL(intel_crtc
->pipe
);
223 unsigned i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
224 u32 val
= I915_READ(reg
);
226 WARN(!(val
& VIDEO_DIP_ENABLE
), "Writing DIP with CTL reg disabled\n");
228 val
&= ~(VIDEO_DIP_SELECT_MASK
| 0xf); /* clear DIP data offset */
229 val
|= g4x_infoframe_index(frame
);
231 val
&= ~g4x_infoframe_enable(frame
);
233 I915_WRITE(reg
, val
);
235 for (i
= 0; i
< len
; i
+= 4) {
236 I915_WRITE(VLV_TVIDEO_DIP_DATA(intel_crtc
->pipe
), *data
);
240 val
|= g4x_infoframe_enable(frame
);
241 val
&= ~VIDEO_DIP_FREQ_MASK
;
242 val
|= VIDEO_DIP_FREQ_VSYNC
;
244 I915_WRITE(reg
, val
);
247 static void hsw_write_infoframe(struct drm_encoder
*encoder
,
248 struct dip_infoframe
*frame
)
250 uint32_t *data
= (uint32_t *)frame
;
251 struct drm_device
*dev
= encoder
->dev
;
252 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
253 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
254 u32 ctl_reg
= HSW_TVIDEO_DIP_CTL(intel_crtc
->pipe
);
255 u32 data_reg
= hsw_infoframe_data_reg(frame
, intel_crtc
->pipe
);
256 unsigned int i
, len
= DIP_HEADER_SIZE
+ frame
->len
;
257 u32 val
= I915_READ(ctl_reg
);
262 val
&= ~hsw_infoframe_enable(frame
);
263 I915_WRITE(ctl_reg
, val
);
265 for (i
= 0; i
< len
; i
+= 4) {
266 I915_WRITE(data_reg
+ i
, *data
);
270 val
|= hsw_infoframe_enable(frame
);
271 I915_WRITE(ctl_reg
, val
);
274 static void intel_set_infoframe(struct drm_encoder
*encoder
,
275 struct dip_infoframe
*frame
)
277 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
279 intel_dip_infoframe_csum(frame
);
280 intel_hdmi
->write_infoframe(encoder
, frame
);
283 static void intel_hdmi_set_avi_infoframe(struct drm_encoder
*encoder
,
284 struct drm_display_mode
*adjusted_mode
)
286 struct dip_infoframe avi_if
= {
287 .type
= DIP_TYPE_AVI
,
288 .ver
= DIP_VERSION_AVI
,
292 if (adjusted_mode
->flags
& DRM_MODE_FLAG_DBLCLK
)
293 avi_if
.body
.avi
.YQ_CN_PR
|= DIP_AVI_PR_2
;
295 intel_set_infoframe(encoder
, &avi_if
);
298 static void intel_hdmi_set_spd_infoframe(struct drm_encoder
*encoder
)
300 struct dip_infoframe spd_if
;
302 memset(&spd_if
, 0, sizeof(spd_if
));
303 spd_if
.type
= DIP_TYPE_SPD
;
304 spd_if
.ver
= DIP_VERSION_SPD
;
305 spd_if
.len
= DIP_LEN_SPD
;
306 strcpy(spd_if
.body
.spd
.vn
, "Intel");
307 strcpy(spd_if
.body
.spd
.pd
, "Integrated gfx");
308 spd_if
.body
.spd
.sdi
= DIP_SPD_PC
;
310 intel_set_infoframe(encoder
, &spd_if
);
313 static void g4x_set_infoframes(struct drm_encoder
*encoder
,
314 struct drm_display_mode
*adjusted_mode
)
316 struct drm_i915_private
*dev_priv
= encoder
->dev
->dev_private
;
317 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
318 u32 reg
= VIDEO_DIP_CTL
;
319 u32 val
= I915_READ(reg
);
321 /* If the registers were not initialized yet, they might be zeroes,
322 * which means we're selecting the AVI DIP and we're setting its
323 * frequency to once. This seems to really confuse the HW and make
324 * things stop working (the register spec says the AVI always needs to
325 * be sent every VSync). So here we avoid writing to the register more
326 * than we need and also explicitly select the AVI DIP and explicitly
327 * set its frequency to every VSync. Avoiding to write it twice seems to
328 * be enough to solve the problem, but being defensive shouldn't hurt us
330 val
|= VIDEO_DIP_SELECT_AVI
| VIDEO_DIP_FREQ_VSYNC
;
332 if (!intel_hdmi
->has_hdmi_sink
) {
333 if (!(val
& VIDEO_DIP_ENABLE
))
335 val
&= ~VIDEO_DIP_ENABLE
;
336 I915_WRITE(reg
, val
);
340 val
&= ~VIDEO_DIP_PORT_MASK
;
341 switch (intel_hdmi
->sdvox_reg
) {
343 val
|= VIDEO_DIP_PORT_B
;
346 val
|= VIDEO_DIP_PORT_C
;
352 val
|= VIDEO_DIP_ENABLE
;
353 val
&= ~VIDEO_DIP_ENABLE_VENDOR
;
355 I915_WRITE(reg
, val
);
357 intel_hdmi_set_avi_infoframe(encoder
, adjusted_mode
);
358 intel_hdmi_set_spd_infoframe(encoder
);
361 static void ibx_set_infoframes(struct drm_encoder
*encoder
,
362 struct drm_display_mode
*adjusted_mode
)
364 struct drm_i915_private
*dev_priv
= encoder
->dev
->dev_private
;
365 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
366 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
367 u32 reg
= TVIDEO_DIP_CTL(intel_crtc
->pipe
);
368 u32 val
= I915_READ(reg
);
370 /* See the big comment in g4x_set_infoframes() */
371 val
|= VIDEO_DIP_SELECT_AVI
| VIDEO_DIP_FREQ_VSYNC
;
373 if (!intel_hdmi
->has_hdmi_sink
) {
374 if (!(val
& VIDEO_DIP_ENABLE
))
376 val
&= ~VIDEO_DIP_ENABLE
;
377 I915_WRITE(reg
, val
);
381 val
&= ~VIDEO_DIP_PORT_MASK
;
382 switch (intel_hdmi
->sdvox_reg
) {
384 val
|= VIDEO_DIP_PORT_B
;
387 val
|= VIDEO_DIP_PORT_C
;
390 val
|= VIDEO_DIP_PORT_D
;
396 val
|= VIDEO_DIP_ENABLE
;
397 val
&= ~(VIDEO_DIP_ENABLE_VENDOR
| VIDEO_DIP_ENABLE_GAMUT
|
398 VIDEO_DIP_ENABLE_GCP
);
400 I915_WRITE(reg
, val
);
402 intel_hdmi_set_avi_infoframe(encoder
, adjusted_mode
);
403 intel_hdmi_set_spd_infoframe(encoder
);
406 static void cpt_set_infoframes(struct drm_encoder
*encoder
,
407 struct drm_display_mode
*adjusted_mode
)
409 struct drm_i915_private
*dev_priv
= encoder
->dev
->dev_private
;
410 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
411 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
412 u32 reg
= TVIDEO_DIP_CTL(intel_crtc
->pipe
);
413 u32 val
= I915_READ(reg
);
415 /* See the big comment in g4x_set_infoframes() */
416 val
|= VIDEO_DIP_SELECT_AVI
| VIDEO_DIP_FREQ_VSYNC
;
418 if (!intel_hdmi
->has_hdmi_sink
) {
419 if (!(val
& VIDEO_DIP_ENABLE
))
421 val
&= ~(VIDEO_DIP_ENABLE
| VIDEO_DIP_ENABLE_AVI
);
422 I915_WRITE(reg
, val
);
426 /* Set both together, unset both together: see the spec. */
427 val
|= VIDEO_DIP_ENABLE
| VIDEO_DIP_ENABLE_AVI
;
428 val
&= ~(VIDEO_DIP_ENABLE_VENDOR
| VIDEO_DIP_ENABLE_GAMUT
|
429 VIDEO_DIP_ENABLE_GCP
);
431 I915_WRITE(reg
, val
);
433 intel_hdmi_set_avi_infoframe(encoder
, adjusted_mode
);
434 intel_hdmi_set_spd_infoframe(encoder
);
437 static void vlv_set_infoframes(struct drm_encoder
*encoder
,
438 struct drm_display_mode
*adjusted_mode
)
440 struct drm_i915_private
*dev_priv
= encoder
->dev
->dev_private
;
441 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
442 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
443 u32 reg
= VLV_TVIDEO_DIP_CTL(intel_crtc
->pipe
);
444 u32 val
= I915_READ(reg
);
446 /* See the big comment in g4x_set_infoframes() */
447 val
|= VIDEO_DIP_SELECT_AVI
| VIDEO_DIP_FREQ_VSYNC
;
449 if (!intel_hdmi
->has_hdmi_sink
) {
450 if (!(val
& VIDEO_DIP_ENABLE
))
452 val
&= ~VIDEO_DIP_ENABLE
;
453 I915_WRITE(reg
, val
);
457 val
|= VIDEO_DIP_ENABLE
;
458 val
&= ~(VIDEO_DIP_ENABLE_VENDOR
| VIDEO_DIP_ENABLE_GAMUT
|
459 VIDEO_DIP_ENABLE_GCP
);
461 I915_WRITE(reg
, val
);
463 intel_hdmi_set_avi_infoframe(encoder
, adjusted_mode
);
464 intel_hdmi_set_spd_infoframe(encoder
);
467 static void hsw_set_infoframes(struct drm_encoder
*encoder
,
468 struct drm_display_mode
*adjusted_mode
)
470 struct drm_i915_private
*dev_priv
= encoder
->dev
->dev_private
;
471 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
472 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
473 u32 reg
= HSW_TVIDEO_DIP_CTL(intel_crtc
->pipe
);
474 u32 val
= I915_READ(reg
);
476 if (!intel_hdmi
->has_hdmi_sink
) {
481 val
&= ~(VIDEO_DIP_ENABLE_VSC_HSW
| VIDEO_DIP_ENABLE_GCP_HSW
|
482 VIDEO_DIP_ENABLE_VS_HSW
| VIDEO_DIP_ENABLE_GMP_HSW
);
484 I915_WRITE(reg
, val
);
486 intel_hdmi_set_avi_infoframe(encoder
, adjusted_mode
);
487 intel_hdmi_set_spd_infoframe(encoder
);
490 static void intel_hdmi_mode_set(struct drm_encoder
*encoder
,
491 struct drm_display_mode
*mode
,
492 struct drm_display_mode
*adjusted_mode
)
494 struct drm_device
*dev
= encoder
->dev
;
495 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
496 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
497 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
500 sdvox
= SDVO_ENCODING_HDMI
| SDVO_BORDER_ENABLE
;
501 if (!HAS_PCH_SPLIT(dev
))
502 sdvox
|= intel_hdmi
->color_range
;
503 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PVSYNC
)
504 sdvox
|= SDVO_VSYNC_ACTIVE_HIGH
;
505 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PHSYNC
)
506 sdvox
|= SDVO_HSYNC_ACTIVE_HIGH
;
508 if (intel_crtc
->bpp
> 24)
509 sdvox
|= COLOR_FORMAT_12bpc
;
511 sdvox
|= COLOR_FORMAT_8bpc
;
513 /* Required on CPT */
514 if (intel_hdmi
->has_hdmi_sink
&& HAS_PCH_CPT(dev
))
515 sdvox
|= HDMI_MODE_SELECT
;
517 if (intel_hdmi
->has_audio
) {
518 DRM_DEBUG_DRIVER("Enabling HDMI audio on pipe %c\n",
519 pipe_name(intel_crtc
->pipe
));
520 sdvox
|= SDVO_AUDIO_ENABLE
;
521 sdvox
|= SDVO_NULL_PACKETS_DURING_VSYNC
;
522 intel_write_eld(encoder
, adjusted_mode
);
525 if (HAS_PCH_CPT(dev
))
526 sdvox
|= PORT_TRANS_SEL_CPT(intel_crtc
->pipe
);
527 else if (intel_crtc
->pipe
== 1)
528 sdvox
|= SDVO_PIPE_B_SELECT
;
530 I915_WRITE(intel_hdmi
->sdvox_reg
, sdvox
);
531 POSTING_READ(intel_hdmi
->sdvox_reg
);
533 intel_hdmi
->set_infoframes(encoder
, adjusted_mode
);
536 static void intel_hdmi_dpms(struct drm_encoder
*encoder
, int mode
)
538 struct drm_device
*dev
= encoder
->dev
;
539 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
540 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
542 u32 enable_bits
= SDVO_ENABLE
;
544 if (intel_hdmi
->has_audio
)
545 enable_bits
|= SDVO_AUDIO_ENABLE
;
547 temp
= I915_READ(intel_hdmi
->sdvox_reg
);
549 /* HW workaround, need to toggle enable bit off and on for 12bpc, but
550 * we do this anyway which shows more stable in testing.
552 if (HAS_PCH_SPLIT(dev
)) {
553 I915_WRITE(intel_hdmi
->sdvox_reg
, temp
& ~SDVO_ENABLE
);
554 POSTING_READ(intel_hdmi
->sdvox_reg
);
557 if (mode
!= DRM_MODE_DPMS_ON
) {
558 temp
&= ~enable_bits
;
563 I915_WRITE(intel_hdmi
->sdvox_reg
, temp
);
564 POSTING_READ(intel_hdmi
->sdvox_reg
);
566 /* HW workaround, need to write this twice for issue that may result
567 * in first write getting masked.
569 if (HAS_PCH_SPLIT(dev
)) {
570 I915_WRITE(intel_hdmi
->sdvox_reg
, temp
);
571 POSTING_READ(intel_hdmi
->sdvox_reg
);
575 static int intel_hdmi_mode_valid(struct drm_connector
*connector
,
576 struct drm_display_mode
*mode
)
578 if (mode
->clock
> 165000)
579 return MODE_CLOCK_HIGH
;
580 if (mode
->clock
< 20000)
581 return MODE_CLOCK_LOW
;
583 if (mode
->flags
& DRM_MODE_FLAG_DBLSCAN
)
584 return MODE_NO_DBLESCAN
;
589 static bool intel_hdmi_mode_fixup(struct drm_encoder
*encoder
,
590 struct drm_display_mode
*mode
,
591 struct drm_display_mode
*adjusted_mode
)
596 static bool g4x_hdmi_connected(struct intel_hdmi
*intel_hdmi
)
598 struct drm_device
*dev
= intel_hdmi
->base
.base
.dev
;
599 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
602 switch (intel_hdmi
->sdvox_reg
) {
604 bit
= HDMIB_HOTPLUG_LIVE_STATUS
;
607 bit
= HDMIC_HOTPLUG_LIVE_STATUS
;
614 return I915_READ(PORT_HOTPLUG_STAT
) & bit
;
617 static enum drm_connector_status
618 intel_hdmi_detect(struct drm_connector
*connector
, bool force
)
620 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
621 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
623 enum drm_connector_status status
= connector_status_disconnected
;
625 if (IS_G4X(connector
->dev
) && !g4x_hdmi_connected(intel_hdmi
))
628 intel_hdmi
->has_hdmi_sink
= false;
629 intel_hdmi
->has_audio
= false;
630 edid
= drm_get_edid(connector
,
631 intel_gmbus_get_adapter(dev_priv
,
632 intel_hdmi
->ddc_bus
));
635 if (edid
->input
& DRM_EDID_INPUT_DIGITAL
) {
636 status
= connector_status_connected
;
637 if (intel_hdmi
->force_audio
!= HDMI_AUDIO_OFF_DVI
)
638 intel_hdmi
->has_hdmi_sink
=
639 drm_detect_hdmi_monitor(edid
);
640 intel_hdmi
->has_audio
= drm_detect_monitor_audio(edid
);
642 connector
->display_info
.raw_edid
= NULL
;
646 if (status
== connector_status_connected
) {
647 if (intel_hdmi
->force_audio
!= HDMI_AUDIO_AUTO
)
648 intel_hdmi
->has_audio
=
649 (intel_hdmi
->force_audio
== HDMI_AUDIO_ON
);
655 static int intel_hdmi_get_modes(struct drm_connector
*connector
)
657 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
658 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
660 /* We should parse the EDID data and find out if it's an HDMI sink so
661 * we can send audio to it.
664 return intel_ddc_get_modes(connector
,
665 intel_gmbus_get_adapter(dev_priv
,
666 intel_hdmi
->ddc_bus
));
670 intel_hdmi_detect_audio(struct drm_connector
*connector
)
672 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
673 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
675 bool has_audio
= false;
677 edid
= drm_get_edid(connector
,
678 intel_gmbus_get_adapter(dev_priv
,
679 intel_hdmi
->ddc_bus
));
681 if (edid
->input
& DRM_EDID_INPUT_DIGITAL
)
682 has_audio
= drm_detect_monitor_audio(edid
);
684 connector
->display_info
.raw_edid
= NULL
;
692 intel_hdmi_set_property(struct drm_connector
*connector
,
693 struct drm_property
*property
,
696 struct intel_hdmi
*intel_hdmi
= intel_attached_hdmi(connector
);
697 struct drm_i915_private
*dev_priv
= connector
->dev
->dev_private
;
700 ret
= drm_connector_property_set_value(connector
, property
, val
);
704 if (property
== dev_priv
->force_audio_property
) {
705 enum hdmi_force_audio i
= val
;
708 if (i
== intel_hdmi
->force_audio
)
711 intel_hdmi
->force_audio
= i
;
713 if (i
== HDMI_AUDIO_AUTO
)
714 has_audio
= intel_hdmi_detect_audio(connector
);
716 has_audio
= (i
== HDMI_AUDIO_ON
);
718 if (i
== HDMI_AUDIO_OFF_DVI
)
719 intel_hdmi
->has_hdmi_sink
= 0;
721 intel_hdmi
->has_audio
= has_audio
;
725 if (property
== dev_priv
->broadcast_rgb_property
) {
726 if (val
== !!intel_hdmi
->color_range
)
729 intel_hdmi
->color_range
= val
? SDVO_COLOR_RANGE_16_235
: 0;
736 if (intel_hdmi
->base
.base
.crtc
) {
737 struct drm_crtc
*crtc
= intel_hdmi
->base
.base
.crtc
;
738 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
746 static void intel_hdmi_destroy(struct drm_connector
*connector
)
748 drm_sysfs_connector_remove(connector
);
749 drm_connector_cleanup(connector
);
753 static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs_hsw
= {
754 .dpms
= intel_ddi_dpms
,
755 .mode_fixup
= intel_hdmi_mode_fixup
,
756 .prepare
= intel_encoder_prepare
,
757 .mode_set
= intel_ddi_mode_set
,
758 .commit
= intel_encoder_commit
,
761 static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs
= {
762 .dpms
= intel_hdmi_dpms
,
763 .mode_fixup
= intel_hdmi_mode_fixup
,
764 .prepare
= intel_encoder_prepare
,
765 .mode_set
= intel_hdmi_mode_set
,
766 .commit
= intel_encoder_commit
,
769 static const struct drm_connector_funcs intel_hdmi_connector_funcs
= {
770 .dpms
= drm_helper_connector_dpms
,
771 .detect
= intel_hdmi_detect
,
772 .fill_modes
= drm_helper_probe_single_connector_modes
,
773 .set_property
= intel_hdmi_set_property
,
774 .destroy
= intel_hdmi_destroy
,
777 static const struct drm_connector_helper_funcs intel_hdmi_connector_helper_funcs
= {
778 .get_modes
= intel_hdmi_get_modes
,
779 .mode_valid
= intel_hdmi_mode_valid
,
780 .best_encoder
= intel_best_encoder
,
783 static const struct drm_encoder_funcs intel_hdmi_enc_funcs
= {
784 .destroy
= intel_encoder_destroy
,
788 intel_hdmi_add_properties(struct intel_hdmi
*intel_hdmi
, struct drm_connector
*connector
)
790 intel_attach_force_audio_property(connector
);
791 intel_attach_broadcast_rgb_property(connector
);
794 void intel_hdmi_init(struct drm_device
*dev
, int sdvox_reg
)
796 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
797 struct drm_connector
*connector
;
798 struct intel_encoder
*intel_encoder
;
799 struct intel_connector
*intel_connector
;
800 struct intel_hdmi
*intel_hdmi
;
803 intel_hdmi
= kzalloc(sizeof(struct intel_hdmi
), GFP_KERNEL
);
807 intel_connector
= kzalloc(sizeof(struct intel_connector
), GFP_KERNEL
);
808 if (!intel_connector
) {
813 intel_encoder
= &intel_hdmi
->base
;
814 drm_encoder_init(dev
, &intel_encoder
->base
, &intel_hdmi_enc_funcs
,
815 DRM_MODE_ENCODER_TMDS
);
817 connector
= &intel_connector
->base
;
818 drm_connector_init(dev
, connector
, &intel_hdmi_connector_funcs
,
819 DRM_MODE_CONNECTOR_HDMIA
);
820 drm_connector_helper_add(connector
, &intel_hdmi_connector_helper_funcs
);
822 intel_encoder
->type
= INTEL_OUTPUT_HDMI
;
824 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
825 connector
->interlace_allowed
= 1;
826 connector
->doublescan_allowed
= 0;
827 intel_encoder
->crtc_mask
= (1 << 0) | (1 << 1) | (1 << 2);
829 /* Set up the DDC bus. */
830 if (sdvox_reg
== SDVOB
) {
831 intel_encoder
->clone_mask
= (1 << INTEL_HDMIB_CLONE_BIT
);
832 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPB
;
833 dev_priv
->hotplug_supported_mask
|= HDMIB_HOTPLUG_INT_STATUS
;
834 } else if (sdvox_reg
== SDVOC
) {
835 intel_encoder
->clone_mask
= (1 << INTEL_HDMIC_CLONE_BIT
);
836 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPC
;
837 dev_priv
->hotplug_supported_mask
|= HDMIC_HOTPLUG_INT_STATUS
;
838 } else if (sdvox_reg
== HDMIB
) {
839 intel_encoder
->clone_mask
= (1 << INTEL_HDMID_CLONE_BIT
);
840 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPB
;
841 dev_priv
->hotplug_supported_mask
|= HDMIB_HOTPLUG_INT_STATUS
;
842 } else if (sdvox_reg
== HDMIC
) {
843 intel_encoder
->clone_mask
= (1 << INTEL_HDMIE_CLONE_BIT
);
844 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPC
;
845 dev_priv
->hotplug_supported_mask
|= HDMIC_HOTPLUG_INT_STATUS
;
846 } else if (sdvox_reg
== HDMID
) {
847 intel_encoder
->clone_mask
= (1 << INTEL_HDMIF_CLONE_BIT
);
848 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPD
;
849 dev_priv
->hotplug_supported_mask
|= HDMID_HOTPLUG_INT_STATUS
;
850 } else if (sdvox_reg
== DDI_BUF_CTL(PORT_B
)) {
851 DRM_DEBUG_DRIVER("LPT: detected output on DDI B\n");
852 intel_encoder
->clone_mask
= (1 << INTEL_HDMIB_CLONE_BIT
);
853 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPB
;
854 intel_hdmi
->ddi_port
= PORT_B
;
855 dev_priv
->hotplug_supported_mask
|= HDMIB_HOTPLUG_INT_STATUS
;
856 } else if (sdvox_reg
== DDI_BUF_CTL(PORT_C
)) {
857 DRM_DEBUG_DRIVER("LPT: detected output on DDI C\n");
858 intel_encoder
->clone_mask
= (1 << INTEL_HDMIC_CLONE_BIT
);
859 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPC
;
860 intel_hdmi
->ddi_port
= PORT_C
;
861 dev_priv
->hotplug_supported_mask
|= HDMIC_HOTPLUG_INT_STATUS
;
862 } else if (sdvox_reg
== DDI_BUF_CTL(PORT_D
)) {
863 DRM_DEBUG_DRIVER("LPT: detected output on DDI D\n");
864 intel_encoder
->clone_mask
= (1 << INTEL_HDMID_CLONE_BIT
);
865 intel_hdmi
->ddc_bus
= GMBUS_PORT_DPD
;
866 intel_hdmi
->ddi_port
= PORT_D
;
867 dev_priv
->hotplug_supported_mask
|= HDMID_HOTPLUG_INT_STATUS
;
869 /* If we got an unknown sdvox_reg, things are pretty much broken
870 * in a way that we should let the kernel know about it */
874 intel_hdmi
->sdvox_reg
= sdvox_reg
;
876 if (!HAS_PCH_SPLIT(dev
)) {
877 intel_hdmi
->write_infoframe
= g4x_write_infoframe
;
878 intel_hdmi
->set_infoframes
= g4x_set_infoframes
;
879 I915_WRITE(VIDEO_DIP_CTL
, 0);
880 } else if (IS_VALLEYVIEW(dev
)) {
881 intel_hdmi
->write_infoframe
= vlv_write_infoframe
;
882 intel_hdmi
->set_infoframes
= vlv_set_infoframes
;
884 I915_WRITE(VLV_TVIDEO_DIP_CTL(i
), 0);
885 } else if (IS_HASWELL(dev
)) {
886 /* FIXME: Haswell has a new set of DIP frame registers, but we are
887 * just doing the minimal required for HDMI to work at this stage.
889 intel_hdmi
->write_infoframe
= hsw_write_infoframe
;
890 intel_hdmi
->set_infoframes
= hsw_set_infoframes
;
892 I915_WRITE(HSW_TVIDEO_DIP_CTL(i
), 0);
893 } else if (HAS_PCH_IBX(dev
)) {
894 intel_hdmi
->write_infoframe
= ibx_write_infoframe
;
895 intel_hdmi
->set_infoframes
= ibx_set_infoframes
;
897 I915_WRITE(TVIDEO_DIP_CTL(i
), 0);
899 intel_hdmi
->write_infoframe
= cpt_write_infoframe
;
900 intel_hdmi
->set_infoframes
= cpt_set_infoframes
;
902 I915_WRITE(TVIDEO_DIP_CTL(i
), 0);
906 drm_encoder_helper_add(&intel_encoder
->base
, &intel_hdmi_helper_funcs_hsw
);
908 drm_encoder_helper_add(&intel_encoder
->base
, &intel_hdmi_helper_funcs
);
910 intel_hdmi_add_properties(intel_hdmi
, connector
);
912 intel_connector_attach_encoder(intel_connector
, intel_encoder
);
913 drm_sysfs_connector_add(connector
);
915 /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
916 * 0xd. Failure to do so will result in spurious interrupts being
917 * generated on the port when a cable is not attached.
919 if (IS_G4X(dev
) && !IS_GM45(dev
)) {
920 u32 temp
= I915_READ(PEG_BAND_GAP_DATA
);
921 I915_WRITE(PEG_BAND_GAP_DATA
, (temp
& ~0xf) | 0xd);