2 * Copyright © 2006-2011 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
24 * jim liu <jim.liu@intel.com>
27 * We should probably make this generic and share it with Medfield
32 #include <drm/drm_crtc.h>
33 #include <drm/drm_edid.h>
34 #include "psb_intel_drv.h"
36 #include "psb_intel_reg.h"
37 #include <linux/pm_runtime.h>
39 /* hdmi control bits */
40 #define HDMI_NULL_PACKETS_DURING_VSYNC (1 << 9)
41 #define HDMI_BORDER_ENABLE (1 << 7)
42 #define HDMI_AUDIO_ENABLE (1 << 6)
43 #define HDMI_VSYNC_ACTIVE_HIGH (1 << 4)
44 #define HDMI_HSYNC_ACTIVE_HIGH (1 << 3)
45 /* hdmi-b control bits */
46 #define HDMIB_PIPE_B_SELECT (1 << 30)
49 struct mid_intel_hdmi_priv
{
54 /* Should set this when detect hotplug */
55 bool hdmi_device_connected
;
56 struct mdfld_hdmi_i2c
*i2c_bus
;
57 struct i2c_adapter
*hdmi_i2c_adapter
; /* for control functions */
58 struct drm_device
*dev
;
61 static void cdv_hdmi_mode_set(struct drm_encoder
*encoder
,
62 struct drm_display_mode
*mode
,
63 struct drm_display_mode
*adjusted_mode
)
65 struct drm_device
*dev
= encoder
->dev
;
66 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
67 struct mid_intel_hdmi_priv
*hdmi_priv
= output
->dev_priv
;
69 struct drm_crtc
*crtc
= encoder
->crtc
;
70 struct psb_intel_crtc
*intel_crtc
= to_psb_intel_crtc(crtc
);
74 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PVSYNC
)
75 hdmib
|= HDMI_VSYNC_ACTIVE_HIGH
;
76 if (adjusted_mode
->flags
& DRM_MODE_FLAG_PHSYNC
)
77 hdmib
|= HDMI_HSYNC_ACTIVE_HIGH
;
79 if (intel_crtc
->pipe
== 1)
80 hdmib
|= HDMIB_PIPE_B_SELECT
;
82 if (hdmi_priv
->has_hdmi_audio
) {
83 hdmib
|= HDMI_AUDIO_ENABLE
;
84 hdmib
|= HDMI_NULL_PACKETS_DURING_VSYNC
;
87 REG_WRITE(hdmi_priv
->hdmi_reg
, hdmib
);
88 REG_READ(hdmi_priv
->hdmi_reg
);
91 static bool cdv_hdmi_mode_fixup(struct drm_encoder
*encoder
,
92 struct drm_display_mode
*mode
,
93 struct drm_display_mode
*adjusted_mode
)
98 static void cdv_hdmi_dpms(struct drm_encoder
*encoder
, int mode
)
100 struct drm_device
*dev
= encoder
->dev
;
101 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
102 struct mid_intel_hdmi_priv
*hdmi_priv
= output
->dev_priv
;
105 hdmib
= REG_READ(hdmi_priv
->hdmi_reg
);
107 if (mode
!= DRM_MODE_DPMS_ON
)
108 REG_WRITE(hdmi_priv
->hdmi_reg
, hdmib
& ~HDMIB_PORT_EN
);
110 REG_WRITE(hdmi_priv
->hdmi_reg
, hdmib
| HDMIB_PORT_EN
);
111 REG_READ(hdmi_priv
->hdmi_reg
);
114 static void cdv_hdmi_save(struct drm_connector
*connector
)
116 struct drm_device
*dev
= connector
->dev
;
117 struct psb_intel_output
*output
= to_psb_intel_output(connector
);
118 struct mid_intel_hdmi_priv
*hdmi_priv
= output
->dev_priv
;
120 hdmi_priv
->save_HDMIB
= REG_READ(hdmi_priv
->hdmi_reg
);
123 static void cdv_hdmi_restore(struct drm_connector
*connector
)
125 struct drm_device
*dev
= connector
->dev
;
126 struct psb_intel_output
*output
= to_psb_intel_output(connector
);
127 struct mid_intel_hdmi_priv
*hdmi_priv
= output
->dev_priv
;
129 REG_WRITE(hdmi_priv
->hdmi_reg
, hdmi_priv
->save_HDMIB
);
130 REG_READ(hdmi_priv
->hdmi_reg
);
133 static enum drm_connector_status
cdv_hdmi_detect(
134 struct drm_connector
*connector
, bool force
)
136 struct psb_intel_output
*psb_intel_output
=
137 to_psb_intel_output(connector
);
138 struct mid_intel_hdmi_priv
*hdmi_priv
= psb_intel_output
->dev_priv
;
139 struct edid
*edid
= NULL
;
140 enum drm_connector_status status
= connector_status_disconnected
;
142 edid
= drm_get_edid(&psb_intel_output
->base
,
143 psb_intel_output
->hdmi_i2c_adapter
);
145 hdmi_priv
->has_hdmi_sink
= false;
146 hdmi_priv
->has_hdmi_audio
= false;
148 if (edid
->input
& DRM_EDID_INPUT_DIGITAL
) {
149 status
= connector_status_connected
;
150 hdmi_priv
->has_hdmi_sink
=
151 drm_detect_hdmi_monitor(edid
);
152 hdmi_priv
->has_hdmi_audio
=
153 drm_detect_monitor_audio(edid
);
156 psb_intel_output
->base
.display_info
.raw_edid
= NULL
;
162 static int cdv_hdmi_set_property(struct drm_connector
*connector
,
163 struct drm_property
*property
,
166 struct drm_encoder
*encoder
= connector
->encoder
;
168 if (!strcmp(property
->name
, "scaling mode") && encoder
) {
169 struct psb_intel_crtc
*crtc
= to_psb_intel_crtc(encoder
->crtc
);
177 case DRM_MODE_SCALE_FULLSCREEN
:
179 case DRM_MODE_SCALE_NO_SCALE
:
181 case DRM_MODE_SCALE_ASPECT
:
187 if (drm_connector_property_get_value(connector
,
188 property
, &curValue
))
191 if (curValue
== value
)
194 if (drm_connector_property_set_value(connector
,
198 centre
= (curValue
== DRM_MODE_SCALE_NO_SCALE
) ||
199 (value
== DRM_MODE_SCALE_NO_SCALE
);
201 if (crtc
->saved_mode
.hdisplay
!= 0 &&
202 crtc
->saved_mode
.vdisplay
!= 0) {
204 if (!drm_crtc_helper_set_mode(encoder
->crtc
, &crtc
->saved_mode
,
205 encoder
->crtc
->x
, encoder
->crtc
->y
, encoder
->crtc
->fb
))
208 struct drm_encoder_helper_funcs
*helpers
209 = encoder
->helper_private
;
210 helpers
->mode_set(encoder
, &crtc
->saved_mode
,
211 &crtc
->saved_adjusted_mode
);
219 * Return the list of HDMI DDC modes if available.
221 static int cdv_hdmi_get_modes(struct drm_connector
*connector
)
223 struct psb_intel_output
*psb_intel_output
=
224 to_psb_intel_output(connector
);
225 struct edid
*edid
= NULL
;
228 edid
= drm_get_edid(&psb_intel_output
->base
,
229 psb_intel_output
->hdmi_i2c_adapter
);
231 drm_mode_connector_update_edid_property(&psb_intel_output
->
233 ret
= drm_add_edid_modes(&psb_intel_output
->base
, edid
);
239 static int cdv_hdmi_mode_valid(struct drm_connector
*connector
,
240 struct drm_display_mode
*mode
)
243 if (mode
->clock
> 165000)
244 return MODE_CLOCK_HIGH
;
245 if (mode
->clock
< 20000)
246 return MODE_CLOCK_HIGH
;
249 if (mode
->flags
& DRM_MODE_FLAG_DBLSCAN
)
250 return MODE_NO_DBLESCAN
;
253 if (mode
->flags
& DRM_MODE_FLAG_INTERLACE
)
254 return MODE_NO_INTERLACE
;
257 * FIXME: for now we limit the size to 1680x1050 on CDV, otherwise it
258 * will go beyond the stolen memory size allocated to the framebuffer
260 if (mode
->hdisplay
> 1680)
262 if (mode
->vdisplay
> 1050)
267 static void cdv_hdmi_destroy(struct drm_connector
*connector
)
269 struct psb_intel_output
*psb_intel_output
=
270 to_psb_intel_output(connector
);
272 if (psb_intel_output
->ddc_bus
)
273 psb_intel_i2c_destroy(psb_intel_output
->ddc_bus
);
274 drm_sysfs_connector_remove(connector
);
275 drm_connector_cleanup(connector
);
279 static const struct drm_encoder_helper_funcs cdv_hdmi_helper_funcs
= {
280 .dpms
= cdv_hdmi_dpms
,
281 .mode_fixup
= cdv_hdmi_mode_fixup
,
282 .prepare
= psb_intel_encoder_prepare
,
283 .mode_set
= cdv_hdmi_mode_set
,
284 .commit
= psb_intel_encoder_commit
,
287 static const struct drm_connector_helper_funcs
288 cdv_hdmi_connector_helper_funcs
= {
289 .get_modes
= cdv_hdmi_get_modes
,
290 .mode_valid
= cdv_hdmi_mode_valid
,
291 .best_encoder
= psb_intel_best_encoder
,
294 static const struct drm_connector_funcs cdv_hdmi_connector_funcs
= {
295 .dpms
= drm_helper_connector_dpms
,
296 .save
= cdv_hdmi_save
,
297 .restore
= cdv_hdmi_restore
,
298 .detect
= cdv_hdmi_detect
,
299 .fill_modes
= drm_helper_probe_single_connector_modes
,
300 .set_property
= cdv_hdmi_set_property
,
301 .destroy
= cdv_hdmi_destroy
,
304 void cdv_hdmi_init(struct drm_device
*dev
,
305 struct psb_intel_mode_device
*mode_dev
, int reg
)
307 struct psb_intel_output
*psb_intel_output
;
308 struct drm_connector
*connector
;
309 struct drm_encoder
*encoder
;
310 struct mid_intel_hdmi_priv
*hdmi_priv
;
313 psb_intel_output
= kzalloc(sizeof(struct psb_intel_output
) +
314 sizeof(struct mid_intel_hdmi_priv
), GFP_KERNEL
);
315 if (!psb_intel_output
)
318 hdmi_priv
= (struct mid_intel_hdmi_priv
*)(psb_intel_output
+ 1);
319 psb_intel_output
->mode_dev
= mode_dev
;
320 connector
= &psb_intel_output
->base
;
321 encoder
= &psb_intel_output
->enc
;
322 drm_connector_init(dev
, &psb_intel_output
->base
,
323 &cdv_hdmi_connector_funcs
,
324 DRM_MODE_CONNECTOR_DVID
);
326 drm_encoder_init(dev
, &psb_intel_output
->enc
, &psb_intel_lvds_enc_funcs
,
327 DRM_MODE_ENCODER_TMDS
);
329 drm_mode_connector_attach_encoder(&psb_intel_output
->base
,
330 &psb_intel_output
->enc
);
331 psb_intel_output
->type
= INTEL_OUTPUT_HDMI
;
332 hdmi_priv
->hdmi_reg
= reg
;
333 hdmi_priv
->has_hdmi_sink
= false;
334 psb_intel_output
->dev_priv
= hdmi_priv
;
336 drm_encoder_helper_add(encoder
, &cdv_hdmi_helper_funcs
);
337 drm_connector_helper_add(connector
,
338 &cdv_hdmi_connector_helper_funcs
);
339 connector
->display_info
.subpixel_order
= SubPixelHorizontalRGB
;
340 connector
->interlace_allowed
= false;
341 connector
->doublescan_allowed
= false;
343 drm_connector_attach_property(connector
,
344 dev
->mode_config
.scaling_mode_property
, DRM_MODE_SCALE_FULLSCREEN
);
354 DRM_ERROR("unknown reg 0x%x for HDMI\n", reg
);
359 psb_intel_output
->ddc_bus
= psb_intel_i2c_create(dev
,
360 ddc_bus
, (reg
== SDVOB
) ? "HDMIB" : "HDMIC");
362 if (!psb_intel_output
->ddc_bus
) {
363 dev_err(dev
->dev
, "No ddc adapter available!\n");
366 psb_intel_output
->hdmi_i2c_adapter
=
367 &(psb_intel_output
->ddc_bus
->adapter
);
368 hdmi_priv
->dev
= dev
;
369 drm_sysfs_connector_add(connector
);
373 drm_encoder_cleanup(&psb_intel_output
->enc
);
374 drm_connector_cleanup(&psb_intel_output
->base
);
375 kfree(psb_intel_output
);