2 * Copyright © 2006-2007 Intel Corporation
3 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
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 * Dave Airlie <airlied@linux.ie>
27 * Jesse Barnes <jesse.barnes@intel.com>
30 #include <linux/dmi.h>
31 #include <linux/i2c.h>
36 #include "intel_drv.h"
41 * Sets the backlight level.
43 * \param level backlight level, from 0 to intel_lvds_get_max_backlight().
45 static void intel_lvds_set_backlight(struct drm_device
*dev
, int level
)
47 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
50 blc_pwm_ctl
= I915_READ(BLC_PWM_CTL
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
51 I915_WRITE(BLC_PWM_CTL
, (blc_pwm_ctl
|
52 (level
<< BACKLIGHT_DUTY_CYCLE_SHIFT
)));
56 * Returns the maximum level of the backlight duty cycle field.
58 static u32
intel_lvds_get_max_backlight(struct drm_device
*dev
)
60 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
62 return ((I915_READ(BLC_PWM_CTL
) & BACKLIGHT_MODULATION_FREQ_MASK
) >>
63 BACKLIGHT_MODULATION_FREQ_SHIFT
) * 2;
67 * Sets the power state for the panel.
69 static void intel_lvds_set_power(struct drm_device
*dev
, bool on
)
71 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
75 I915_WRITE(PP_CONTROL
, I915_READ(PP_CONTROL
) |
78 pp_status
= I915_READ(PP_STATUS
);
79 } while ((pp_status
& PP_ON
) == 0);
81 intel_lvds_set_backlight(dev
, dev_priv
->backlight_duty_cycle
);
83 intel_lvds_set_backlight(dev
, 0);
85 I915_WRITE(PP_CONTROL
, I915_READ(PP_CONTROL
) &
88 pp_status
= I915_READ(PP_STATUS
);
89 } while (pp_status
& PP_ON
);
93 static void intel_lvds_dpms(struct drm_encoder
*encoder
, int mode
)
95 struct drm_device
*dev
= encoder
->dev
;
97 if (mode
== DRM_MODE_DPMS_ON
)
98 intel_lvds_set_power(dev
, true);
100 intel_lvds_set_power(dev
, false);
102 /* XXX: We never power down the LVDS pairs. */
105 static void intel_lvds_save(struct drm_connector
*connector
)
107 struct drm_device
*dev
= connector
->dev
;
108 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
110 dev_priv
->savePP_ON
= I915_READ(PP_ON_DELAYS
);
111 dev_priv
->savePP_OFF
= I915_READ(PP_OFF_DELAYS
);
112 dev_priv
->savePP_CONTROL
= I915_READ(PP_CONTROL
);
113 dev_priv
->savePP_DIVISOR
= I915_READ(PP_DIVISOR
);
114 dev_priv
->saveBLC_PWM_CTL
= I915_READ(BLC_PWM_CTL
);
115 dev_priv
->backlight_duty_cycle
= (dev_priv
->saveBLC_PWM_CTL
&
116 BACKLIGHT_DUTY_CYCLE_MASK
);
119 * If the light is off at server startup, just make it full brightness
121 if (dev_priv
->backlight_duty_cycle
== 0)
122 dev_priv
->backlight_duty_cycle
=
123 intel_lvds_get_max_backlight(dev
);
126 static void intel_lvds_restore(struct drm_connector
*connector
)
128 struct drm_device
*dev
= connector
->dev
;
129 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
131 I915_WRITE(BLC_PWM_CTL
, dev_priv
->saveBLC_PWM_CTL
);
132 I915_WRITE(PP_ON_DELAYS
, dev_priv
->savePP_ON
);
133 I915_WRITE(PP_OFF_DELAYS
, dev_priv
->savePP_OFF
);
134 I915_WRITE(PP_DIVISOR
, dev_priv
->savePP_DIVISOR
);
135 I915_WRITE(PP_CONTROL
, dev_priv
->savePP_CONTROL
);
136 if (dev_priv
->savePP_CONTROL
& POWER_TARGET_ON
)
137 intel_lvds_set_power(dev
, true);
139 intel_lvds_set_power(dev
, false);
142 static int intel_lvds_mode_valid(struct drm_connector
*connector
,
143 struct drm_display_mode
*mode
)
145 struct drm_device
*dev
= connector
->dev
;
146 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
147 struct drm_display_mode
*fixed_mode
= dev_priv
->panel_fixed_mode
;
150 if (mode
->hdisplay
> fixed_mode
->hdisplay
)
152 if (mode
->vdisplay
> fixed_mode
->vdisplay
)
159 static bool intel_lvds_mode_fixup(struct drm_encoder
*encoder
,
160 struct drm_display_mode
*mode
,
161 struct drm_display_mode
*adjusted_mode
)
163 struct drm_device
*dev
= encoder
->dev
;
164 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
165 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
166 struct drm_encoder
*tmp_encoder
;
168 /* Should never happen!! */
169 if (!IS_I965G(dev
) && intel_crtc
->pipe
== 0) {
170 printk(KERN_ERR
"Can't support LVDS on pipe A\n");
174 /* Should never happen!! */
175 list_for_each_entry(tmp_encoder
, &dev
->mode_config
.encoder_list
, head
) {
176 if (tmp_encoder
!= encoder
&& tmp_encoder
->crtc
== encoder
->crtc
) {
177 printk(KERN_ERR
"Can't enable LVDS and another "
178 "encoder on the same pipe\n");
184 * If we have timings from the BIOS for the panel, put them in
185 * to the adjusted mode. The CRTC will be set up for this mode,
186 * with the panel scaling set up to source from the H/VDisplay
187 * of the original mode.
189 if (dev_priv
->panel_fixed_mode
!= NULL
) {
190 adjusted_mode
->hdisplay
= dev_priv
->panel_fixed_mode
->hdisplay
;
191 adjusted_mode
->hsync_start
=
192 dev_priv
->panel_fixed_mode
->hsync_start
;
193 adjusted_mode
->hsync_end
=
194 dev_priv
->panel_fixed_mode
->hsync_end
;
195 adjusted_mode
->htotal
= dev_priv
->panel_fixed_mode
->htotal
;
196 adjusted_mode
->vdisplay
= dev_priv
->panel_fixed_mode
->vdisplay
;
197 adjusted_mode
->vsync_start
=
198 dev_priv
->panel_fixed_mode
->vsync_start
;
199 adjusted_mode
->vsync_end
=
200 dev_priv
->panel_fixed_mode
->vsync_end
;
201 adjusted_mode
->vtotal
= dev_priv
->panel_fixed_mode
->vtotal
;
202 adjusted_mode
->clock
= dev_priv
->panel_fixed_mode
->clock
;
203 drm_mode_set_crtcinfo(adjusted_mode
, CRTC_INTERLACE_HALVE_V
);
207 * XXX: It would be nice to support lower refresh rates on the
208 * panels to reduce power consumption, and perhaps match the
209 * user's requested refresh rate.
215 static void intel_lvds_prepare(struct drm_encoder
*encoder
)
217 struct drm_device
*dev
= encoder
->dev
;
218 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
220 dev_priv
->saveBLC_PWM_CTL
= I915_READ(BLC_PWM_CTL
);
221 dev_priv
->backlight_duty_cycle
= (dev_priv
->saveBLC_PWM_CTL
&
222 BACKLIGHT_DUTY_CYCLE_MASK
);
224 intel_lvds_set_power(dev
, false);
227 static void intel_lvds_commit( struct drm_encoder
*encoder
)
229 struct drm_device
*dev
= encoder
->dev
;
230 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
232 if (dev_priv
->backlight_duty_cycle
== 0)
233 dev_priv
->backlight_duty_cycle
=
234 intel_lvds_get_max_backlight(dev
);
236 intel_lvds_set_power(dev
, true);
239 static void intel_lvds_mode_set(struct drm_encoder
*encoder
,
240 struct drm_display_mode
*mode
,
241 struct drm_display_mode
*adjusted_mode
)
243 struct drm_device
*dev
= encoder
->dev
;
244 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
245 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
249 * The LVDS pin pair will already have been turned on in the
250 * intel_crtc_mode_set since it has a large impact on the DPLL
255 * Enable automatic panel scaling so that non-native modes fill the
256 * screen. Should be enabled before the pipe is enabled, according to
257 * register description and PRM.
259 if (mode
->hdisplay
!= adjusted_mode
->hdisplay
||
260 mode
->vdisplay
!= adjusted_mode
->vdisplay
)
261 pfit_control
= (PFIT_ENABLE
| VERT_AUTO_SCALE
|
262 HORIZ_AUTO_SCALE
| VERT_INTERP_BILINEAR
|
263 HORIZ_INTERP_BILINEAR
);
267 if (!IS_I965G(dev
)) {
268 if (dev_priv
->panel_wants_dither
|| dev_priv
->lvds_dither
)
269 pfit_control
|= PANEL_8TO6_DITHER_ENABLE
;
272 pfit_control
|= intel_crtc
->pipe
<< PFIT_PIPE_SHIFT
;
274 I915_WRITE(PFIT_CONTROL
, pfit_control
);
278 * Detect the LVDS connection.
280 * This always returns CONNECTOR_STATUS_CONNECTED. This connector should only have
281 * been set up if the LVDS was actually connected anyway.
283 static enum drm_connector_status
intel_lvds_detect(struct drm_connector
*connector
)
285 return connector_status_connected
;
289 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
291 static int intel_lvds_get_modes(struct drm_connector
*connector
)
293 struct drm_device
*dev
= connector
->dev
;
294 struct intel_output
*intel_output
= to_intel_output(connector
);
295 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
298 ret
= intel_ddc_get_modes(intel_output
);
303 /* Didn't get an EDID, so
304 * Set wide sync ranges so we get all modes
305 * handed to valid_mode for checking
307 connector
->display_info
.min_vfreq
= 0;
308 connector
->display_info
.max_vfreq
= 200;
309 connector
->display_info
.min_hfreq
= 0;
310 connector
->display_info
.max_hfreq
= 200;
312 if (dev_priv
->panel_fixed_mode
!= NULL
) {
313 struct drm_display_mode
*mode
;
315 mode
= drm_mode_duplicate(dev
, dev_priv
->panel_fixed_mode
);
316 drm_mode_probed_add(connector
, mode
);
325 * intel_lvds_destroy - unregister and free LVDS structures
326 * @connector: connector to free
328 * Unregister the DDC bus for this connector then free the driver private
331 static void intel_lvds_destroy(struct drm_connector
*connector
)
333 struct intel_output
*intel_output
= to_intel_output(connector
);
335 if (intel_output
->ddc_bus
)
336 intel_i2c_destroy(intel_output
->ddc_bus
);
337 drm_sysfs_connector_remove(connector
);
338 drm_connector_cleanup(connector
);
342 static int intel_lvds_set_property(struct drm_connector
*connector
,
343 struct drm_property
*property
,
349 static const struct drm_encoder_helper_funcs intel_lvds_helper_funcs
= {
350 .dpms
= intel_lvds_dpms
,
351 .mode_fixup
= intel_lvds_mode_fixup
,
352 .prepare
= intel_lvds_prepare
,
353 .mode_set
= intel_lvds_mode_set
,
354 .commit
= intel_lvds_commit
,
357 static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs
= {
358 .get_modes
= intel_lvds_get_modes
,
359 .mode_valid
= intel_lvds_mode_valid
,
360 .best_encoder
= intel_best_encoder
,
363 static const struct drm_connector_funcs intel_lvds_connector_funcs
= {
364 .dpms
= drm_helper_connector_dpms
,
365 .save
= intel_lvds_save
,
366 .restore
= intel_lvds_restore
,
367 .detect
= intel_lvds_detect
,
368 .fill_modes
= drm_helper_probe_single_connector_modes
,
369 .set_property
= intel_lvds_set_property
,
370 .destroy
= intel_lvds_destroy
,
374 static void intel_lvds_enc_destroy(struct drm_encoder
*encoder
)
376 drm_encoder_cleanup(encoder
);
379 static const struct drm_encoder_funcs intel_lvds_enc_funcs
= {
380 .destroy
= intel_lvds_enc_destroy
,
383 static int __init
intel_no_lvds_dmi_callback(const struct dmi_system_id
*id
)
385 DRM_DEBUG("Skipping LVDS initialization for %s\n", id
->ident
);
389 /* These systems claim to have LVDS, but really don't */
390 static const struct dmi_system_id intel_no_lvds
[] = {
392 .callback
= intel_no_lvds_dmi_callback
,
393 .ident
= "Apple Mac Mini (Core series)",
395 DMI_MATCH(DMI_SYS_VENDOR
, "Apple Inc."),
396 DMI_MATCH(DMI_PRODUCT_NAME
, "Macmini1,1"),
400 .callback
= intel_no_lvds_dmi_callback
,
401 .ident
= "Apple Mac Mini (Core 2 series)",
403 DMI_MATCH(DMI_SYS_VENDOR
, "Apple Inc."),
404 DMI_MATCH(DMI_PRODUCT_NAME
, "Macmini2,1"),
408 .callback
= intel_no_lvds_dmi_callback
,
409 .ident
= "MSI IM-945GSE-A",
411 DMI_MATCH(DMI_SYS_VENDOR
, "MSI"),
412 DMI_MATCH(DMI_PRODUCT_NAME
, "A9830IMS"),
416 .callback
= intel_no_lvds_dmi_callback
,
417 .ident
= "Dell Studio Hybrid",
419 DMI_MATCH(DMI_SYS_VENDOR
, "Dell Inc."),
420 DMI_MATCH(DMI_PRODUCT_NAME
, "Studio Hybrid 140g"),
424 /* FIXME: add a check for the Aopen Mini PC */
426 { } /* terminating entry */
430 * intel_lvds_init - setup LVDS connectors on this device
433 * Create the connector, register the LVDS DDC bus, and try to figure out what
434 * modes we can display on the LVDS panel (if present).
436 void intel_lvds_init(struct drm_device
*dev
)
438 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
439 struct intel_output
*intel_output
;
440 struct drm_connector
*connector
;
441 struct drm_encoder
*encoder
;
442 struct drm_display_mode
*scan
; /* *modes, *bios_mode; */
443 struct drm_crtc
*crtc
;
447 /* Skip init on machines we know falsely report LVDS */
448 if (dmi_check_system(intel_no_lvds
))
451 intel_output
= kzalloc(sizeof(struct intel_output
), GFP_KERNEL
);
456 connector
= &intel_output
->base
;
457 encoder
= &intel_output
->enc
;
458 drm_connector_init(dev
, &intel_output
->base
, &intel_lvds_connector_funcs
,
459 DRM_MODE_CONNECTOR_LVDS
);
461 drm_encoder_init(dev
, &intel_output
->enc
, &intel_lvds_enc_funcs
,
462 DRM_MODE_ENCODER_LVDS
);
464 drm_mode_connector_attach_encoder(&intel_output
->base
, &intel_output
->enc
);
465 intel_output
->type
= INTEL_OUTPUT_LVDS
;
467 drm_encoder_helper_add(encoder
, &intel_lvds_helper_funcs
);
468 drm_connector_helper_add(connector
, &intel_lvds_connector_helper_funcs
);
469 connector
->display_info
.subpixel_order
= SubPixelHorizontalRGB
;
470 connector
->interlace_allowed
= false;
471 connector
->doublescan_allowed
= false;
476 * 1) check for EDID on DDC
477 * 2) check for VBT data
478 * 3) check to see if LVDS is already on
479 * if none of the above, no panel
480 * 4) make sure lid is open
481 * if closed, act like it's not there for now
484 /* Set up the DDC bus. */
485 intel_output
->ddc_bus
= intel_i2c_create(dev
, GPIOC
, "LVDSDDC_C");
486 if (!intel_output
->ddc_bus
) {
487 dev_printk(KERN_ERR
, &dev
->pdev
->dev
, "DDC bus registration "
493 * Attempt to get the fixed panel mode from DDC. Assume that the
494 * preferred mode is the right one.
496 intel_ddc_get_modes(intel_output
);
498 list_for_each_entry(scan
, &connector
->probed_modes
, head
) {
499 mutex_lock(&dev
->mode_config
.mutex
);
500 if (scan
->type
& DRM_MODE_TYPE_PREFERRED
) {
501 dev_priv
->panel_fixed_mode
=
502 drm_mode_duplicate(dev
, scan
);
503 mutex_unlock(&dev
->mode_config
.mutex
);
506 mutex_unlock(&dev
->mode_config
.mutex
);
509 /* Failed to get EDID, what about VBT? */
510 if (dev_priv
->lfp_lvds_vbt_mode
) {
511 mutex_lock(&dev
->mode_config
.mutex
);
512 dev_priv
->panel_fixed_mode
=
513 drm_mode_duplicate(dev
, dev_priv
->lfp_lvds_vbt_mode
);
514 mutex_unlock(&dev
->mode_config
.mutex
);
515 if (dev_priv
->panel_fixed_mode
) {
516 dev_priv
->panel_fixed_mode
->type
|=
517 DRM_MODE_TYPE_PREFERRED
;
523 * If we didn't get EDID, try checking if the panel is already turned
524 * on. If so, assume that whatever is currently programmed is the
527 lvds
= I915_READ(LVDS
);
528 pipe
= (lvds
& LVDS_PIPEB_SELECT
) ? 1 : 0;
529 crtc
= intel_get_crtc_from_pipe(dev
, pipe
);
531 if (crtc
&& (lvds
& LVDS_PORT_EN
)) {
532 dev_priv
->panel_fixed_mode
= intel_crtc_mode_get(dev
, crtc
);
533 if (dev_priv
->panel_fixed_mode
) {
534 dev_priv
->panel_fixed_mode
->type
|=
535 DRM_MODE_TYPE_PREFERRED
;
540 /* If we still don't have a mode after all that, give up. */
541 if (!dev_priv
->panel_fixed_mode
)
545 drm_sysfs_connector_add(connector
);
549 DRM_DEBUG("No LVDS modes found, disabling.\n");
550 if (intel_output
->ddc_bus
)
551 intel_i2c_destroy(intel_output
->ddc_bus
);
552 drm_connector_cleanup(connector
);