Branch data Line data Source code
1 : : /*
2 : : * Copyright 2006 Dave Airlie <airlied@linux.ie>
3 : : * Copyright © 2006-2007 Intel Corporation
4 : : *
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:
11 : : *
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
14 : : * Software.
15 : : *
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.
23 : : *
24 : : * Authors:
25 : : * Eric Anholt <eric@anholt.net>
26 : : */
27 : :
28 : : #include <linux/i2c.h>
29 : : #include <linux/slab.h>
30 : :
31 : : #include <drm/drm_atomic_helper.h>
32 : : #include <drm/drm_crtc.h>
33 : : #include <drm/i915_drm.h>
34 : :
35 : : #include "i915_drv.h"
36 : : #include "intel_connector.h"
37 : : #include "intel_display_types.h"
38 : : #include "intel_dvo.h"
39 : : #include "intel_dvo_dev.h"
40 : : #include "intel_gmbus.h"
41 : : #include "intel_panel.h"
42 : :
43 : : #define INTEL_DVO_CHIP_NONE 0
44 : : #define INTEL_DVO_CHIP_LVDS 1
45 : : #define INTEL_DVO_CHIP_TMDS 2
46 : : #define INTEL_DVO_CHIP_TVOUT 4
47 : :
48 : : #define SIL164_ADDR 0x38
49 : : #define CH7xxx_ADDR 0x76
50 : : #define TFP410_ADDR 0x38
51 : : #define NS2501_ADDR 0x38
52 : :
53 : : static const struct intel_dvo_device intel_dvo_devices[] = {
54 : : {
55 : : .type = INTEL_DVO_CHIP_TMDS,
56 : : .name = "sil164",
57 : : .dvo_reg = DVOC,
58 : : .dvo_srcdim_reg = DVOC_SRCDIM,
59 : : .slave_addr = SIL164_ADDR,
60 : : .dev_ops = &sil164_ops,
61 : : },
62 : : {
63 : : .type = INTEL_DVO_CHIP_TMDS,
64 : : .name = "ch7xxx",
65 : : .dvo_reg = DVOC,
66 : : .dvo_srcdim_reg = DVOC_SRCDIM,
67 : : .slave_addr = CH7xxx_ADDR,
68 : : .dev_ops = &ch7xxx_ops,
69 : : },
70 : : {
71 : : .type = INTEL_DVO_CHIP_TMDS,
72 : : .name = "ch7xxx",
73 : : .dvo_reg = DVOC,
74 : : .dvo_srcdim_reg = DVOC_SRCDIM,
75 : : .slave_addr = 0x75, /* For some ch7010 */
76 : : .dev_ops = &ch7xxx_ops,
77 : : },
78 : : {
79 : : .type = INTEL_DVO_CHIP_LVDS,
80 : : .name = "ivch",
81 : : .dvo_reg = DVOA,
82 : : .dvo_srcdim_reg = DVOA_SRCDIM,
83 : : .slave_addr = 0x02, /* Might also be 0x44, 0x84, 0xc4 */
84 : : .dev_ops = &ivch_ops,
85 : : },
86 : : {
87 : : .type = INTEL_DVO_CHIP_TMDS,
88 : : .name = "tfp410",
89 : : .dvo_reg = DVOC,
90 : : .dvo_srcdim_reg = DVOC_SRCDIM,
91 : : .slave_addr = TFP410_ADDR,
92 : : .dev_ops = &tfp410_ops,
93 : : },
94 : : {
95 : : .type = INTEL_DVO_CHIP_LVDS,
96 : : .name = "ch7017",
97 : : .dvo_reg = DVOC,
98 : : .dvo_srcdim_reg = DVOC_SRCDIM,
99 : : .slave_addr = 0x75,
100 : : .gpio = GMBUS_PIN_DPB,
101 : : .dev_ops = &ch7017_ops,
102 : : },
103 : : {
104 : : .type = INTEL_DVO_CHIP_TMDS,
105 : : .name = "ns2501",
106 : : .dvo_reg = DVOB,
107 : : .dvo_srcdim_reg = DVOB_SRCDIM,
108 : : .slave_addr = NS2501_ADDR,
109 : : .dev_ops = &ns2501_ops,
110 : : }
111 : : };
112 : :
113 : : struct intel_dvo {
114 : : struct intel_encoder base;
115 : :
116 : : struct intel_dvo_device dev;
117 : :
118 : : struct intel_connector *attached_connector;
119 : :
120 : : bool panel_wants_dither;
121 : : };
122 : :
123 : 0 : static struct intel_dvo *enc_to_dvo(struct intel_encoder *encoder)
124 : : {
125 : 0 : return container_of(encoder, struct intel_dvo, base);
126 : : }
127 : :
128 : 0 : static struct intel_dvo *intel_attached_dvo(struct intel_connector *connector)
129 : : {
130 : 0 : return enc_to_dvo(intel_attached_encoder(connector));
131 : : }
132 : :
133 : 0 : static bool intel_dvo_connector_get_hw_state(struct intel_connector *connector)
134 : : {
135 : 0 : struct drm_device *dev = connector->base.dev;
136 : 0 : struct drm_i915_private *dev_priv = to_i915(dev);
137 : 0 : struct intel_dvo *intel_dvo = intel_attached_dvo(connector);
138 : 0 : u32 tmp;
139 : :
140 : 0 : tmp = I915_READ(intel_dvo->dev.dvo_reg);
141 : :
142 [ # # ]: 0 : if (!(tmp & DVO_ENABLE))
143 : : return false;
144 : :
145 : 0 : return intel_dvo->dev.dev_ops->get_hw_state(&intel_dvo->dev);
146 : : }
147 : :
148 : 0 : static bool intel_dvo_get_hw_state(struct intel_encoder *encoder,
149 : : enum pipe *pipe)
150 : : {
151 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
152 : 0 : struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
153 : 0 : u32 tmp;
154 : :
155 : 0 : tmp = I915_READ(intel_dvo->dev.dvo_reg);
156 : :
157 : 0 : *pipe = (tmp & DVO_PIPE_SEL_MASK) >> DVO_PIPE_SEL_SHIFT;
158 : :
159 : 0 : return tmp & DVO_ENABLE;
160 : : }
161 : :
162 : 0 : static void intel_dvo_get_config(struct intel_encoder *encoder,
163 : : struct intel_crtc_state *pipe_config)
164 : : {
165 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
166 : 0 : struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
167 : 0 : u32 tmp, flags = 0;
168 : :
169 : 0 : pipe_config->output_types |= BIT(INTEL_OUTPUT_DVO);
170 : :
171 : 0 : tmp = I915_READ(intel_dvo->dev.dvo_reg);
172 [ # # ]: 0 : if (tmp & DVO_HSYNC_ACTIVE_HIGH)
173 : : flags |= DRM_MODE_FLAG_PHSYNC;
174 : : else
175 : 0 : flags |= DRM_MODE_FLAG_NHSYNC;
176 [ # # ]: 0 : if (tmp & DVO_VSYNC_ACTIVE_HIGH)
177 : 0 : flags |= DRM_MODE_FLAG_PVSYNC;
178 : : else
179 : 0 : flags |= DRM_MODE_FLAG_NVSYNC;
180 : :
181 : 0 : pipe_config->hw.adjusted_mode.flags |= flags;
182 : :
183 : 0 : pipe_config->hw.adjusted_mode.crtc_clock = pipe_config->port_clock;
184 : 0 : }
185 : :
186 : 0 : static void intel_disable_dvo(struct intel_encoder *encoder,
187 : : const struct intel_crtc_state *old_crtc_state,
188 : : const struct drm_connector_state *old_conn_state)
189 : : {
190 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
191 : 0 : struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
192 : 0 : i915_reg_t dvo_reg = intel_dvo->dev.dvo_reg;
193 : 0 : u32 temp = I915_READ(dvo_reg);
194 : :
195 : 0 : intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, false);
196 : 0 : I915_WRITE(dvo_reg, temp & ~DVO_ENABLE);
197 : 0 : I915_READ(dvo_reg);
198 : 0 : }
199 : :
200 : 0 : static void intel_enable_dvo(struct intel_encoder *encoder,
201 : : const struct intel_crtc_state *pipe_config,
202 : : const struct drm_connector_state *conn_state)
203 : : {
204 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
205 : 0 : struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
206 : 0 : i915_reg_t dvo_reg = intel_dvo->dev.dvo_reg;
207 : 0 : u32 temp = I915_READ(dvo_reg);
208 : :
209 : 0 : intel_dvo->dev.dev_ops->mode_set(&intel_dvo->dev,
210 : : &pipe_config->hw.mode,
211 : : &pipe_config->hw.adjusted_mode);
212 : :
213 : 0 : I915_WRITE(dvo_reg, temp | DVO_ENABLE);
214 : 0 : I915_READ(dvo_reg);
215 : :
216 : 0 : intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, true);
217 : 0 : }
218 : :
219 : : static enum drm_mode_status
220 : 0 : intel_dvo_mode_valid(struct drm_connector *connector,
221 : : struct drm_display_mode *mode)
222 : : {
223 [ # # ]: 0 : struct intel_dvo *intel_dvo = intel_attached_dvo(to_intel_connector(connector));
224 : 0 : const struct drm_display_mode *fixed_mode =
225 : 0 : to_intel_connector(connector)->panel.fixed_mode;
226 [ # # ]: 0 : int max_dotclk = to_i915(connector->dev)->max_dotclk_freq;
227 : 0 : int target_clock = mode->clock;
228 : :
229 [ # # ]: 0 : if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
230 : : return MODE_NO_DBLESCAN;
231 : :
232 : : /* XXX: Validate clock range */
233 : :
234 [ # # ]: 0 : if (fixed_mode) {
235 [ # # ]: 0 : if (mode->hdisplay > fixed_mode->hdisplay)
236 : : return MODE_PANEL;
237 [ # # ]: 0 : if (mode->vdisplay > fixed_mode->vdisplay)
238 : : return MODE_PANEL;
239 : :
240 : 0 : target_clock = fixed_mode->clock;
241 : : }
242 : :
243 [ # # ]: 0 : if (target_clock > max_dotclk)
244 : : return MODE_CLOCK_HIGH;
245 : :
246 : 0 : return intel_dvo->dev.dev_ops->mode_valid(&intel_dvo->dev, mode);
247 : : }
248 : :
249 : 0 : static int intel_dvo_compute_config(struct intel_encoder *encoder,
250 : : struct intel_crtc_state *pipe_config,
251 : : struct drm_connector_state *conn_state)
252 : : {
253 : 0 : struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
254 : 0 : const struct drm_display_mode *fixed_mode =
255 : 0 : intel_dvo->attached_connector->panel.fixed_mode;
256 : 0 : struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
257 : :
258 : : /*
259 : : * If we have timings from the BIOS for the panel, put them in
260 : : * to the adjusted mode. The CRTC will be set up for this mode,
261 : : * with the panel scaling set up to source from the H/VDisplay
262 : : * of the original mode.
263 : : */
264 [ # # ]: 0 : if (fixed_mode)
265 : 0 : intel_fixed_panel_mode(fixed_mode, adjusted_mode);
266 : :
267 [ # # ]: 0 : if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN)
268 : : return -EINVAL;
269 : :
270 : 0 : pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
271 : :
272 : 0 : return 0;
273 : : }
274 : :
275 : 0 : static void intel_dvo_pre_enable(struct intel_encoder *encoder,
276 : : const struct intel_crtc_state *pipe_config,
277 : : const struct drm_connector_state *conn_state)
278 : : {
279 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
280 : 0 : struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
281 : 0 : const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
282 : 0 : struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
283 : 0 : enum pipe pipe = crtc->pipe;
284 : 0 : u32 dvo_val;
285 : 0 : i915_reg_t dvo_reg = intel_dvo->dev.dvo_reg;
286 : 0 : i915_reg_t dvo_srcdim_reg = intel_dvo->dev.dvo_srcdim_reg;
287 : :
288 : : /* Save the data order, since I don't know what it should be set to. */
289 : 0 : dvo_val = I915_READ(dvo_reg) &
290 : : (DVO_PRESERVE_MASK | DVO_DATA_ORDER_GBRG);
291 : 0 : dvo_val |= DVO_DATA_ORDER_FP | DVO_BORDER_ENABLE |
292 : : DVO_BLANK_ACTIVE_HIGH;
293 : :
294 : 0 : dvo_val |= DVO_PIPE_SEL(pipe);
295 : 0 : dvo_val |= DVO_PIPE_STALL;
296 [ # # ]: 0 : if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
297 : 0 : dvo_val |= DVO_HSYNC_ACTIVE_HIGH;
298 [ # # ]: 0 : if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
299 : 0 : dvo_val |= DVO_VSYNC_ACTIVE_HIGH;
300 : :
301 : : /*I915_WRITE(DVOB_SRCDIM,
302 : : (adjusted_mode->crtc_hdisplay << DVO_SRCDIM_HORIZONTAL_SHIFT) |
303 : : (adjusted_mode->crtc_vdisplay << DVO_SRCDIM_VERTICAL_SHIFT));*/
304 : 0 : I915_WRITE(dvo_srcdim_reg,
305 : : (adjusted_mode->crtc_hdisplay << DVO_SRCDIM_HORIZONTAL_SHIFT) |
306 : : (adjusted_mode->crtc_vdisplay << DVO_SRCDIM_VERTICAL_SHIFT));
307 : : /*I915_WRITE(DVOB, dvo_val);*/
308 : 0 : I915_WRITE(dvo_reg, dvo_val);
309 : 0 : }
310 : :
311 : : static enum drm_connector_status
312 : 0 : intel_dvo_detect(struct drm_connector *connector, bool force)
313 : : {
314 : 0 : struct intel_dvo *intel_dvo = intel_attached_dvo(to_intel_connector(connector));
315 : 0 : DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
316 : : connector->base.id, connector->name);
317 : 0 : return intel_dvo->dev.dev_ops->detect(&intel_dvo->dev);
318 : : }
319 : :
320 : 0 : static int intel_dvo_get_modes(struct drm_connector *connector)
321 : : {
322 : 0 : struct drm_i915_private *dev_priv = to_i915(connector->dev);
323 : 0 : const struct drm_display_mode *fixed_mode =
324 : 0 : to_intel_connector(connector)->panel.fixed_mode;
325 : :
326 : : /*
327 : : * We should probably have an i2c driver get_modes function for those
328 : : * devices which will have a fixed set of modes determined by the chip
329 : : * (TV-out, for example), but for now with just TMDS and LVDS,
330 : : * that's not the case.
331 : : */
332 : 0 : intel_ddc_get_modes(connector,
333 : : intel_gmbus_get_adapter(dev_priv, GMBUS_PIN_DPC));
334 [ # # ]: 0 : if (!list_empty(&connector->probed_modes))
335 : : return 1;
336 : :
337 [ # # ]: 0 : if (fixed_mode) {
338 : 0 : struct drm_display_mode *mode;
339 : 0 : mode = drm_mode_duplicate(connector->dev, fixed_mode);
340 [ # # ]: 0 : if (mode) {
341 : 0 : drm_mode_probed_add(connector, mode);
342 : 0 : return 1;
343 : : }
344 : : }
345 : :
346 : : return 0;
347 : : }
348 : :
349 : : static const struct drm_connector_funcs intel_dvo_connector_funcs = {
350 : : .detect = intel_dvo_detect,
351 : : .late_register = intel_connector_register,
352 : : .early_unregister = intel_connector_unregister,
353 : : .destroy = intel_connector_destroy,
354 : : .fill_modes = drm_helper_probe_single_connector_modes,
355 : : .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
356 : : .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
357 : : };
358 : :
359 : : static const struct drm_connector_helper_funcs intel_dvo_connector_helper_funcs = {
360 : : .mode_valid = intel_dvo_mode_valid,
361 : : .get_modes = intel_dvo_get_modes,
362 : : };
363 : :
364 : 0 : static void intel_dvo_enc_destroy(struct drm_encoder *encoder)
365 : : {
366 : 0 : struct intel_dvo *intel_dvo = enc_to_dvo(to_intel_encoder(encoder));
367 : :
368 [ # # ]: 0 : if (intel_dvo->dev.dev_ops->destroy)
369 : 0 : intel_dvo->dev.dev_ops->destroy(&intel_dvo->dev);
370 : :
371 : 0 : intel_encoder_destroy(encoder);
372 : 0 : }
373 : :
374 : : static const struct drm_encoder_funcs intel_dvo_enc_funcs = {
375 : : .destroy = intel_dvo_enc_destroy,
376 : : };
377 : :
378 : : /*
379 : : * Attempts to get a fixed panel timing for LVDS (currently only the i830).
380 : : *
381 : : * Other chips with DVO LVDS will need to extend this to deal with the LVDS
382 : : * chip being on DVOB/C and having multiple pipes.
383 : : */
384 : : static struct drm_display_mode *
385 : 0 : intel_dvo_get_current_mode(struct intel_encoder *encoder)
386 : : {
387 : 0 : struct drm_display_mode *mode;
388 : :
389 : 0 : mode = intel_encoder_current_mode(encoder);
390 [ # # ]: 0 : if (mode) {
391 : 0 : DRM_DEBUG_KMS("using current (BIOS) mode: ");
392 : 0 : drm_mode_debug_printmodeline(mode);
393 : 0 : mode->type |= DRM_MODE_TYPE_PREFERRED;
394 : : }
395 : :
396 : 0 : return mode;
397 : : }
398 : :
399 : 0 : static enum port intel_dvo_port(i915_reg_t dvo_reg)
400 : : {
401 : 0 : if (i915_mmio_reg_equal(dvo_reg, DVOA))
402 : : return PORT_A;
403 [ # # ]: 0 : else if (i915_mmio_reg_equal(dvo_reg, DVOB))
404 : : return PORT_B;
405 : : else
406 : 0 : return PORT_C;
407 : : }
408 : :
409 : 0 : void intel_dvo_init(struct drm_i915_private *dev_priv)
410 : : {
411 : 0 : struct intel_encoder *intel_encoder;
412 : 0 : struct intel_dvo *intel_dvo;
413 : 0 : struct intel_connector *intel_connector;
414 : 0 : int i;
415 : 0 : int encoder_type = DRM_MODE_ENCODER_NONE;
416 : :
417 : 0 : intel_dvo = kzalloc(sizeof(*intel_dvo), GFP_KERNEL);
418 [ # # ]: 0 : if (!intel_dvo)
419 : : return;
420 : :
421 : 0 : intel_connector = intel_connector_alloc();
422 [ # # ]: 0 : if (!intel_connector) {
423 : 0 : kfree(intel_dvo);
424 : 0 : return;
425 : : }
426 : :
427 : 0 : intel_dvo->attached_connector = intel_connector;
428 : :
429 : 0 : intel_encoder = &intel_dvo->base;
430 : :
431 : 0 : intel_encoder->disable = intel_disable_dvo;
432 : 0 : intel_encoder->enable = intel_enable_dvo;
433 : 0 : intel_encoder->get_hw_state = intel_dvo_get_hw_state;
434 : 0 : intel_encoder->get_config = intel_dvo_get_config;
435 : 0 : intel_encoder->compute_config = intel_dvo_compute_config;
436 : 0 : intel_encoder->pre_enable = intel_dvo_pre_enable;
437 : 0 : intel_connector->get_hw_state = intel_dvo_connector_get_hw_state;
438 : :
439 : : /* Now, try to find a controller */
440 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(intel_dvo_devices); i++) {
441 : 0 : struct drm_connector *connector = &intel_connector->base;
442 : 0 : const struct intel_dvo_device *dvo = &intel_dvo_devices[i];
443 : 0 : struct i2c_adapter *i2c;
444 : 0 : int gpio;
445 : 0 : bool dvoinit;
446 : 0 : enum pipe pipe;
447 : 0 : u32 dpll[I915_MAX_PIPES];
448 : 0 : enum port port;
449 : :
450 : : /*
451 : : * Allow the I2C driver info to specify the GPIO to be used in
452 : : * special cases, but otherwise default to what's defined
453 : : * in the spec.
454 : : */
455 [ # # ]: 0 : if (intel_gmbus_is_valid_pin(dev_priv, dvo->gpio))
456 : 0 : gpio = dvo->gpio;
457 [ # # ]: 0 : else if (dvo->type == INTEL_DVO_CHIP_LVDS)
458 : : gpio = GMBUS_PIN_SSC;
459 : : else
460 : 0 : gpio = GMBUS_PIN_DPB;
461 : :
462 : : /*
463 : : * Set up the I2C bus necessary for the chip we're probing.
464 : : * It appears that everything is on GPIOE except for panels
465 : : * on i830 laptops, which are on GPIOB (DVOA).
466 : : */
467 : 0 : i2c = intel_gmbus_get_adapter(dev_priv, gpio);
468 : :
469 : 0 : intel_dvo->dev = *dvo;
470 : :
471 : : /*
472 : : * GMBUS NAK handling seems to be unstable, hence let the
473 : : * transmitter detection run in bit banging mode for now.
474 : : */
475 : 0 : intel_gmbus_force_bit(i2c, true);
476 : :
477 : : /*
478 : : * ns2501 requires the DVO 2x clock before it will
479 : : * respond to i2c accesses, so make sure we have
480 : : * have the clock enabled before we attempt to
481 : : * initialize the device.
482 : : */
483 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
484 : 0 : dpll[pipe] = I915_READ(DPLL(pipe));
485 : 0 : I915_WRITE(DPLL(pipe), dpll[pipe] | DPLL_DVO_2X_MODE);
486 : : }
487 : :
488 : 0 : dvoinit = dvo->dev_ops->init(&intel_dvo->dev, i2c);
489 : :
490 : : /* restore the DVO 2x clock state to original */
491 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
492 : 0 : I915_WRITE(DPLL(pipe), dpll[pipe]);
493 : : }
494 : :
495 : 0 : intel_gmbus_force_bit(i2c, false);
496 : :
497 [ # # ]: 0 : if (!dvoinit)
498 : 0 : continue;
499 : :
500 [ # # ]: 0 : port = intel_dvo_port(dvo->dvo_reg);
501 : 0 : drm_encoder_init(&dev_priv->drm, &intel_encoder->base,
502 : : &intel_dvo_enc_funcs, encoder_type,
503 : : "DVO %c", port_name(port));
504 : :
505 : 0 : intel_encoder->type = INTEL_OUTPUT_DVO;
506 : 0 : intel_encoder->power_domain = POWER_DOMAIN_PORT_OTHER;
507 : 0 : intel_encoder->port = port;
508 : 0 : intel_encoder->pipe_mask = ~0;
509 : :
510 [ # # # ]: 0 : switch (dvo->type) {
511 : 0 : case INTEL_DVO_CHIP_TMDS:
512 : 0 : intel_encoder->cloneable = (1 << INTEL_OUTPUT_ANALOG) |
513 : : (1 << INTEL_OUTPUT_DVO);
514 : 0 : drm_connector_init(&dev_priv->drm, connector,
515 : : &intel_dvo_connector_funcs,
516 : : DRM_MODE_CONNECTOR_DVII);
517 : 0 : encoder_type = DRM_MODE_ENCODER_TMDS;
518 : 0 : break;
519 : 0 : case INTEL_DVO_CHIP_LVDS:
520 : 0 : intel_encoder->cloneable = 0;
521 : 0 : drm_connector_init(&dev_priv->drm, connector,
522 : : &intel_dvo_connector_funcs,
523 : : DRM_MODE_CONNECTOR_LVDS);
524 : 0 : encoder_type = DRM_MODE_ENCODER_LVDS;
525 : 0 : break;
526 : : }
527 : :
528 : 0 : drm_connector_helper_add(connector,
529 : : &intel_dvo_connector_helper_funcs);
530 : 0 : connector->display_info.subpixel_order = SubPixelHorizontalRGB;
531 : 0 : connector->interlace_allowed = false;
532 : 0 : connector->doublescan_allowed = false;
533 : :
534 : 0 : intel_connector_attach_encoder(intel_connector, intel_encoder);
535 [ # # ]: 0 : if (dvo->type == INTEL_DVO_CHIP_LVDS) {
536 : : /*
537 : : * For our LVDS chipsets, we should hopefully be able
538 : : * to dig the fixed panel mode out of the BIOS data.
539 : : * However, it's in a different format from the BIOS
540 : : * data on chipsets with integrated LVDS (stored in AIM
541 : : * headers, likely), so for now, just get the current
542 : : * mode being output through DVO.
543 : : */
544 : 0 : intel_panel_init(&intel_connector->panel,
545 : : intel_dvo_get_current_mode(intel_encoder),
546 : : NULL);
547 : 0 : intel_dvo->panel_wants_dither = true;
548 : : }
549 : :
550 : 0 : return;
551 : : }
552 : :
553 : 0 : kfree(intel_dvo);
554 : 0 : kfree(intel_connector);
555 : : }
|
