2 * Copyright © 2006-2011 Intel Corporation
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 * Eric Anholt <eric@anholt.net>
19 * Dave Airlie <airlied@linux.ie>
20 * Jesse Barnes <jesse.barnes@intel.com>
23 #include <linux/i2c.h>
24 #include <linux/dmi.h>
27 #include "intel_bios.h"
29 #include "psb_intel_drv.h"
30 #include "psb_intel_reg.h"
32 #include <linux/pm_runtime.h>
33 #include "cdv_device.h"
36 * LVDS I2C backlight control macros
38 #define BRIGHTNESS_MAX_LEVEL 100
39 #define BRIGHTNESS_MASK 0xFF
40 #define BLC_I2C_TYPE 0x01
41 #define BLC_PWM_TYPT 0x02
43 #define BLC_POLARITY_NORMAL 0
44 #define BLC_POLARITY_INVERSE 1
46 #define PSB_BLC_MAX_PWM_REG_FREQ (0xFFFE)
47 #define PSB_BLC_MIN_PWM_REG_FREQ (0x2)
48 #define PSB_BLC_PWM_PRECISION_FACTOR (10)
49 #define PSB_BACKLIGHT_PWM_CTL_SHIFT (16)
50 #define PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR (0xFFFE)
52 struct cdv_intel_lvds_priv
{
54 * Saved LVDO output states
59 uint32_t savePP_CONTROL
;
60 uint32_t savePP_CYCLE
;
61 uint32_t savePFIT_CONTROL
;
62 uint32_t savePFIT_PGM_RATIOS
;
63 uint32_t saveBLC_PWM_CTL
;
67 * Returns the maximum level of the backlight duty cycle field.
69 static u32
cdv_intel_lvds_get_max_backlight(struct drm_device
*dev
)
71 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
74 if (gma_power_begin(dev
, false)) {
75 retval
= ((REG_READ(BLC_PWM_CTL
) &
76 BACKLIGHT_MODULATION_FREQ_MASK
) >>
77 BACKLIGHT_MODULATION_FREQ_SHIFT
) * 2;
81 retval
= ((dev_priv
->saveBLC_PWM_CTL
&
82 BACKLIGHT_MODULATION_FREQ_MASK
) >>
83 BACKLIGHT_MODULATION_FREQ_SHIFT
) * 2;
89 * Set LVDS backlight level by I2C command
91 static int cdv_lvds_i2c_set_brightness(struct drm_device
*dev
,
94 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
95 struct psb_intel_i2c_chan
*lvds_i2c_bus
= dev_priv
->lvds_i2c_bus
;
97 unsigned int blc_i2c_brightness
;
99 struct i2c_msg msgs
[] = {
101 .addr
= lvds_i2c_bus
->slave_addr
,
108 blc_i2c_brightness
= BRIGHTNESS_MASK
& ((unsigned int)level
*
110 BRIGHTNESS_MAX_LEVEL
);
112 if (dev_priv
->lvds_bl
->pol
== BLC_POLARITY_INVERSE
)
113 blc_i2c_brightness
= BRIGHTNESS_MASK
- blc_i2c_brightness
;
115 out_buf
[0] = dev_priv
->lvds_bl
->brightnesscmd
;
116 out_buf
[1] = (u8
)blc_i2c_brightness
;
118 if (i2c_transfer(&lvds_i2c_bus
->adapter
, msgs
, 1) == 1)
121 DRM_ERROR("I2C transfer error\n");
126 static int cdv_lvds_pwm_set_brightness(struct drm_device
*dev
, int level
)
128 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
131 u32 blc_pwm_duty_cycle
;
133 max_pwm_blc
= cdv_intel_lvds_get_max_backlight(dev
);
135 /*BLC_PWM_CTL Should be initiated while backlight device init*/
136 BUG_ON((max_pwm_blc
& PSB_BLC_MAX_PWM_REG_FREQ
) == 0);
138 blc_pwm_duty_cycle
= level
* max_pwm_blc
/ BRIGHTNESS_MAX_LEVEL
;
140 if (dev_priv
->lvds_bl
->pol
== BLC_POLARITY_INVERSE
)
141 blc_pwm_duty_cycle
= max_pwm_blc
- blc_pwm_duty_cycle
;
143 blc_pwm_duty_cycle
&= PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR
;
144 REG_WRITE(BLC_PWM_CTL
,
145 (max_pwm_blc
<< PSB_BACKLIGHT_PWM_CTL_SHIFT
) |
146 (blc_pwm_duty_cycle
));
152 * Set LVDS backlight level either by I2C or PWM
154 void cdv_intel_lvds_set_brightness(struct drm_device
*dev
, int level
)
156 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
158 if (!dev_priv
->lvds_bl
) {
159 DRM_ERROR("NO LVDS Backlight Info\n");
163 if (dev_priv
->lvds_bl
->type
== BLC_I2C_TYPE
)
164 cdv_lvds_i2c_set_brightness(dev
, level
);
166 cdv_lvds_pwm_set_brightness(dev
, level
);
170 * Sets the backlight level.
172 * level backlight level, from 0 to cdv_intel_lvds_get_max_backlight().
174 static void cdv_intel_lvds_set_backlight(struct drm_device
*dev
, int level
)
176 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
179 if (gma_power_begin(dev
, false)) {
181 REG_READ(BLC_PWM_CTL
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
182 REG_WRITE(BLC_PWM_CTL
,
184 (level
<< BACKLIGHT_DUTY_CYCLE_SHIFT
)));
187 blc_pwm_ctl
= dev_priv
->saveBLC_PWM_CTL
&
188 ~BACKLIGHT_DUTY_CYCLE_MASK
;
189 dev_priv
->saveBLC_PWM_CTL
= (blc_pwm_ctl
|
190 (level
<< BACKLIGHT_DUTY_CYCLE_SHIFT
));
195 * Sets the power state for the panel.
197 static void cdv_intel_lvds_set_power(struct drm_device
*dev
,
198 struct psb_intel_output
*output
, bool on
)
202 if (!gma_power_begin(dev
, true))
206 REG_WRITE(PP_CONTROL
, REG_READ(PP_CONTROL
) |
209 pp_status
= REG_READ(PP_STATUS
);
210 } while ((pp_status
& PP_ON
) == 0);
212 cdv_intel_lvds_set_backlight(dev
,
214 mode_dev
->backlight_duty_cycle
);
216 cdv_intel_lvds_set_backlight(dev
, 0);
218 REG_WRITE(PP_CONTROL
, REG_READ(PP_CONTROL
) &
221 pp_status
= REG_READ(PP_STATUS
);
222 } while (pp_status
& PP_ON
);
227 static void cdv_intel_lvds_encoder_dpms(struct drm_encoder
*encoder
, int mode
)
229 struct drm_device
*dev
= encoder
->dev
;
230 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
231 if (mode
== DRM_MODE_DPMS_ON
)
232 cdv_intel_lvds_set_power(dev
, output
, true);
234 cdv_intel_lvds_set_power(dev
, output
, false);
235 /* XXX: We never power down the LVDS pairs. */
238 static void cdv_intel_lvds_save(struct drm_connector
*connector
)
242 static void cdv_intel_lvds_restore(struct drm_connector
*connector
)
246 int cdv_intel_lvds_mode_valid(struct drm_connector
*connector
,
247 struct drm_display_mode
*mode
)
249 struct psb_intel_output
*psb_intel_output
=
250 to_psb_intel_output(connector
);
251 struct drm_display_mode
*fixed_mode
=
252 psb_intel_output
->mode_dev
->panel_fixed_mode
;
255 if (mode
->flags
& DRM_MODE_FLAG_DBLSCAN
)
256 return MODE_NO_DBLESCAN
;
259 if (mode
->flags
& DRM_MODE_FLAG_INTERLACE
)
260 return MODE_NO_INTERLACE
;
263 if (mode
->hdisplay
> fixed_mode
->hdisplay
)
265 if (mode
->vdisplay
> fixed_mode
->vdisplay
)
271 bool cdv_intel_lvds_mode_fixup(struct drm_encoder
*encoder
,
272 struct drm_display_mode
*mode
,
273 struct drm_display_mode
*adjusted_mode
)
275 struct psb_intel_mode_device
*mode_dev
=
276 enc_to_psb_intel_output(encoder
)->mode_dev
;
277 struct drm_device
*dev
= encoder
->dev
;
278 struct drm_encoder
*tmp_encoder
;
279 struct drm_display_mode
*panel_fixed_mode
= mode_dev
->panel_fixed_mode
;
281 /* Should never happen!! */
282 list_for_each_entry(tmp_encoder
, &dev
->mode_config
.encoder_list
,
284 if (tmp_encoder
!= encoder
285 && tmp_encoder
->crtc
== encoder
->crtc
) {
286 printk(KERN_ERR
"Can't enable LVDS and another "
287 "encoder on the same pipe\n");
293 * If we have timings from the BIOS for the panel, put them in
294 * to the adjusted mode. The CRTC will be set up for this mode,
295 * with the panel scaling set up to source from the H/VDisplay
296 * of the original mode.
298 if (panel_fixed_mode
!= NULL
) {
299 adjusted_mode
->hdisplay
= panel_fixed_mode
->hdisplay
;
300 adjusted_mode
->hsync_start
= panel_fixed_mode
->hsync_start
;
301 adjusted_mode
->hsync_end
= panel_fixed_mode
->hsync_end
;
302 adjusted_mode
->htotal
= panel_fixed_mode
->htotal
;
303 adjusted_mode
->vdisplay
= panel_fixed_mode
->vdisplay
;
304 adjusted_mode
->vsync_start
= panel_fixed_mode
->vsync_start
;
305 adjusted_mode
->vsync_end
= panel_fixed_mode
->vsync_end
;
306 adjusted_mode
->vtotal
= panel_fixed_mode
->vtotal
;
307 adjusted_mode
->clock
= panel_fixed_mode
->clock
;
308 drm_mode_set_crtcinfo(adjusted_mode
,
309 CRTC_INTERLACE_HALVE_V
);
313 * XXX: It would be nice to support lower refresh rates on the
314 * panels to reduce power consumption, and perhaps match the
315 * user's requested refresh rate.
321 static void cdv_intel_lvds_prepare(struct drm_encoder
*encoder
)
323 struct drm_device
*dev
= encoder
->dev
;
324 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
325 struct psb_intel_mode_device
*mode_dev
= output
->mode_dev
;
327 if (!gma_power_begin(dev
, true))
330 mode_dev
->saveBLC_PWM_CTL
= REG_READ(BLC_PWM_CTL
);
331 mode_dev
->backlight_duty_cycle
= (mode_dev
->saveBLC_PWM_CTL
&
332 BACKLIGHT_DUTY_CYCLE_MASK
);
334 cdv_intel_lvds_set_power(dev
, output
, false);
339 static void cdv_intel_lvds_commit(struct drm_encoder
*encoder
)
341 struct drm_device
*dev
= encoder
->dev
;
342 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
343 struct psb_intel_mode_device
*mode_dev
= output
->mode_dev
;
345 if (mode_dev
->backlight_duty_cycle
== 0)
346 mode_dev
->backlight_duty_cycle
=
347 cdv_intel_lvds_get_max_backlight(dev
);
349 cdv_intel_lvds_set_power(dev
, output
, true);
352 static void cdv_intel_lvds_mode_set(struct drm_encoder
*encoder
,
353 struct drm_display_mode
*mode
,
354 struct drm_display_mode
*adjusted_mode
)
356 struct psb_intel_mode_device
*mode_dev
=
357 enc_to_psb_intel_output(encoder
)->mode_dev
;
358 struct drm_device
*dev
= encoder
->dev
;
359 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
363 * The LVDS pin pair will already have been turned on in the
364 * cdv_intel_crtc_mode_set since it has a large impact on the DPLL
369 * Enable automatic panel scaling so that non-native modes fill the
370 * screen. Should be enabled before the pipe is enabled, according to
371 * register description and PRM.
373 if (mode
->hdisplay
!= adjusted_mode
->hdisplay
||
374 mode
->vdisplay
!= adjusted_mode
->vdisplay
)
375 pfit_control
= (PFIT_ENABLE
| VERT_AUTO_SCALE
|
376 HORIZ_AUTO_SCALE
| VERT_INTERP_BILINEAR
|
377 HORIZ_INTERP_BILINEAR
);
381 if (dev_priv
->lvds_dither
)
382 pfit_control
|= PANEL_8TO6_DITHER_ENABLE
;
384 REG_WRITE(PFIT_CONTROL
, pfit_control
);
388 * Detect the LVDS connection.
390 * This always returns CONNECTOR_STATUS_CONNECTED.
391 * This connector should only have
392 * been set up if the LVDS was actually connected anyway.
394 static enum drm_connector_status
cdv_intel_lvds_detect(
395 struct drm_connector
*connector
, bool force
)
397 return connector_status_connected
;
401 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
403 static int cdv_intel_lvds_get_modes(struct drm_connector
*connector
)
405 struct drm_device
*dev
= connector
->dev
;
406 struct psb_intel_output
*psb_intel_output
=
407 to_psb_intel_output(connector
);
408 struct psb_intel_mode_device
*mode_dev
=
409 psb_intel_output
->mode_dev
;
412 ret
= psb_intel_ddc_get_modes(psb_intel_output
);
417 /* Didn't get an EDID, so
418 * Set wide sync ranges so we get all modes
419 * handed to valid_mode for checking
421 connector
->display_info
.min_vfreq
= 0;
422 connector
->display_info
.max_vfreq
= 200;
423 connector
->display_info
.min_hfreq
= 0;
424 connector
->display_info
.max_hfreq
= 200;
425 if (mode_dev
->panel_fixed_mode
!= NULL
) {
426 struct drm_display_mode
*mode
=
427 drm_mode_duplicate(dev
, mode_dev
->panel_fixed_mode
);
428 drm_mode_probed_add(connector
, mode
);
436 * cdv_intel_lvds_destroy - unregister and free LVDS structures
437 * @connector: connector to free
439 * Unregister the DDC bus for this connector then free the driver private
442 void cdv_intel_lvds_destroy(struct drm_connector
*connector
)
444 struct psb_intel_output
*psb_intel_output
=
445 to_psb_intel_output(connector
);
447 if (psb_intel_output
->ddc_bus
)
448 psb_intel_i2c_destroy(psb_intel_output
->ddc_bus
);
449 drm_sysfs_connector_remove(connector
);
450 drm_connector_cleanup(connector
);
454 int cdv_intel_lvds_set_property(struct drm_connector
*connector
,
455 struct drm_property
*property
,
458 struct drm_encoder
*encoder
= connector
->encoder
;
460 if (!strcmp(property
->name
, "scaling mode") && encoder
) {
461 struct psb_intel_crtc
*crtc
=
462 to_psb_intel_crtc(encoder
->crtc
);
469 case DRM_MODE_SCALE_FULLSCREEN
:
471 case DRM_MODE_SCALE_NO_SCALE
:
473 case DRM_MODE_SCALE_ASPECT
:
479 if (drm_connector_property_get_value(connector
,
484 if (curValue
== value
)
487 if (drm_connector_property_set_value(connector
,
492 if (crtc
->saved_mode
.hdisplay
!= 0 &&
493 crtc
->saved_mode
.vdisplay
!= 0) {
494 if (!drm_crtc_helper_set_mode(encoder
->crtc
,
501 } else if (!strcmp(property
->name
, "backlight") && encoder
) {
502 if (drm_connector_property_set_value(connector
,
507 #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
508 struct drm_psb_private
*dev_priv
=
509 encoder
->dev
->dev_private
;
510 struct backlight_device
*bd
=
511 dev_priv
->backlight_device
;
512 bd
->props
.brightness
= value
;
513 backlight_update_status(bd
);
516 } else if (!strcmp(property
->name
, "DPMS") && encoder
) {
517 struct drm_encoder_helper_funcs
*helpers
=
518 encoder
->helper_private
;
519 helpers
->dpms(encoder
, value
);
524 static const struct drm_encoder_helper_funcs
525 cdv_intel_lvds_helper_funcs
= {
526 .dpms
= cdv_intel_lvds_encoder_dpms
,
527 .mode_fixup
= cdv_intel_lvds_mode_fixup
,
528 .prepare
= cdv_intel_lvds_prepare
,
529 .mode_set
= cdv_intel_lvds_mode_set
,
530 .commit
= cdv_intel_lvds_commit
,
533 static const struct drm_connector_helper_funcs
534 cdv_intel_lvds_connector_helper_funcs
= {
535 .get_modes
= cdv_intel_lvds_get_modes
,
536 .mode_valid
= cdv_intel_lvds_mode_valid
,
537 .best_encoder
= psb_intel_best_encoder
,
540 static const struct drm_connector_funcs cdv_intel_lvds_connector_funcs
= {
541 .dpms
= drm_helper_connector_dpms
,
542 .save
= cdv_intel_lvds_save
,
543 .restore
= cdv_intel_lvds_restore
,
544 .detect
= cdv_intel_lvds_detect
,
545 .fill_modes
= drm_helper_probe_single_connector_modes
,
546 .set_property
= cdv_intel_lvds_set_property
,
547 .destroy
= cdv_intel_lvds_destroy
,
551 static void cdv_intel_lvds_enc_destroy(struct drm_encoder
*encoder
)
553 drm_encoder_cleanup(encoder
);
556 const struct drm_encoder_funcs cdv_intel_lvds_enc_funcs
= {
557 .destroy
= cdv_intel_lvds_enc_destroy
,
561 * cdv_intel_lvds_init - setup LVDS connectors on this device
564 * Create the connector, register the LVDS DDC bus, and try to figure out what
565 * modes we can display on the LVDS panel (if present).
567 void cdv_intel_lvds_init(struct drm_device
*dev
,
568 struct psb_intel_mode_device
*mode_dev
)
570 struct psb_intel_output
*psb_intel_output
;
571 struct cdv_intel_lvds_priv
*lvds_priv
;
572 struct drm_connector
*connector
;
573 struct drm_encoder
*encoder
;
574 struct drm_display_mode
*scan
;
575 struct drm_crtc
*crtc
;
576 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
580 psb_intel_output
= kzalloc(sizeof(struct psb_intel_output
) +
581 sizeof(struct cdv_intel_lvds_priv
), GFP_KERNEL
);
582 if (!psb_intel_output
)
585 lvds_priv
= (struct cdv_intel_lvds_priv
*)(psb_intel_output
+ 1);
587 psb_intel_output
->dev_priv
= lvds_priv
;
589 psb_intel_output
->mode_dev
= mode_dev
;
590 connector
= &psb_intel_output
->base
;
591 encoder
= &psb_intel_output
->enc
;
594 drm_connector_init(dev
, &psb_intel_output
->base
,
595 &cdv_intel_lvds_connector_funcs
,
596 DRM_MODE_CONNECTOR_LVDS
);
598 drm_encoder_init(dev
, &psb_intel_output
->enc
,
599 &cdv_intel_lvds_enc_funcs
,
600 DRM_MODE_ENCODER_LVDS
);
603 drm_mode_connector_attach_encoder(&psb_intel_output
->base
,
604 &psb_intel_output
->enc
);
605 psb_intel_output
->type
= INTEL_OUTPUT_LVDS
;
607 drm_encoder_helper_add(encoder
, &cdv_intel_lvds_helper_funcs
);
608 drm_connector_helper_add(connector
,
609 &cdv_intel_lvds_connector_helper_funcs
);
610 connector
->display_info
.subpixel_order
= SubPixelHorizontalRGB
;
611 connector
->interlace_allowed
= false;
612 connector
->doublescan_allowed
= false;
614 /*Attach connector properties*/
615 drm_connector_attach_property(connector
,
616 dev
->mode_config
.scaling_mode_property
,
617 DRM_MODE_SCALE_FULLSCREEN
);
618 drm_connector_attach_property(connector
,
619 dev_priv
->backlight_property
,
620 BRIGHTNESS_MAX_LEVEL
);
624 * FIXME: distroy i2c_bus when exit
626 psb_intel_output
->i2c_bus
= psb_intel_i2c_create(dev
,
629 if (!psb_intel_output
->i2c_bus
) {
631 &dev
->pdev
->dev
, "I2C bus registration failed.\n");
634 psb_intel_output
->i2c_bus
->slave_addr
= 0x2C;
635 dev_priv
->lvds_i2c_bus
= psb_intel_output
->i2c_bus
;
639 * 1) check for EDID on DDC
640 * 2) check for VBT data
641 * 3) check to see if LVDS is already on
642 * if none of the above, no panel
643 * 4) make sure lid is open
644 * if closed, act like it's not there for now
647 /* Set up the DDC bus. */
648 psb_intel_output
->ddc_bus
= psb_intel_i2c_create(dev
,
651 if (!psb_intel_output
->ddc_bus
) {
652 dev_printk(KERN_ERR
, &dev
->pdev
->dev
,
653 "DDC bus registration " "failed.\n");
658 * Attempt to get the fixed panel mode from DDC. Assume that the
659 * preferred mode is the right one.
661 psb_intel_ddc_get_modes(psb_intel_output
);
662 list_for_each_entry(scan
, &connector
->probed_modes
, head
) {
663 if (scan
->type
& DRM_MODE_TYPE_PREFERRED
) {
664 mode_dev
->panel_fixed_mode
=
665 drm_mode_duplicate(dev
, scan
);
666 goto out
; /* FIXME: check for quirks */
670 /* Failed to get EDID, what about VBT? do we need this?*/
671 if (dev_priv
->lfp_lvds_vbt_mode
) {
672 mode_dev
->panel_fixed_mode
=
673 drm_mode_duplicate(dev
, dev_priv
->lfp_lvds_vbt_mode
);
674 if (mode_dev
->panel_fixed_mode
) {
675 mode_dev
->panel_fixed_mode
->type
|=
676 DRM_MODE_TYPE_PREFERRED
;
677 goto out
; /* FIXME: check for quirks */
681 * If we didn't get EDID, try checking if the panel is already turned
682 * on. If so, assume that whatever is currently programmed is the
685 lvds
= REG_READ(LVDS
);
686 pipe
= (lvds
& LVDS_PIPEB_SELECT
) ? 1 : 0;
687 crtc
= psb_intel_get_crtc_from_pipe(dev
, pipe
);
689 if (crtc
&& (lvds
& LVDS_PORT_EN
)) {
690 mode_dev
->panel_fixed_mode
=
691 cdv_intel_crtc_mode_get(dev
, crtc
);
692 if (mode_dev
->panel_fixed_mode
) {
693 mode_dev
->panel_fixed_mode
->type
|=
694 DRM_MODE_TYPE_PREFERRED
;
695 goto out
; /* FIXME: check for quirks */
699 /* If we still don't have a mode after all that, give up. */
700 if (!mode_dev
->panel_fixed_mode
) {
702 ("Found no modes on the lvds, ignoring the LVDS\n");
707 drm_sysfs_connector_add(connector
);
711 printk(KERN_ERR
"Failed find\n");
712 if (psb_intel_output
->ddc_bus
)
713 psb_intel_i2c_destroy(psb_intel_output
->ddc_bus
);
715 printk(KERN_ERR
"Failed DDC\n");
716 if (psb_intel_output
->i2c_bus
)
717 psb_intel_i2c_destroy(psb_intel_output
->i2c_bus
);
719 printk(KERN_ERR
"Failed BLC\n");
720 drm_encoder_cleanup(encoder
);
721 drm_connector_cleanup(connector
);