]>
Commit | Line | Data |
---|---|---|
6a227d5f AC |
1 | /* |
2 | * Copyright © 2006-2011 Intel Corporation | |
3 | * | |
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: | |
10 | * | |
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 | |
13 | * Software. | |
14 | * | |
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. | |
22 | * | |
23 | * Authors: | |
24 | * jim liu <jim.liu@intel.com> | |
25 | * | |
26 | * FIXME: | |
27 | * We should probably make this generic and share it with Medfield | |
28 | */ | |
29 | ||
30 | #include <drm/drmP.h> | |
31 | #include <drm/drm.h> | |
32 | #include <drm/drm_crtc.h> | |
33 | #include <drm/drm_edid.h> | |
34 | #include "psb_intel_drv.h" | |
35 | #include "psb_drv.h" | |
36 | #include "psb_intel_reg.h" | |
455b9e91 | 37 | #include "cdv_device.h" |
6a227d5f AC |
38 | #include <linux/pm_runtime.h> |
39 | ||
40 | /* hdmi control bits */ | |
41 | #define HDMI_NULL_PACKETS_DURING_VSYNC (1 << 9) | |
42 | #define HDMI_BORDER_ENABLE (1 << 7) | |
43 | #define HDMI_AUDIO_ENABLE (1 << 6) | |
44 | #define HDMI_VSYNC_ACTIVE_HIGH (1 << 4) | |
45 | #define HDMI_HSYNC_ACTIVE_HIGH (1 << 3) | |
46 | /* hdmi-b control bits */ | |
47 | #define HDMIB_PIPE_B_SELECT (1 << 30) | |
48 | ||
49 | ||
50 | struct mid_intel_hdmi_priv { | |
51 | u32 hdmi_reg; | |
52 | u32 save_HDMIB; | |
53 | bool has_hdmi_sink; | |
54 | bool has_hdmi_audio; | |
55 | /* Should set this when detect hotplug */ | |
56 | bool hdmi_device_connected; | |
57 | struct mdfld_hdmi_i2c *i2c_bus; | |
58 | struct i2c_adapter *hdmi_i2c_adapter; /* for control functions */ | |
59 | struct drm_device *dev; | |
60 | }; | |
61 | ||
62 | static void cdv_hdmi_mode_set(struct drm_encoder *encoder, | |
63 | struct drm_display_mode *mode, | |
64 | struct drm_display_mode *adjusted_mode) | |
65 | { | |
66 | struct drm_device *dev = encoder->dev; | |
367e4408 PJ |
67 | struct gma_encoder *gma_encoder = to_gma_encoder(encoder); |
68 | struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv; | |
6a227d5f AC |
69 | u32 hdmib; |
70 | struct drm_crtc *crtc = encoder->crtc; | |
6306865d | 71 | struct gma_crtc *gma_crtc = to_gma_crtc(crtc); |
6a227d5f AC |
72 | |
73 | hdmib = (2 << 10); | |
74 | ||
75 | if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC) | |
76 | hdmib |= HDMI_VSYNC_ACTIVE_HIGH; | |
77 | if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC) | |
78 | hdmib |= HDMI_HSYNC_ACTIVE_HIGH; | |
79 | ||
6306865d | 80 | if (gma_crtc->pipe == 1) |
6a227d5f AC |
81 | hdmib |= HDMIB_PIPE_B_SELECT; |
82 | ||
83 | if (hdmi_priv->has_hdmi_audio) { | |
84 | hdmib |= HDMI_AUDIO_ENABLE; | |
85 | hdmib |= HDMI_NULL_PACKETS_DURING_VSYNC; | |
86 | } | |
87 | ||
88 | REG_WRITE(hdmi_priv->hdmi_reg, hdmib); | |
89 | REG_READ(hdmi_priv->hdmi_reg); | |
90 | } | |
91 | ||
6a227d5f AC |
92 | static void cdv_hdmi_dpms(struct drm_encoder *encoder, int mode) |
93 | { | |
94 | struct drm_device *dev = encoder->dev; | |
367e4408 PJ |
95 | struct gma_encoder *gma_encoder = to_gma_encoder(encoder); |
96 | struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv; | |
6a227d5f AC |
97 | u32 hdmib; |
98 | ||
99 | hdmib = REG_READ(hdmi_priv->hdmi_reg); | |
100 | ||
101 | if (mode != DRM_MODE_DPMS_ON) | |
102 | REG_WRITE(hdmi_priv->hdmi_reg, hdmib & ~HDMIB_PORT_EN); | |
103 | else | |
104 | REG_WRITE(hdmi_priv->hdmi_reg, hdmib | HDMIB_PORT_EN); | |
105 | REG_READ(hdmi_priv->hdmi_reg); | |
106 | } | |
107 | ||
108 | static void cdv_hdmi_save(struct drm_connector *connector) | |
109 | { | |
110 | struct drm_device *dev = connector->dev; | |
367e4408 PJ |
111 | struct gma_encoder *gma_encoder = gma_attached_encoder(connector); |
112 | struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv; | |
6a227d5f AC |
113 | |
114 | hdmi_priv->save_HDMIB = REG_READ(hdmi_priv->hdmi_reg); | |
115 | } | |
116 | ||
117 | static void cdv_hdmi_restore(struct drm_connector *connector) | |
118 | { | |
119 | struct drm_device *dev = connector->dev; | |
367e4408 PJ |
120 | struct gma_encoder *gma_encoder = gma_attached_encoder(connector); |
121 | struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv; | |
6a227d5f AC |
122 | |
123 | REG_WRITE(hdmi_priv->hdmi_reg, hdmi_priv->save_HDMIB); | |
124 | REG_READ(hdmi_priv->hdmi_reg); | |
125 | } | |
126 | ||
127 | static enum drm_connector_status cdv_hdmi_detect( | |
128 | struct drm_connector *connector, bool force) | |
129 | { | |
367e4408 PJ |
130 | struct gma_encoder *gma_encoder = gma_attached_encoder(connector); |
131 | struct mid_intel_hdmi_priv *hdmi_priv = gma_encoder->dev_priv; | |
6a227d5f AC |
132 | struct edid *edid = NULL; |
133 | enum drm_connector_status status = connector_status_disconnected; | |
134 | ||
367e4408 | 135 | edid = drm_get_edid(connector, &gma_encoder->i2c_bus->adapter); |
6a227d5f AC |
136 | |
137 | hdmi_priv->has_hdmi_sink = false; | |
138 | hdmi_priv->has_hdmi_audio = false; | |
139 | if (edid) { | |
140 | if (edid->input & DRM_EDID_INPUT_DIGITAL) { | |
141 | status = connector_status_connected; | |
142 | hdmi_priv->has_hdmi_sink = | |
143 | drm_detect_hdmi_monitor(edid); | |
144 | hdmi_priv->has_hdmi_audio = | |
145 | drm_detect_monitor_audio(edid); | |
146 | } | |
6a227d5f AC |
147 | kfree(edid); |
148 | } | |
149 | return status; | |
150 | } | |
151 | ||
152 | static int cdv_hdmi_set_property(struct drm_connector *connector, | |
153 | struct drm_property *property, | |
154 | uint64_t value) | |
155 | { | |
156 | struct drm_encoder *encoder = connector->encoder; | |
157 | ||
158 | if (!strcmp(property->name, "scaling mode") && encoder) { | |
6306865d | 159 | struct gma_crtc *crtc = to_gma_crtc(encoder->crtc); |
6a227d5f AC |
160 | bool centre; |
161 | uint64_t curValue; | |
162 | ||
163 | if (!crtc) | |
164 | return -1; | |
165 | ||
166 | switch (value) { | |
167 | case DRM_MODE_SCALE_FULLSCREEN: | |
168 | break; | |
169 | case DRM_MODE_SCALE_NO_SCALE: | |
170 | break; | |
171 | case DRM_MODE_SCALE_ASPECT: | |
172 | break; | |
173 | default: | |
174 | return -1; | |
175 | } | |
176 | ||
a69ac9ea | 177 | if (drm_object_property_get_value(&connector->base, |
6a227d5f AC |
178 | property, &curValue)) |
179 | return -1; | |
180 | ||
181 | if (curValue == value) | |
182 | return 0; | |
183 | ||
a69ac9ea | 184 | if (drm_object_property_set_value(&connector->base, |
6a227d5f AC |
185 | property, value)) |
186 | return -1; | |
187 | ||
188 | centre = (curValue == DRM_MODE_SCALE_NO_SCALE) || | |
189 | (value == DRM_MODE_SCALE_NO_SCALE); | |
190 | ||
191 | if (crtc->saved_mode.hdisplay != 0 && | |
192 | crtc->saved_mode.vdisplay != 0) { | |
193 | if (centre) { | |
194 | if (!drm_crtc_helper_set_mode(encoder->crtc, &crtc->saved_mode, | |
f4510a27 | 195 | encoder->crtc->x, encoder->crtc->y, encoder->crtc->primary->fb)) |
6a227d5f AC |
196 | return -1; |
197 | } else { | |
198 | struct drm_encoder_helper_funcs *helpers | |
199 | = encoder->helper_private; | |
200 | helpers->mode_set(encoder, &crtc->saved_mode, | |
201 | &crtc->saved_adjusted_mode); | |
202 | } | |
203 | } | |
204 | } | |
205 | return 0; | |
206 | } | |
207 | ||
208 | /* | |
209 | * Return the list of HDMI DDC modes if available. | |
210 | */ | |
211 | static int cdv_hdmi_get_modes(struct drm_connector *connector) | |
212 | { | |
367e4408 | 213 | struct gma_encoder *gma_encoder = gma_attached_encoder(connector); |
6a227d5f AC |
214 | struct edid *edid = NULL; |
215 | int ret = 0; | |
216 | ||
367e4408 | 217 | edid = drm_get_edid(connector, &gma_encoder->i2c_bus->adapter); |
6a227d5f | 218 | if (edid) { |
a12d6a07 PJ |
219 | drm_mode_connector_update_edid_property(connector, edid); |
220 | ret = drm_add_edid_modes(connector, edid); | |
6a227d5f AC |
221 | kfree(edid); |
222 | } | |
223 | return ret; | |
224 | } | |
225 | ||
226 | static int cdv_hdmi_mode_valid(struct drm_connector *connector, | |
227 | struct drm_display_mode *mode) | |
228 | { | |
6a227d5f AC |
229 | if (mode->clock > 165000) |
230 | return MODE_CLOCK_HIGH; | |
231 | if (mode->clock < 20000) | |
232 | return MODE_CLOCK_HIGH; | |
233 | ||
234 | /* just in case */ | |
235 | if (mode->flags & DRM_MODE_FLAG_DBLSCAN) | |
236 | return MODE_NO_DBLESCAN; | |
237 | ||
238 | /* just in case */ | |
239 | if (mode->flags & DRM_MODE_FLAG_INTERLACE) | |
240 | return MODE_NO_INTERLACE; | |
241 | ||
6a227d5f AC |
242 | return MODE_OK; |
243 | } | |
244 | ||
245 | static void cdv_hdmi_destroy(struct drm_connector *connector) | |
246 | { | |
367e4408 | 247 | struct gma_encoder *gma_encoder = gma_attached_encoder(connector); |
6a227d5f | 248 | |
367e4408 PJ |
249 | if (gma_encoder->i2c_bus) |
250 | psb_intel_i2c_destroy(gma_encoder->i2c_bus); | |
6a227d5f AC |
251 | drm_sysfs_connector_remove(connector); |
252 | drm_connector_cleanup(connector); | |
253 | kfree(connector); | |
254 | } | |
255 | ||
256 | static const struct drm_encoder_helper_funcs cdv_hdmi_helper_funcs = { | |
257 | .dpms = cdv_hdmi_dpms, | |
19519943 | 258 | .mode_fixup = gma_encoder_mode_fixup, |
c9d49590 | 259 | .prepare = gma_encoder_prepare, |
6a227d5f | 260 | .mode_set = cdv_hdmi_mode_set, |
c9d49590 | 261 | .commit = gma_encoder_commit, |
6a227d5f AC |
262 | }; |
263 | ||
264 | static const struct drm_connector_helper_funcs | |
265 | cdv_hdmi_connector_helper_funcs = { | |
266 | .get_modes = cdv_hdmi_get_modes, | |
267 | .mode_valid = cdv_hdmi_mode_valid, | |
c9d49590 | 268 | .best_encoder = gma_best_encoder, |
6a227d5f AC |
269 | }; |
270 | ||
271 | static const struct drm_connector_funcs cdv_hdmi_connector_funcs = { | |
272 | .dpms = drm_helper_connector_dpms, | |
273 | .save = cdv_hdmi_save, | |
274 | .restore = cdv_hdmi_restore, | |
275 | .detect = cdv_hdmi_detect, | |
276 | .fill_modes = drm_helper_probe_single_connector_modes, | |
277 | .set_property = cdv_hdmi_set_property, | |
278 | .destroy = cdv_hdmi_destroy, | |
279 | }; | |
280 | ||
281 | void cdv_hdmi_init(struct drm_device *dev, | |
282 | struct psb_intel_mode_device *mode_dev, int reg) | |
283 | { | |
367e4408 | 284 | struct gma_encoder *gma_encoder; |
a3d5d75f | 285 | struct gma_connector *gma_connector; |
6a227d5f AC |
286 | struct drm_connector *connector; |
287 | struct drm_encoder *encoder; | |
288 | struct mid_intel_hdmi_priv *hdmi_priv; | |
289 | int ddc_bus; | |
290 | ||
367e4408 | 291 | gma_encoder = kzalloc(sizeof(struct gma_encoder), GFP_KERNEL); |
a12d6a07 | 292 | |
367e4408 | 293 | if (!gma_encoder) |
6a227d5f AC |
294 | return; |
295 | ||
a3d5d75f | 296 | gma_connector = kzalloc(sizeof(struct gma_connector), |
a12d6a07 PJ |
297 | GFP_KERNEL); |
298 | ||
a3d5d75f | 299 | if (!gma_connector) |
a12d6a07 PJ |
300 | goto err_connector; |
301 | ||
302 | hdmi_priv = kzalloc(sizeof(struct mid_intel_hdmi_priv), GFP_KERNEL); | |
303 | ||
304 | if (!hdmi_priv) | |
305 | goto err_priv; | |
306 | ||
a3d5d75f | 307 | connector = &gma_connector->base; |
bda50031 | 308 | connector->polled = DRM_CONNECTOR_POLL_HPD; |
367e4408 | 309 | encoder = &gma_encoder->base; |
a12d6a07 | 310 | drm_connector_init(dev, connector, |
6a227d5f AC |
311 | &cdv_hdmi_connector_funcs, |
312 | DRM_MODE_CONNECTOR_DVID); | |
313 | ||
a12d6a07 | 314 | drm_encoder_init(dev, encoder, &psb_intel_lvds_enc_funcs, |
6a227d5f AC |
315 | DRM_MODE_ENCODER_TMDS); |
316 | ||
367e4408 PJ |
317 | gma_connector_attach_encoder(gma_connector, gma_encoder); |
318 | gma_encoder->type = INTEL_OUTPUT_HDMI; | |
6a227d5f AC |
319 | hdmi_priv->hdmi_reg = reg; |
320 | hdmi_priv->has_hdmi_sink = false; | |
367e4408 | 321 | gma_encoder->dev_priv = hdmi_priv; |
6a227d5f AC |
322 | |
323 | drm_encoder_helper_add(encoder, &cdv_hdmi_helper_funcs); | |
324 | drm_connector_helper_add(connector, | |
325 | &cdv_hdmi_connector_helper_funcs); | |
326 | connector->display_info.subpixel_order = SubPixelHorizontalRGB; | |
327 | connector->interlace_allowed = false; | |
328 | connector->doublescan_allowed = false; | |
329 | ||
a69ac9ea | 330 | drm_object_attach_property(&connector->base, |
a12d6a07 PJ |
331 | dev->mode_config.scaling_mode_property, |
332 | DRM_MODE_SCALE_FULLSCREEN); | |
6a227d5f AC |
333 | |
334 | switch (reg) { | |
335 | case SDVOB: | |
336 | ddc_bus = GPIOE; | |
367e4408 | 337 | gma_encoder->ddi_select = DDI0_SELECT; |
6a227d5f AC |
338 | break; |
339 | case SDVOC: | |
340 | ddc_bus = GPIOD; | |
367e4408 | 341 | gma_encoder->ddi_select = DDI1_SELECT; |
6a227d5f AC |
342 | break; |
343 | default: | |
344 | DRM_ERROR("unknown reg 0x%x for HDMI\n", reg); | |
345 | goto failed_ddc; | |
346 | break; | |
347 | } | |
348 | ||
367e4408 | 349 | gma_encoder->i2c_bus = psb_intel_i2c_create(dev, |
6a227d5f AC |
350 | ddc_bus, (reg == SDVOB) ? "HDMIB" : "HDMIC"); |
351 | ||
367e4408 | 352 | if (!gma_encoder->i2c_bus) { |
6a227d5f AC |
353 | dev_err(dev->dev, "No ddc adapter available!\n"); |
354 | goto failed_ddc; | |
355 | } | |
a12d6a07 | 356 | |
367e4408 | 357 | hdmi_priv->hdmi_i2c_adapter = &(gma_encoder->i2c_bus->adapter); |
6a227d5f AC |
358 | hdmi_priv->dev = dev; |
359 | drm_sysfs_connector_add(connector); | |
360 | return; | |
361 | ||
362 | failed_ddc: | |
a12d6a07 PJ |
363 | drm_encoder_cleanup(encoder); |
364 | drm_connector_cleanup(connector); | |
365 | err_priv: | |
a3d5d75f | 366 | kfree(gma_connector); |
a12d6a07 | 367 | err_connector: |
367e4408 | 368 | kfree(gma_encoder); |
6a227d5f | 369 | } |