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/i2c.h>
35 #include "intel_drv.h"
40 * Sets the backlight level.
42 * \param level backlight level, from 0 to intel_lvds_get_max_backlight().
44 static void intel_lvds_set_backlight(struct drm_device
*dev
, int level
)
46 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
49 blc_pwm_ctl
= I915_READ(BLC_PWM_CTL
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
50 I915_WRITE(BLC_PWM_CTL
, (blc_pwm_ctl
|
51 (level
<< BACKLIGHT_DUTY_CYCLE_SHIFT
)));
55 * Returns the maximum level of the backlight duty cycle field.
57 static u32
intel_lvds_get_max_backlight(struct drm_device
*dev
)
59 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
61 return ((I915_READ(BLC_PWM_CTL
) & BACKLIGHT_MODULATION_FREQ_MASK
) >>
62 BACKLIGHT_MODULATION_FREQ_SHIFT
) * 2;
66 * Sets the power state for the panel.
68 static void intel_lvds_set_power(struct drm_device
*dev
, bool on
)
70 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
74 I915_WRITE(PP_CONTROL
, I915_READ(PP_CONTROL
) |
77 pp_status
= I915_READ(PP_STATUS
);
78 } while ((pp_status
& PP_ON
) == 0);
80 intel_lvds_set_backlight(dev
, dev_priv
->backlight_duty_cycle
);
82 intel_lvds_set_backlight(dev
, 0);
84 I915_WRITE(PP_CONTROL
, I915_READ(PP_CONTROL
) &
87 pp_status
= I915_READ(PP_STATUS
);
88 } while (pp_status
& PP_ON
);
92 static void intel_lvds_dpms(struct drm_encoder
*encoder
, int mode
)
94 struct drm_device
*dev
= encoder
->dev
;
96 if (mode
== DRM_MODE_DPMS_ON
)
97 intel_lvds_set_power(dev
, true);
99 intel_lvds_set_power(dev
, false);
101 /* XXX: We never power down the LVDS pairs. */
104 static void intel_lvds_save(struct drm_connector
*connector
)
106 struct drm_device
*dev
= connector
->dev
;
107 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
109 dev_priv
->savePP_ON
= I915_READ(PP_ON_DELAYS
);
110 dev_priv
->savePP_OFF
= I915_READ(PP_OFF_DELAYS
);
111 dev_priv
->savePP_CONTROL
= I915_READ(PP_CONTROL
);
112 dev_priv
->savePP_DIVISOR
= I915_READ(PP_DIVISOR
);
113 dev_priv
->saveBLC_PWM_CTL
= I915_READ(BLC_PWM_CTL
);
114 dev_priv
->backlight_duty_cycle
= (dev_priv
->saveBLC_PWM_CTL
&
115 BACKLIGHT_DUTY_CYCLE_MASK
);
118 * If the light is off at server startup, just make it full brightness
120 if (dev_priv
->backlight_duty_cycle
== 0)
121 dev_priv
->backlight_duty_cycle
=
122 intel_lvds_get_max_backlight(dev
);
125 static void intel_lvds_restore(struct drm_connector
*connector
)
127 struct drm_device
*dev
= connector
->dev
;
128 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
130 I915_WRITE(BLC_PWM_CTL
, dev_priv
->saveBLC_PWM_CTL
);
131 I915_WRITE(PP_ON_DELAYS
, dev_priv
->savePP_ON
);
132 I915_WRITE(PP_OFF_DELAYS
, dev_priv
->savePP_OFF
);
133 I915_WRITE(PP_DIVISOR
, dev_priv
->savePP_DIVISOR
);
134 I915_WRITE(PP_CONTROL
, dev_priv
->savePP_CONTROL
);
135 if (dev_priv
->savePP_CONTROL
& POWER_TARGET_ON
)
136 intel_lvds_set_power(dev
, true);
138 intel_lvds_set_power(dev
, false);
141 static int intel_lvds_mode_valid(struct drm_connector
*connector
,
142 struct drm_display_mode
*mode
)
144 struct drm_device
*dev
= connector
->dev
;
145 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
146 struct drm_display_mode
*fixed_mode
= dev_priv
->panel_fixed_mode
;
149 if (mode
->hdisplay
> fixed_mode
->hdisplay
)
151 if (mode
->vdisplay
> fixed_mode
->vdisplay
)
158 static bool intel_lvds_mode_fixup(struct drm_encoder
*encoder
,
159 struct drm_display_mode
*mode
,
160 struct drm_display_mode
*adjusted_mode
)
162 struct drm_device
*dev
= encoder
->dev
;
163 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
164 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
165 struct drm_encoder
*tmp_encoder
;
167 /* Should never happen!! */
168 if (!IS_I965G(dev
) && intel_crtc
->pipe
== 0) {
169 printk(KERN_ERR
"Can't support LVDS on pipe A\n");
173 /* Should never happen!! */
174 list_for_each_entry(tmp_encoder
, &dev
->mode_config
.encoder_list
, head
) {
175 if (tmp_encoder
!= encoder
&& tmp_encoder
->crtc
== encoder
->crtc
) {
176 printk(KERN_ERR
"Can't enable LVDS and another "
177 "encoder on the same pipe\n");
183 * If we have timings from the BIOS for the panel, put them in
184 * to the adjusted mode. The CRTC will be set up for this mode,
185 * with the panel scaling set up to source from the H/VDisplay
186 * of the original mode.
188 if (dev_priv
->panel_fixed_mode
!= NULL
) {
189 adjusted_mode
->hdisplay
= dev_priv
->panel_fixed_mode
->hdisplay
;
190 adjusted_mode
->hsync_start
=
191 dev_priv
->panel_fixed_mode
->hsync_start
;
192 adjusted_mode
->hsync_end
=
193 dev_priv
->panel_fixed_mode
->hsync_end
;
194 adjusted_mode
->htotal
= dev_priv
->panel_fixed_mode
->htotal
;
195 adjusted_mode
->vdisplay
= dev_priv
->panel_fixed_mode
->vdisplay
;
196 adjusted_mode
->vsync_start
=
197 dev_priv
->panel_fixed_mode
->vsync_start
;
198 adjusted_mode
->vsync_end
=
199 dev_priv
->panel_fixed_mode
->vsync_end
;
200 adjusted_mode
->vtotal
= dev_priv
->panel_fixed_mode
->vtotal
;
201 adjusted_mode
->clock
= dev_priv
->panel_fixed_mode
->clock
;
202 drm_mode_set_crtcinfo(adjusted_mode
, CRTC_INTERLACE_HALVE_V
);
206 * XXX: It would be nice to support lower refresh rates on the
207 * panels to reduce power consumption, and perhaps match the
208 * user's requested refresh rate.
214 static void intel_lvds_prepare(struct drm_encoder
*encoder
)
216 struct drm_device
*dev
= encoder
->dev
;
217 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
219 dev_priv
->saveBLC_PWM_CTL
= I915_READ(BLC_PWM_CTL
);
220 dev_priv
->backlight_duty_cycle
= (dev_priv
->saveBLC_PWM_CTL
&
221 BACKLIGHT_DUTY_CYCLE_MASK
);
223 intel_lvds_set_power(dev
, false);
226 static void intel_lvds_commit( struct drm_encoder
*encoder
)
228 struct drm_device
*dev
= encoder
->dev
;
229 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
231 if (dev_priv
->backlight_duty_cycle
== 0)
232 dev_priv
->backlight_duty_cycle
=
233 intel_lvds_get_max_backlight(dev
);
235 intel_lvds_set_power(dev
, true);
238 static void intel_lvds_mode_set(struct drm_encoder
*encoder
,
239 struct drm_display_mode
*mode
,
240 struct drm_display_mode
*adjusted_mode
)
242 struct drm_device
*dev
= encoder
->dev
;
243 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
244 struct intel_crtc
*intel_crtc
= to_intel_crtc(encoder
->crtc
);
248 * The LVDS pin pair will already have been turned on in the
249 * intel_crtc_mode_set since it has a large impact on the DPLL
254 * Enable automatic panel scaling so that non-native modes fill the
255 * screen. Should be enabled before the pipe is enabled, according to
256 * register description and PRM.
258 if (mode
->hdisplay
!= adjusted_mode
->hdisplay
||
259 mode
->vdisplay
!= adjusted_mode
->vdisplay
)
260 pfit_control
= (PFIT_ENABLE
| VERT_AUTO_SCALE
|
261 HORIZ_AUTO_SCALE
| VERT_INTERP_BILINEAR
|
262 HORIZ_INTERP_BILINEAR
);
266 if (!IS_I965G(dev
)) {
267 if (dev_priv
->panel_wants_dither
)
268 pfit_control
|= PANEL_8TO6_DITHER_ENABLE
;
271 pfit_control
|= intel_crtc
->pipe
<< PFIT_PIPE_SHIFT
;
273 I915_WRITE(PFIT_CONTROL
, pfit_control
);
277 * Detect the LVDS connection.
279 * This always returns CONNECTOR_STATUS_CONNECTED. This connector should only have
280 * been set up if the LVDS was actually connected anyway.
282 static enum drm_connector_status
intel_lvds_detect(struct drm_connector
*connector
)
284 return connector_status_connected
;
288 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
290 static int intel_lvds_get_modes(struct drm_connector
*connector
)
292 struct drm_device
*dev
= connector
->dev
;
293 struct intel_output
*intel_output
= to_intel_output(connector
);
294 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
297 ret
= intel_ddc_get_modes(intel_output
);
302 /* Didn't get an EDID, so
303 * Set wide sync ranges so we get all modes
304 * handed to valid_mode for checking
306 connector
->display_info
.min_vfreq
= 0;
307 connector
->display_info
.max_vfreq
= 200;
308 connector
->display_info
.min_hfreq
= 0;
309 connector
->display_info
.max_hfreq
= 200;
311 if (dev_priv
->panel_fixed_mode
!= NULL
) {
312 struct drm_display_mode
*mode
;
314 mutex_lock(&dev
->mode_config
.mutex
);
315 mode
= drm_mode_duplicate(dev
, dev_priv
->panel_fixed_mode
);
316 drm_mode_probed_add(connector
, mode
);
317 mutex_unlock(&dev
->mode_config
.mutex
);
326 * intel_lvds_destroy - unregister and free LVDS structures
327 * @connector: connector to free
329 * Unregister the DDC bus for this connector then free the driver private
332 static void intel_lvds_destroy(struct drm_connector
*connector
)
334 struct intel_output
*intel_output
= to_intel_output(connector
);
336 if (intel_output
->ddc_bus
)
337 intel_i2c_destroy(intel_output
->ddc_bus
);
338 drm_sysfs_connector_remove(connector
);
339 drm_connector_cleanup(connector
);
343 static int intel_lvds_set_property(struct drm_connector
*connector
,
344 struct drm_property
*property
,
347 struct drm_device
*dev
= connector
->dev
;
349 if (property
== dev
->mode_config
.dpms_property
&& connector
->encoder
)
350 intel_lvds_dpms(connector
->encoder
, (uint32_t)(value
& 0xf));
355 static const struct drm_encoder_helper_funcs intel_lvds_helper_funcs
= {
356 .dpms
= intel_lvds_dpms
,
357 .mode_fixup
= intel_lvds_mode_fixup
,
358 .prepare
= intel_lvds_prepare
,
359 .mode_set
= intel_lvds_mode_set
,
360 .commit
= intel_lvds_commit
,
363 static const struct drm_connector_helper_funcs intel_lvds_connector_helper_funcs
= {
364 .get_modes
= intel_lvds_get_modes
,
365 .mode_valid
= intel_lvds_mode_valid
,
366 .best_encoder
= intel_best_encoder
,
369 static const struct drm_connector_funcs intel_lvds_connector_funcs
= {
370 .save
= intel_lvds_save
,
371 .restore
= intel_lvds_restore
,
372 .detect
= intel_lvds_detect
,
373 .fill_modes
= drm_helper_probe_single_connector_modes
,
374 .set_property
= intel_lvds_set_property
,
375 .destroy
= intel_lvds_destroy
,
379 static void intel_lvds_enc_destroy(struct drm_encoder
*encoder
)
381 drm_encoder_cleanup(encoder
);
384 static const struct drm_encoder_funcs intel_lvds_enc_funcs
= {
385 .destroy
= intel_lvds_enc_destroy
,
391 * intel_lvds_init - setup LVDS connectors on this device
394 * Create the connector, register the LVDS DDC bus, and try to figure out what
395 * modes we can display on the LVDS panel (if present).
397 void intel_lvds_init(struct drm_device
*dev
)
399 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
400 struct intel_output
*intel_output
;
401 struct drm_connector
*connector
;
402 struct drm_encoder
*encoder
;
403 struct drm_display_mode
*scan
; /* *modes, *bios_mode; */
404 struct drm_crtc
*crtc
;
408 intel_output
= kzalloc(sizeof(struct intel_output
), GFP_KERNEL
);
413 connector
= &intel_output
->base
;
414 encoder
= &intel_output
->enc
;
415 drm_connector_init(dev
, &intel_output
->base
, &intel_lvds_connector_funcs
,
416 DRM_MODE_CONNECTOR_LVDS
);
418 drm_encoder_init(dev
, &intel_output
->enc
, &intel_lvds_enc_funcs
,
419 DRM_MODE_ENCODER_LVDS
);
421 drm_mode_connector_attach_encoder(&intel_output
->base
, &intel_output
->enc
);
422 intel_output
->type
= INTEL_OUTPUT_LVDS
;
424 drm_encoder_helper_add(encoder
, &intel_lvds_helper_funcs
);
425 drm_connector_helper_add(connector
, &intel_lvds_connector_helper_funcs
);
426 connector
->display_info
.subpixel_order
= SubPixelHorizontalRGB
;
427 connector
->interlace_allowed
= false;
428 connector
->doublescan_allowed
= false;
433 * 1) check for EDID on DDC
434 * 2) check for VBT data
435 * 3) check to see if LVDS is already on
436 * if none of the above, no panel
437 * 4) make sure lid is open
438 * if closed, act like it's not there for now
441 /* Set up the DDC bus. */
442 intel_output
->ddc_bus
= intel_i2c_create(dev
, GPIOC
, "LVDSDDC_C");
443 if (!intel_output
->ddc_bus
) {
444 dev_printk(KERN_ERR
, &dev
->pdev
->dev
, "DDC bus registration "
450 * Attempt to get the fixed panel mode from DDC. Assume that the
451 * preferred mode is the right one.
453 intel_ddc_get_modes(intel_output
);
455 list_for_each_entry(scan
, &connector
->probed_modes
, head
) {
456 mutex_lock(&dev
->mode_config
.mutex
);
457 if (scan
->type
& DRM_MODE_TYPE_PREFERRED
) {
458 dev_priv
->panel_fixed_mode
=
459 drm_mode_duplicate(dev
, scan
);
460 mutex_unlock(&dev
->mode_config
.mutex
);
461 goto out
; /* FIXME: check for quirks */
463 mutex_unlock(&dev
->mode_config
.mutex
);
466 /* Failed to get EDID, what about VBT? */
467 if (dev_priv
->vbt_mode
) {
468 mutex_lock(&dev
->mode_config
.mutex
);
469 dev_priv
->panel_fixed_mode
=
470 drm_mode_duplicate(dev
, dev_priv
->vbt_mode
);
471 mutex_unlock(&dev
->mode_config
.mutex
);
472 if (dev_priv
->panel_fixed_mode
) {
473 dev_priv
->panel_fixed_mode
->type
|=
474 DRM_MODE_TYPE_PREFERRED
;
475 drm_mode_probed_add(connector
,
476 dev_priv
->panel_fixed_mode
);
482 * If we didn't get EDID, try checking if the panel is already turned
483 * on. If so, assume that whatever is currently programmed is the
486 lvds
= I915_READ(LVDS
);
487 pipe
= (lvds
& LVDS_PIPEB_SELECT
) ? 1 : 0;
488 crtc
= intel_get_crtc_from_pipe(dev
, pipe
);
490 if (crtc
&& (lvds
& LVDS_PORT_EN
)) {
491 dev_priv
->panel_fixed_mode
= intel_crtc_mode_get(dev
, crtc
);
492 if (dev_priv
->panel_fixed_mode
) {
493 dev_priv
->panel_fixed_mode
->type
|=
494 DRM_MODE_TYPE_PREFERRED
;
495 goto out
; /* FIXME: check for quirks */
499 /* If we still don't have a mode after all that, give up. */
500 if (!dev_priv
->panel_fixed_mode
)
503 /* FIXME: detect aopen & mac mini type stuff automatically? */
505 * Blacklist machines with BIOSes that list an LVDS panel without
506 * actually having one.
508 if (IS_I945GM(dev
)) {
510 if (dev
->pdev
->subsystem_vendor
== 0xa0a0)
513 if ((dev
->pdev
->subsystem_vendor
== 0x8086) &&
514 (dev
->pdev
->subsystem_device
== 0x7270)) {
515 /* It's a Mac Mini or Macbook Pro.
517 * Apple hardware is out to get us. The macbook pro
518 * has a real LVDS panel, but the mac mini does not,
519 * and they have the same device IDs. We'll
520 * distinguish by panel size, on the assumption
521 * that Apple isn't about to make any machines with an
525 if (dev_priv
->panel_fixed_mode
!= NULL
&&
526 dev_priv
->panel_fixed_mode
->hdisplay
== 800 &&
527 dev_priv
->panel_fixed_mode
->vdisplay
== 600) {
528 DRM_DEBUG("Suspected Mac Mini, ignoring the LVDS\n");
536 drm_sysfs_connector_add(connector
);
540 DRM_DEBUG("No LVDS modes found, disabling.\n");
541 if (intel_output
->ddc_bus
)
542 intel_i2c_destroy(intel_output
->ddc_bus
);
543 drm_connector_cleanup(connector
);