Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
psb_intel_lvds.c
Go to the documentation of this file.
1 /*
2  * Copyright © 2006-2007 Intel Corporation
3  *
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.
7  *
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
11  * more details.
12  *
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.
16  *
17  * Authors:
18  * Eric Anholt <[email protected]>
19  * Dave Airlie <[email protected]>
20  * Jesse Barnes <[email protected]>
21  */
22 
23 #include <linux/i2c.h>
24 #include <drm/drmP.h>
25 
26 #include "intel_bios.h"
27 #include "psb_drv.h"
28 #include "psb_intel_drv.h"
29 #include "psb_intel_reg.h"
30 #include "power.h"
31 #include <linux/pm_runtime.h>
32 
33 /*
34  * LVDS I2C backlight control macros
35  */
36 #define BRIGHTNESS_MAX_LEVEL 100
37 #define BRIGHTNESS_MASK 0xFF
38 #define BLC_I2C_TYPE 0x01
39 #define BLC_PWM_TYPT 0x02
40 
41 #define BLC_POLARITY_NORMAL 0
42 #define BLC_POLARITY_INVERSE 1
43 
44 #define PSB_BLC_MAX_PWM_REG_FREQ (0xFFFE)
45 #define PSB_BLC_MIN_PWM_REG_FREQ (0x2)
46 #define PSB_BLC_PWM_PRECISION_FACTOR (10)
47 #define PSB_BACKLIGHT_PWM_CTL_SHIFT (16)
48 #define PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR (0xFFFE)
49 
51  /*
52  * Saved LVDO output states
53  */
62 
65 };
66 
67 
68 /*
69  * Returns the maximum level of the backlight duty cycle field.
70  */
71 static u32 psb_intel_lvds_get_max_backlight(struct drm_device *dev)
72 {
73  struct drm_psb_private *dev_priv = dev->dev_private;
74  u32 ret;
75 
76  if (gma_power_begin(dev, false)) {
77  ret = REG_READ(BLC_PWM_CTL);
78  gma_power_end(dev);
79  } else /* Powered off, use the saved value */
80  ret = dev_priv->regs.saveBLC_PWM_CTL;
81 
82  /* Top 15bits hold the frequency mask */
83  ret = (ret & BACKLIGHT_MODULATION_FREQ_MASK) >>
85 
86  ret *= 2; /* Return a 16bit range as needed for setting */
87  if (ret == 0)
88  dev_err(dev->dev, "BL bug: Reg %08x save %08X\n",
89  REG_READ(BLC_PWM_CTL), dev_priv->regs.saveBLC_PWM_CTL);
90  return ret;
91 }
92 
93 /*
94  * Set LVDS backlight level by I2C command
95  *
96  * FIXME: at some point we need to both track this for PM and also
97  * disable runtime pm on MRST if the brightness is nil (ie blanked)
98  */
99 static int psb_lvds_i2c_set_brightness(struct drm_device *dev,
100  unsigned int level)
101 {
102  struct drm_psb_private *dev_priv =
103  (struct drm_psb_private *)dev->dev_private;
104 
105  struct psb_intel_i2c_chan *lvds_i2c_bus = dev_priv->lvds_i2c_bus;
106  u8 out_buf[2];
107  unsigned int blc_i2c_brightness;
108 
109  struct i2c_msg msgs[] = {
110  {
111  .addr = lvds_i2c_bus->slave_addr,
112  .flags = 0,
113  .len = 2,
114  .buf = out_buf,
115  }
116  };
117 
118  blc_i2c_brightness = BRIGHTNESS_MASK & ((unsigned int)level *
121 
122  if (dev_priv->lvds_bl->pol == BLC_POLARITY_INVERSE)
123  blc_i2c_brightness = BRIGHTNESS_MASK - blc_i2c_brightness;
124 
125  out_buf[0] = dev_priv->lvds_bl->brightnesscmd;
126  out_buf[1] = (u8)blc_i2c_brightness;
127 
128  if (i2c_transfer(&lvds_i2c_bus->adapter, msgs, 1) == 1) {
129  dev_dbg(dev->dev, "I2C set brightness.(command, value) (%d, %d)\n",
130  dev_priv->lvds_bl->brightnesscmd,
131  blc_i2c_brightness);
132  return 0;
133  }
134 
135  dev_err(dev->dev, "I2C transfer error\n");
136  return -1;
137 }
138 
139 
140 static int psb_lvds_pwm_set_brightness(struct drm_device *dev, int level)
141 {
142  struct drm_psb_private *dev_priv =
143  (struct drm_psb_private *)dev->dev_private;
144 
145  u32 max_pwm_blc;
146  u32 blc_pwm_duty_cycle;
147 
148  max_pwm_blc = psb_intel_lvds_get_max_backlight(dev);
149 
150  /*BLC_PWM_CTL Should be initiated while backlight device init*/
151  BUG_ON(max_pwm_blc == 0);
152 
153  blc_pwm_duty_cycle = level * max_pwm_blc / BRIGHTNESS_MAX_LEVEL;
154 
155  if (dev_priv->lvds_bl->pol == BLC_POLARITY_INVERSE)
156  blc_pwm_duty_cycle = max_pwm_blc - blc_pwm_duty_cycle;
157 
158  blc_pwm_duty_cycle &= PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR;
160  (max_pwm_blc << PSB_BACKLIGHT_PWM_CTL_SHIFT) |
161  (blc_pwm_duty_cycle));
162 
163  dev_info(dev->dev, "Backlight lvds set brightness %08x\n",
164  (max_pwm_blc << PSB_BACKLIGHT_PWM_CTL_SHIFT) |
165  (blc_pwm_duty_cycle));
166 
167  return 0;
168 }
169 
170 /*
171  * Set LVDS backlight level either by I2C or PWM
172  */
173 void psb_intel_lvds_set_brightness(struct drm_device *dev, int level)
174 {
175  struct drm_psb_private *dev_priv = dev->dev_private;
176 
177  dev_dbg(dev->dev, "backlight level is %d\n", level);
178 
179  if (!dev_priv->lvds_bl) {
180  dev_err(dev->dev, "NO LVDS backlight info\n");
181  return;
182  }
183 
184  if (dev_priv->lvds_bl->type == BLC_I2C_TYPE)
185  psb_lvds_i2c_set_brightness(dev, level);
186  else
187  psb_lvds_pwm_set_brightness(dev, level);
188 }
189 
190 /*
191  * Sets the backlight level.
192  *
193  * level: backlight level, from 0 to psb_intel_lvds_get_max_backlight().
194  */
195 static void psb_intel_lvds_set_backlight(struct drm_device *dev, int level)
196 {
197  struct drm_psb_private *dev_priv = dev->dev_private;
198  u32 blc_pwm_ctl;
199 
200  if (gma_power_begin(dev, false)) {
201  blc_pwm_ctl = REG_READ(BLC_PWM_CTL);
202  blc_pwm_ctl &= ~BACKLIGHT_DUTY_CYCLE_MASK;
204  (blc_pwm_ctl |
205  (level << BACKLIGHT_DUTY_CYCLE_SHIFT)));
206  dev_priv->regs.saveBLC_PWM_CTL = (blc_pwm_ctl |
207  (level << BACKLIGHT_DUTY_CYCLE_SHIFT));
208  gma_power_end(dev);
209  } else {
210  blc_pwm_ctl = dev_priv->regs.saveBLC_PWM_CTL &
212  dev_priv->regs.saveBLC_PWM_CTL = (blc_pwm_ctl |
213  (level << BACKLIGHT_DUTY_CYCLE_SHIFT));
214  }
215 }
216 
217 /*
218  * Sets the power state for the panel.
219  */
220 static void psb_intel_lvds_set_power(struct drm_device *dev, bool on)
221 {
222  struct drm_psb_private *dev_priv = dev->dev_private;
223  struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
224  u32 pp_status;
225 
226  if (!gma_power_begin(dev, true)) {
227  dev_err(dev->dev, "set power, chip off!\n");
228  return;
229  }
230 
231  if (on) {
234  do {
235  pp_status = REG_READ(PP_STATUS);
236  } while ((pp_status & PP_ON) == 0);
237 
238  psb_intel_lvds_set_backlight(dev,
239  mode_dev->backlight_duty_cycle);
240  } else {
241  psb_intel_lvds_set_backlight(dev, 0);
242 
244  ~POWER_TARGET_ON);
245  do {
246  pp_status = REG_READ(PP_STATUS);
247  } while (pp_status & PP_ON);
248  }
249 
250  gma_power_end(dev);
251 }
252 
253 static void psb_intel_lvds_encoder_dpms(struct drm_encoder *encoder, int mode)
254 {
255  struct drm_device *dev = encoder->dev;
256 
257  if (mode == DRM_MODE_DPMS_ON)
258  psb_intel_lvds_set_power(dev, true);
259  else
260  psb_intel_lvds_set_power(dev, false);
261 
262  /* XXX: We never power down the LVDS pairs. */
263 }
264 
265 static void psb_intel_lvds_save(struct drm_connector *connector)
266 {
267  struct drm_device *dev = connector->dev;
268  struct drm_psb_private *dev_priv =
269  (struct drm_psb_private *)dev->dev_private;
271  psb_intel_attached_encoder(connector);
272  struct psb_intel_lvds_priv *lvds_priv =
274 
275  lvds_priv->savePP_ON = REG_READ(LVDSPP_ON);
276  lvds_priv->savePP_OFF = REG_READ(LVDSPP_OFF);
277  lvds_priv->saveLVDS = REG_READ(LVDS);
278  lvds_priv->savePP_CONTROL = REG_READ(PP_CONTROL);
279  lvds_priv->savePP_CYCLE = REG_READ(PP_CYCLE);
280  /*lvds_priv->savePP_DIVISOR = REG_READ(PP_DIVISOR);*/
281  lvds_priv->saveBLC_PWM_CTL = REG_READ(BLC_PWM_CTL);
282  lvds_priv->savePFIT_CONTROL = REG_READ(PFIT_CONTROL);
284 
285  /*TODO: move backlight_duty_cycle to psb_intel_lvds_priv*/
286  dev_priv->backlight_duty_cycle = (dev_priv->regs.saveBLC_PWM_CTL &
288 
289  /*
290  * If the light is off at server startup,
291  * just make it full brightness
292  */
293  if (dev_priv->backlight_duty_cycle == 0)
294  dev_priv->backlight_duty_cycle =
295  psb_intel_lvds_get_max_backlight(dev);
296 
297  dev_dbg(dev->dev, "(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
298  lvds_priv->savePP_ON,
299  lvds_priv->savePP_OFF,
300  lvds_priv->saveLVDS,
301  lvds_priv->savePP_CONTROL,
302  lvds_priv->savePP_CYCLE,
303  lvds_priv->saveBLC_PWM_CTL);
304 }
305 
306 static void psb_intel_lvds_restore(struct drm_connector *connector)
307 {
308  struct drm_device *dev = connector->dev;
309  u32 pp_status;
311  psb_intel_attached_encoder(connector);
312  struct psb_intel_lvds_priv *lvds_priv =
313  (struct psb_intel_lvds_priv *)psb_intel_encoder->dev_priv;
314 
315  dev_dbg(dev->dev, "(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
316  lvds_priv->savePP_ON,
317  lvds_priv->savePP_OFF,
318  lvds_priv->saveLVDS,
319  lvds_priv->savePP_CONTROL,
320  lvds_priv->savePP_CYCLE,
321  lvds_priv->saveBLC_PWM_CTL);
322 
326  REG_WRITE(LVDSPP_ON, lvds_priv->savePP_ON);
327  REG_WRITE(LVDSPP_OFF, lvds_priv->savePP_OFF);
328  /*REG_WRITE(PP_DIVISOR, lvds_priv->savePP_DIVISOR);*/
329  REG_WRITE(PP_CYCLE, lvds_priv->savePP_CYCLE);
330  REG_WRITE(PP_CONTROL, lvds_priv->savePP_CONTROL);
331  REG_WRITE(LVDS, lvds_priv->saveLVDS);
332 
333  if (lvds_priv->savePP_CONTROL & POWER_TARGET_ON) {
336  do {
337  pp_status = REG_READ(PP_STATUS);
338  } while ((pp_status & PP_ON) == 0);
339  } else {
341  ~POWER_TARGET_ON);
342  do {
343  pp_status = REG_READ(PP_STATUS);
344  } while (pp_status & PP_ON);
345  }
346 }
347 
349  struct drm_display_mode *mode)
350 {
351  struct drm_psb_private *dev_priv = connector->dev->dev_private;
352  struct psb_intel_encoder *psb_intel_encoder =
353  psb_intel_attached_encoder(connector);
354  struct drm_display_mode *fixed_mode =
355  dev_priv->mode_dev.panel_fixed_mode;
356 
357  if (psb_intel_encoder->type == INTEL_OUTPUT_MIPI2)
358  fixed_mode = dev_priv->mode_dev.panel_fixed_mode2;
359 
360  /* just in case */
361  if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
362  return MODE_NO_DBLESCAN;
363 
364  /* just in case */
365  if (mode->flags & DRM_MODE_FLAG_INTERLACE)
366  return MODE_NO_INTERLACE;
367 
368  if (fixed_mode) {
369  if (mode->hdisplay > fixed_mode->hdisplay)
370  return MODE_PANEL;
371  if (mode->vdisplay > fixed_mode->vdisplay)
372  return MODE_PANEL;
373  }
374  return MODE_OK;
375 }
376 
378  const struct drm_display_mode *mode,
379  struct drm_display_mode *adjusted_mode)
380 {
381  struct drm_device *dev = encoder->dev;
382  struct drm_psb_private *dev_priv = dev->dev_private;
383  struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
385  to_psb_intel_crtc(encoder->crtc);
386  struct drm_encoder *tmp_encoder;
387  struct drm_display_mode *panel_fixed_mode = mode_dev->panel_fixed_mode;
388  struct psb_intel_encoder *psb_intel_encoder =
389  to_psb_intel_encoder(encoder);
390 
391  if (psb_intel_encoder->type == INTEL_OUTPUT_MIPI2)
392  panel_fixed_mode = mode_dev->panel_fixed_mode2;
393 
394  /* PSB requires the LVDS is on pipe B, MRST has only one pipe anyway */
395  if (!IS_MRST(dev) && psb_intel_crtc->pipe == 0) {
396  printk(KERN_ERR "Can't support LVDS on pipe A\n");
397  return false;
398  }
399  if (IS_MRST(dev) && psb_intel_crtc->pipe != 0) {
400  printk(KERN_ERR "Must use PIPE A\n");
401  return false;
402  }
403  /* Should never happen!! */
404  list_for_each_entry(tmp_encoder, &dev->mode_config.encoder_list,
405  head) {
406  if (tmp_encoder != encoder
407  && tmp_encoder->crtc == encoder->crtc) {
408  printk(KERN_ERR "Can't enable LVDS and another "
409  "encoder on the same pipe\n");
410  return false;
411  }
412  }
413 
414  /*
415  * If we have timings from the BIOS for the panel, put them in
416  * to the adjusted mode. The CRTC will be set up for this mode,
417  * with the panel scaling set up to source from the H/VDisplay
418  * of the original mode.
419  */
420  if (panel_fixed_mode != NULL) {
421  adjusted_mode->hdisplay = panel_fixed_mode->hdisplay;
422  adjusted_mode->hsync_start = panel_fixed_mode->hsync_start;
423  adjusted_mode->hsync_end = panel_fixed_mode->hsync_end;
424  adjusted_mode->htotal = panel_fixed_mode->htotal;
425  adjusted_mode->vdisplay = panel_fixed_mode->vdisplay;
426  adjusted_mode->vsync_start = panel_fixed_mode->vsync_start;
427  adjusted_mode->vsync_end = panel_fixed_mode->vsync_end;
428  adjusted_mode->vtotal = panel_fixed_mode->vtotal;
429  adjusted_mode->clock = panel_fixed_mode->clock;
430  drm_mode_set_crtcinfo(adjusted_mode,
432  }
433 
434  /*
435  * XXX: It would be nice to support lower refresh rates on the
436  * panels to reduce power consumption, and perhaps match the
437  * user's requested refresh rate.
438  */
439 
440  return true;
441 }
442 
443 static void psb_intel_lvds_prepare(struct drm_encoder *encoder)
444 {
445  struct drm_device *dev = encoder->dev;
446  struct drm_psb_private *dev_priv = dev->dev_private;
447  struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
448 
449  if (!gma_power_begin(dev, true))
450  return;
451 
452  mode_dev->saveBLC_PWM_CTL = REG_READ(BLC_PWM_CTL);
453  mode_dev->backlight_duty_cycle = (mode_dev->saveBLC_PWM_CTL &
455 
456  psb_intel_lvds_set_power(dev, false);
457 
458  gma_power_end(dev);
459 }
460 
461 static void psb_intel_lvds_commit(struct drm_encoder *encoder)
462 {
463  struct drm_device *dev = encoder->dev;
464  struct drm_psb_private *dev_priv = dev->dev_private;
465  struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
466 
467  if (mode_dev->backlight_duty_cycle == 0)
468  mode_dev->backlight_duty_cycle =
469  psb_intel_lvds_get_max_backlight(dev);
470 
471  psb_intel_lvds_set_power(dev, true);
472 }
473 
474 static void psb_intel_lvds_mode_set(struct drm_encoder *encoder,
475  struct drm_display_mode *mode,
476  struct drm_display_mode *adjusted_mode)
477 {
478  struct drm_device *dev = encoder->dev;
479  struct drm_psb_private *dev_priv = dev->dev_private;
480  u32 pfit_control;
481 
482  /*
483  * The LVDS pin pair will already have been turned on in the
484  * psb_intel_crtc_mode_set since it has a large impact on the DPLL
485  * settings.
486  */
487 
488  /*
489  * Enable automatic panel scaling so that non-native modes fill the
490  * screen. Should be enabled before the pipe is enabled, according to
491  * register description and PRM.
492  */
493  if (mode->hdisplay != adjusted_mode->hdisplay ||
494  mode->vdisplay != adjusted_mode->vdisplay)
495  pfit_control = (PFIT_ENABLE | VERT_AUTO_SCALE |
498  else
499  pfit_control = 0;
500 
501  if (dev_priv->lvds_dither)
502  pfit_control |= PANEL_8TO6_DITHER_ENABLE;
503 
504  REG_WRITE(PFIT_CONTROL, pfit_control);
505 }
506 
507 /*
508  * Detect the LVDS connection.
509  *
510  * This always returns CONNECTOR_STATUS_CONNECTED.
511  * This connector should only have
512  * been set up if the LVDS was actually connected anyway.
513  */
514 static enum drm_connector_status psb_intel_lvds_detect(struct drm_connector
515  *connector, bool force)
516 {
518 }
519 
520 /*
521  * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
522  */
523 static int psb_intel_lvds_get_modes(struct drm_connector *connector)
524 {
525  struct drm_device *dev = connector->dev;
526  struct drm_psb_private *dev_priv = dev->dev_private;
527  struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
528  struct psb_intel_encoder *psb_intel_encoder =
529  psb_intel_attached_encoder(connector);
530  struct psb_intel_lvds_priv *lvds_priv = psb_intel_encoder->dev_priv;
531  int ret = 0;
532 
533  if (!IS_MRST(dev))
534  ret = psb_intel_ddc_get_modes(connector, &lvds_priv->i2c_bus->adapter);
535 
536  if (ret)
537  return ret;
538 
539  /* Didn't get an EDID, so
540  * Set wide sync ranges so we get all modes
541  * handed to valid_mode for checking
542  */
543  connector->display_info.min_vfreq = 0;
544  connector->display_info.max_vfreq = 200;
545  connector->display_info.min_hfreq = 0;
546  connector->display_info.max_hfreq = 200;
547 
548  if (mode_dev->panel_fixed_mode != NULL) {
549  struct drm_display_mode *mode =
550  drm_mode_duplicate(dev, mode_dev->panel_fixed_mode);
551  drm_mode_probed_add(connector, mode);
552  return 1;
553  }
554 
555  return 0;
556 }
557 
565 void psb_intel_lvds_destroy(struct drm_connector *connector)
566 {
567  struct psb_intel_encoder *psb_intel_encoder =
568  psb_intel_attached_encoder(connector);
569  struct psb_intel_lvds_priv *lvds_priv = psb_intel_encoder->dev_priv;
570 
571  if (lvds_priv->ddc_bus)
572  psb_intel_i2c_destroy(lvds_priv->ddc_bus);
573  drm_sysfs_connector_remove(connector);
574  drm_connector_cleanup(connector);
575  kfree(connector);
576 }
577 
579  struct drm_property *property,
580  uint64_t value)
581 {
582  struct drm_encoder *encoder = connector->encoder;
583 
584  if (!encoder)
585  return -1;
586 
587  if (!strcmp(property->name, "scaling mode")) {
588  struct psb_intel_crtc *crtc =
589  to_psb_intel_crtc(encoder->crtc);
590  uint64_t curval;
591 
592  if (!crtc)
593  goto set_prop_error;
594 
595  switch (value) {
597  break;
599  break;
601  break;
602  default:
603  goto set_prop_error;
604  }
605 
606  if (drm_connector_property_get_value(connector,
607  property,
608  &curval))
609  goto set_prop_error;
610 
611  if (curval == value)
612  goto set_prop_done;
613 
614  if (drm_connector_property_set_value(connector,
615  property,
616  value))
617  goto set_prop_error;
618 
619  if (crtc->saved_mode.hdisplay != 0 &&
620  crtc->saved_mode.vdisplay != 0) {
621  if (!drm_crtc_helper_set_mode(encoder->crtc,
622  &crtc->saved_mode,
623  encoder->crtc->x,
624  encoder->crtc->y,
625  encoder->crtc->fb))
626  goto set_prop_error;
627  }
628  } else if (!strcmp(property->name, "backlight")) {
629  if (drm_connector_property_set_value(connector,
630  property,
631  value))
632  goto set_prop_error;
633  else
634  gma_backlight_set(encoder->dev, value);
635  } else if (!strcmp(property->name, "DPMS")) {
636  struct drm_encoder_helper_funcs *hfuncs
637  = encoder->helper_private;
638  hfuncs->dpms(encoder, value);
639  }
640 
641 set_prop_done:
642  return 0;
643 set_prop_error:
644  return -1;
645 }
646 
647 static const struct drm_encoder_helper_funcs psb_intel_lvds_helper_funcs = {
648  .dpms = psb_intel_lvds_encoder_dpms,
649  .mode_fixup = psb_intel_lvds_mode_fixup,
650  .prepare = psb_intel_lvds_prepare,
651  .mode_set = psb_intel_lvds_mode_set,
652  .commit = psb_intel_lvds_commit,
653 };
654 
655 const struct drm_connector_helper_funcs
657  .get_modes = psb_intel_lvds_get_modes,
658  .mode_valid = psb_intel_lvds_mode_valid,
659  .best_encoder = psb_intel_best_encoder,
660 };
661 
664  .save = psb_intel_lvds_save,
665  .restore = psb_intel_lvds_restore,
666  .detect = psb_intel_lvds_detect,
668  .set_property = psb_intel_lvds_set_property,
669  .destroy = psb_intel_lvds_destroy,
670 };
671 
672 
673 static void psb_intel_lvds_enc_destroy(struct drm_encoder *encoder)
674 {
675  drm_encoder_cleanup(encoder);
676 }
677 
679  .destroy = psb_intel_lvds_enc_destroy,
680 };
681 
682 
683 
692  struct psb_intel_mode_device *mode_dev)
693 {
694  struct psb_intel_encoder *psb_intel_encoder;
696  struct psb_intel_lvds_priv *lvds_priv;
697  struct drm_connector *connector;
698  struct drm_encoder *encoder;
699  struct drm_display_mode *scan; /* *modes, *bios_mode; */
700  struct drm_crtc *crtc;
701  struct drm_psb_private *dev_priv = dev->dev_private;
702  u32 lvds;
703  int pipe;
704 
705  psb_intel_encoder =
706  kzalloc(sizeof(struct psb_intel_encoder), GFP_KERNEL);
707  if (!psb_intel_encoder) {
708  dev_err(dev->dev, "psb_intel_encoder allocation error\n");
709  return;
710  }
711 
712  psb_intel_connector =
713  kzalloc(sizeof(struct psb_intel_connector), GFP_KERNEL);
714  if (!psb_intel_connector) {
715  dev_err(dev->dev, "psb_intel_connector allocation error\n");
716  goto failed_encoder;
717  }
718 
719  lvds_priv = kzalloc(sizeof(struct psb_intel_lvds_priv), GFP_KERNEL);
720  if (!lvds_priv) {
721  dev_err(dev->dev, "LVDS private allocation error\n");
722  goto failed_connector;
723  }
724 
725  psb_intel_encoder->dev_priv = lvds_priv;
726 
727  connector = &psb_intel_connector->base;
728  encoder = &psb_intel_encoder->base;
729  drm_connector_init(dev, connector,
730  &psb_intel_lvds_connector_funcs,
732 
733  drm_encoder_init(dev, encoder,
734  &psb_intel_lvds_enc_funcs,
736 
737  psb_intel_connector_attach_encoder(psb_intel_connector,
738  psb_intel_encoder);
739  psb_intel_encoder->type = INTEL_OUTPUT_LVDS;
740 
741  drm_encoder_helper_add(encoder, &psb_intel_lvds_helper_funcs);
742  drm_connector_helper_add(connector,
743  &psb_intel_lvds_connector_helper_funcs);
744  connector->display_info.subpixel_order = SubPixelHorizontalRGB;
745  connector->interlace_allowed = false;
746  connector->doublescan_allowed = false;
747 
748  /*Attach connector properties*/
750  dev->mode_config.scaling_mode_property,
753  dev_priv->backlight_property,
755 
756  /*
757  * Set up I2C bus
758  * FIXME: distroy i2c_bus when exit
759  */
760  lvds_priv->i2c_bus = psb_intel_i2c_create(dev, GPIOB, "LVDSBLC_B");
761  if (!lvds_priv->i2c_bus) {
762  dev_printk(KERN_ERR,
763  &dev->pdev->dev, "I2C bus registration failed.\n");
764  goto failed_blc_i2c;
765  }
766  lvds_priv->i2c_bus->slave_addr = 0x2C;
767  dev_priv->lvds_i2c_bus = lvds_priv->i2c_bus;
768 
769  /*
770  * LVDS discovery:
771  * 1) check for EDID on DDC
772  * 2) check for VBT data
773  * 3) check to see if LVDS is already on
774  * if none of the above, no panel
775  * 4) make sure lid is open
776  * if closed, act like it's not there for now
777  */
778 
779  /* Set up the DDC bus. */
780  lvds_priv->ddc_bus = psb_intel_i2c_create(dev, GPIOC, "LVDSDDC_C");
781  if (!lvds_priv->ddc_bus) {
782  dev_printk(KERN_ERR, &dev->pdev->dev,
783  "DDC bus registration " "failed.\n");
784  goto failed_ddc;
785  }
786 
787  /*
788  * Attempt to get the fixed panel mode from DDC. Assume that the
789  * preferred mode is the right one.
790  */
791  psb_intel_ddc_get_modes(connector, &lvds_priv->ddc_bus->adapter);
792  list_for_each_entry(scan, &connector->probed_modes, head) {
793  if (scan->type & DRM_MODE_TYPE_PREFERRED) {
794  mode_dev->panel_fixed_mode =
795  drm_mode_duplicate(dev, scan);
796  goto out; /* FIXME: check for quirks */
797  }
798  }
799 
800  /* Failed to get EDID, what about VBT? do we need this? */
801  if (mode_dev->vbt_mode)
802  mode_dev->panel_fixed_mode =
803  drm_mode_duplicate(dev, mode_dev->vbt_mode);
804 
805  if (!mode_dev->panel_fixed_mode)
806  if (dev_priv->lfp_lvds_vbt_mode)
807  mode_dev->panel_fixed_mode =
808  drm_mode_duplicate(dev,
809  dev_priv->lfp_lvds_vbt_mode);
810 
811  /*
812  * If we didn't get EDID, try checking if the panel is already turned
813  * on. If so, assume that whatever is currently programmed is the
814  * correct mode.
815  */
816  lvds = REG_READ(LVDS);
817  pipe = (lvds & LVDS_PIPEB_SELECT) ? 1 : 0;
818  crtc = psb_intel_get_crtc_from_pipe(dev, pipe);
819 
820  if (crtc && (lvds & LVDS_PORT_EN)) {
821  mode_dev->panel_fixed_mode =
822  psb_intel_crtc_mode_get(dev, crtc);
823  if (mode_dev->panel_fixed_mode) {
824  mode_dev->panel_fixed_mode->type |=
826  goto out; /* FIXME: check for quirks */
827  }
828  }
829 
830  /* If we still don't have a mode after all that, give up. */
831  if (!mode_dev->panel_fixed_mode) {
832  dev_err(dev->dev, "Found no modes on the lvds, ignoring the LVDS\n");
833  goto failed_find;
834  }
835 
836  /*
837  * Blacklist machines with BIOSes that list an LVDS panel without
838  * actually having one.
839  */
840 out:
841  drm_sysfs_connector_add(connector);
842  return;
843 
844 failed_find:
845  if (lvds_priv->ddc_bus)
846  psb_intel_i2c_destroy(lvds_priv->ddc_bus);
847 failed_ddc:
848  if (lvds_priv->i2c_bus)
849  psb_intel_i2c_destroy(lvds_priv->i2c_bus);
850 failed_blc_i2c:
851  drm_encoder_cleanup(encoder);
852  drm_connector_cleanup(connector);
853 failed_connector:
854  kfree(psb_intel_connector);
855 failed_encoder:
856  kfree(psb_intel_encoder);
857 }
858