Commit | Line | Data |
---|---|---|
6a227d5f AC |
1 | /* |
2 | * Copyright © 2006-2011 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 <eric@anholt.net> | |
19 | * Dave Airlie <airlied@linux.ie> | |
20 | * Jesse Barnes <jesse.barnes@intel.com> | |
21 | */ | |
22 | ||
23 | #include <linux/i2c.h> | |
24 | #include <linux/dmi.h> | |
25 | #include <drm/drmP.h> | |
26 | ||
27 | #include "intel_bios.h" | |
28 | #include "psb_drv.h" | |
29 | #include "psb_intel_drv.h" | |
30 | #include "psb_intel_reg.h" | |
31 | #include "power.h" | |
32 | #include <linux/pm_runtime.h> | |
33 | #include "cdv_device.h" | |
34 | ||
35 | /** | |
36 | * LVDS I2C backlight control macros | |
37 | */ | |
38 | #define BRIGHTNESS_MAX_LEVEL 100 | |
39 | #define BRIGHTNESS_MASK 0xFF | |
40 | #define BLC_I2C_TYPE 0x01 | |
41 | #define BLC_PWM_TYPT 0x02 | |
42 | ||
43 | #define BLC_POLARITY_NORMAL 0 | |
44 | #define BLC_POLARITY_INVERSE 1 | |
45 | ||
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) | |
51 | ||
52 | struct cdv_intel_lvds_priv { | |
53 | /** | |
54 | * Saved LVDO output states | |
55 | */ | |
56 | uint32_t savePP_ON; | |
57 | uint32_t savePP_OFF; | |
58 | uint32_t saveLVDS; | |
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; | |
64 | }; | |
65 | ||
66 | /* | |
67 | * Returns the maximum level of the backlight duty cycle field. | |
68 | */ | |
69 | static u32 cdv_intel_lvds_get_max_backlight(struct drm_device *dev) | |
70 | { | |
71 | struct drm_psb_private *dev_priv = dev->dev_private; | |
72 | u32 retval; | |
73 | ||
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; | |
78 | ||
79 | gma_power_end(dev); | |
80 | } else | |
648a8e34 | 81 | retval = ((dev_priv->regs.saveBLC_PWM_CTL & |
6a227d5f AC |
82 | BACKLIGHT_MODULATION_FREQ_MASK) >> |
83 | BACKLIGHT_MODULATION_FREQ_SHIFT) * 2; | |
84 | ||
85 | return retval; | |
86 | } | |
87 | ||
88 | /* | |
89 | * Set LVDS backlight level by I2C command | |
90 | */ | |
91 | static int cdv_lvds_i2c_set_brightness(struct drm_device *dev, | |
92 | unsigned int level) | |
93 | { | |
94 | struct drm_psb_private *dev_priv = dev->dev_private; | |
95 | struct psb_intel_i2c_chan *lvds_i2c_bus = dev_priv->lvds_i2c_bus; | |
96 | u8 out_buf[2]; | |
97 | unsigned int blc_i2c_brightness; | |
98 | ||
99 | struct i2c_msg msgs[] = { | |
100 | { | |
101 | .addr = lvds_i2c_bus->slave_addr, | |
102 | .flags = 0, | |
103 | .len = 2, | |
104 | .buf = out_buf, | |
105 | } | |
106 | }; | |
107 | ||
108 | blc_i2c_brightness = BRIGHTNESS_MASK & ((unsigned int)level * | |
109 | BRIGHTNESS_MASK / | |
110 | BRIGHTNESS_MAX_LEVEL); | |
111 | ||
112 | if (dev_priv->lvds_bl->pol == BLC_POLARITY_INVERSE) | |
113 | blc_i2c_brightness = BRIGHTNESS_MASK - blc_i2c_brightness; | |
114 | ||
115 | out_buf[0] = dev_priv->lvds_bl->brightnesscmd; | |
116 | out_buf[1] = (u8)blc_i2c_brightness; | |
117 | ||
118 | if (i2c_transfer(&lvds_i2c_bus->adapter, msgs, 1) == 1) | |
119 | return 0; | |
120 | ||
121 | DRM_ERROR("I2C transfer error\n"); | |
122 | return -1; | |
123 | } | |
124 | ||
125 | ||
126 | static int cdv_lvds_pwm_set_brightness(struct drm_device *dev, int level) | |
127 | { | |
128 | struct drm_psb_private *dev_priv = dev->dev_private; | |
129 | ||
130 | u32 max_pwm_blc; | |
131 | u32 blc_pwm_duty_cycle; | |
132 | ||
133 | max_pwm_blc = cdv_intel_lvds_get_max_backlight(dev); | |
134 | ||
135 | /*BLC_PWM_CTL Should be initiated while backlight device init*/ | |
136 | BUG_ON((max_pwm_blc & PSB_BLC_MAX_PWM_REG_FREQ) == 0); | |
137 | ||
138 | blc_pwm_duty_cycle = level * max_pwm_blc / BRIGHTNESS_MAX_LEVEL; | |
139 | ||
140 | if (dev_priv->lvds_bl->pol == BLC_POLARITY_INVERSE) | |
141 | blc_pwm_duty_cycle = max_pwm_blc - blc_pwm_duty_cycle; | |
142 | ||
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)); | |
147 | ||
148 | return 0; | |
149 | } | |
150 | ||
151 | /* | |
152 | * Set LVDS backlight level either by I2C or PWM | |
153 | */ | |
154 | void cdv_intel_lvds_set_brightness(struct drm_device *dev, int level) | |
155 | { | |
156 | struct drm_psb_private *dev_priv = dev->dev_private; | |
157 | ||
158 | if (!dev_priv->lvds_bl) { | |
159 | DRM_ERROR("NO LVDS Backlight Info\n"); | |
160 | return; | |
161 | } | |
162 | ||
163 | if (dev_priv->lvds_bl->type == BLC_I2C_TYPE) | |
164 | cdv_lvds_i2c_set_brightness(dev, level); | |
165 | else | |
166 | cdv_lvds_pwm_set_brightness(dev, level); | |
167 | } | |
168 | ||
169 | /** | |
170 | * Sets the backlight level. | |
171 | * | |
172 | * level backlight level, from 0 to cdv_intel_lvds_get_max_backlight(). | |
173 | */ | |
174 | static void cdv_intel_lvds_set_backlight(struct drm_device *dev, int level) | |
175 | { | |
176 | struct drm_psb_private *dev_priv = dev->dev_private; | |
177 | u32 blc_pwm_ctl; | |
178 | ||
179 | if (gma_power_begin(dev, false)) { | |
180 | blc_pwm_ctl = | |
181 | REG_READ(BLC_PWM_CTL) & ~BACKLIGHT_DUTY_CYCLE_MASK; | |
182 | REG_WRITE(BLC_PWM_CTL, | |
183 | (blc_pwm_ctl | | |
184 | (level << BACKLIGHT_DUTY_CYCLE_SHIFT))); | |
185 | gma_power_end(dev); | |
186 | } else { | |
648a8e34 | 187 | blc_pwm_ctl = dev_priv->regs.saveBLC_PWM_CTL & |
6a227d5f | 188 | ~BACKLIGHT_DUTY_CYCLE_MASK; |
648a8e34 | 189 | dev_priv->regs.saveBLC_PWM_CTL = (blc_pwm_ctl | |
6a227d5f AC |
190 | (level << BACKLIGHT_DUTY_CYCLE_SHIFT)); |
191 | } | |
192 | } | |
193 | ||
194 | /** | |
195 | * Sets the power state for the panel. | |
196 | */ | |
197 | static void cdv_intel_lvds_set_power(struct drm_device *dev, | |
a12d6a07 | 198 | struct drm_encoder *encoder, bool on) |
6a227d5f | 199 | { |
a12d6a07 | 200 | struct drm_psb_private *dev_priv = dev->dev_private; |
6a227d5f AC |
201 | u32 pp_status; |
202 | ||
203 | if (!gma_power_begin(dev, true)) | |
204 | return; | |
205 | ||
206 | if (on) { | |
207 | REG_WRITE(PP_CONTROL, REG_READ(PP_CONTROL) | | |
208 | POWER_TARGET_ON); | |
209 | do { | |
210 | pp_status = REG_READ(PP_STATUS); | |
211 | } while ((pp_status & PP_ON) == 0); | |
212 | ||
213 | cdv_intel_lvds_set_backlight(dev, | |
a12d6a07 | 214 | dev_priv->mode_dev.backlight_duty_cycle); |
6a227d5f AC |
215 | } else { |
216 | cdv_intel_lvds_set_backlight(dev, 0); | |
217 | ||
218 | REG_WRITE(PP_CONTROL, REG_READ(PP_CONTROL) & | |
219 | ~POWER_TARGET_ON); | |
220 | do { | |
221 | pp_status = REG_READ(PP_STATUS); | |
222 | } while (pp_status & PP_ON); | |
223 | } | |
224 | gma_power_end(dev); | |
225 | } | |
226 | ||
227 | static void cdv_intel_lvds_encoder_dpms(struct drm_encoder *encoder, int mode) | |
228 | { | |
229 | struct drm_device *dev = encoder->dev; | |
6a227d5f | 230 | if (mode == DRM_MODE_DPMS_ON) |
a12d6a07 | 231 | cdv_intel_lvds_set_power(dev, encoder, true); |
6a227d5f | 232 | else |
a12d6a07 | 233 | cdv_intel_lvds_set_power(dev, encoder, false); |
6a227d5f AC |
234 | /* XXX: We never power down the LVDS pairs. */ |
235 | } | |
236 | ||
237 | static void cdv_intel_lvds_save(struct drm_connector *connector) | |
238 | { | |
239 | } | |
240 | ||
241 | static void cdv_intel_lvds_restore(struct drm_connector *connector) | |
242 | { | |
243 | } | |
244 | ||
245 | int cdv_intel_lvds_mode_valid(struct drm_connector *connector, | |
a12d6a07 | 246 | struct drm_display_mode *mode) |
6a227d5f | 247 | { |
a12d6a07 PJ |
248 | struct drm_device *dev = connector->dev; |
249 | struct drm_psb_private *dev_priv = dev->dev_private; | |
6a227d5f | 250 | struct drm_display_mode *fixed_mode = |
a12d6a07 | 251 | dev_priv->mode_dev.panel_fixed_mode; |
6a227d5f AC |
252 | |
253 | /* just in case */ | |
254 | if (mode->flags & DRM_MODE_FLAG_DBLSCAN) | |
255 | return MODE_NO_DBLESCAN; | |
256 | ||
257 | /* just in case */ | |
258 | if (mode->flags & DRM_MODE_FLAG_INTERLACE) | |
259 | return MODE_NO_INTERLACE; | |
260 | ||
261 | if (fixed_mode) { | |
262 | if (mode->hdisplay > fixed_mode->hdisplay) | |
263 | return MODE_PANEL; | |
264 | if (mode->vdisplay > fixed_mode->vdisplay) | |
265 | return MODE_PANEL; | |
266 | } | |
267 | return MODE_OK; | |
268 | } | |
269 | ||
270 | bool cdv_intel_lvds_mode_fixup(struct drm_encoder *encoder, | |
271 | struct drm_display_mode *mode, | |
272 | struct drm_display_mode *adjusted_mode) | |
273 | { | |
6a227d5f | 274 | struct drm_device *dev = encoder->dev; |
a12d6a07 PJ |
275 | struct drm_psb_private *dev_priv = dev->dev_private; |
276 | struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev; | |
6a227d5f AC |
277 | struct drm_encoder *tmp_encoder; |
278 | struct drm_display_mode *panel_fixed_mode = mode_dev->panel_fixed_mode; | |
279 | ||
280 | /* Should never happen!! */ | |
281 | list_for_each_entry(tmp_encoder, &dev->mode_config.encoder_list, | |
282 | head) { | |
283 | if (tmp_encoder != encoder | |
284 | && tmp_encoder->crtc == encoder->crtc) { | |
285 | printk(KERN_ERR "Can't enable LVDS and another " | |
286 | "encoder on the same pipe\n"); | |
287 | return false; | |
288 | } | |
289 | } | |
290 | ||
291 | /* | |
292 | * If we have timings from the BIOS for the panel, put them in | |
293 | * to the adjusted mode. The CRTC will be set up for this mode, | |
294 | * with the panel scaling set up to source from the H/VDisplay | |
295 | * of the original mode. | |
296 | */ | |
297 | if (panel_fixed_mode != NULL) { | |
298 | adjusted_mode->hdisplay = panel_fixed_mode->hdisplay; | |
299 | adjusted_mode->hsync_start = panel_fixed_mode->hsync_start; | |
300 | adjusted_mode->hsync_end = panel_fixed_mode->hsync_end; | |
301 | adjusted_mode->htotal = panel_fixed_mode->htotal; | |
302 | adjusted_mode->vdisplay = panel_fixed_mode->vdisplay; | |
303 | adjusted_mode->vsync_start = panel_fixed_mode->vsync_start; | |
304 | adjusted_mode->vsync_end = panel_fixed_mode->vsync_end; | |
305 | adjusted_mode->vtotal = panel_fixed_mode->vtotal; | |
306 | adjusted_mode->clock = panel_fixed_mode->clock; | |
307 | drm_mode_set_crtcinfo(adjusted_mode, | |
308 | CRTC_INTERLACE_HALVE_V); | |
309 | } | |
310 | ||
311 | /* | |
312 | * XXX: It would be nice to support lower refresh rates on the | |
313 | * panels to reduce power consumption, and perhaps match the | |
314 | * user's requested refresh rate. | |
315 | */ | |
316 | ||
317 | return true; | |
318 | } | |
319 | ||
320 | static void cdv_intel_lvds_prepare(struct drm_encoder *encoder) | |
321 | { | |
322 | struct drm_device *dev = encoder->dev; | |
a12d6a07 PJ |
323 | struct drm_psb_private *dev_priv = dev->dev_private; |
324 | struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev; | |
6a227d5f AC |
325 | |
326 | if (!gma_power_begin(dev, true)) | |
327 | return; | |
328 | ||
329 | mode_dev->saveBLC_PWM_CTL = REG_READ(BLC_PWM_CTL); | |
330 | mode_dev->backlight_duty_cycle = (mode_dev->saveBLC_PWM_CTL & | |
331 | BACKLIGHT_DUTY_CYCLE_MASK); | |
332 | ||
a12d6a07 | 333 | cdv_intel_lvds_set_power(dev, encoder, false); |
6a227d5f AC |
334 | |
335 | gma_power_end(dev); | |
336 | } | |
337 | ||
338 | static void cdv_intel_lvds_commit(struct drm_encoder *encoder) | |
339 | { | |
340 | struct drm_device *dev = encoder->dev; | |
a12d6a07 PJ |
341 | struct drm_psb_private *dev_priv = dev->dev_private; |
342 | struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev; | |
6a227d5f AC |
343 | |
344 | if (mode_dev->backlight_duty_cycle == 0) | |
345 | mode_dev->backlight_duty_cycle = | |
346 | cdv_intel_lvds_get_max_backlight(dev); | |
347 | ||
a12d6a07 | 348 | cdv_intel_lvds_set_power(dev, encoder, true); |
6a227d5f AC |
349 | } |
350 | ||
351 | static void cdv_intel_lvds_mode_set(struct drm_encoder *encoder, | |
352 | struct drm_display_mode *mode, | |
353 | struct drm_display_mode *adjusted_mode) | |
354 | { | |
355 | struct drm_device *dev = encoder->dev; | |
356 | struct drm_psb_private *dev_priv = dev->dev_private; | |
357 | u32 pfit_control; | |
358 | ||
359 | /* | |
360 | * The LVDS pin pair will already have been turned on in the | |
361 | * cdv_intel_crtc_mode_set since it has a large impact on the DPLL | |
362 | * settings. | |
363 | */ | |
364 | ||
365 | /* | |
366 | * Enable automatic panel scaling so that non-native modes fill the | |
367 | * screen. Should be enabled before the pipe is enabled, according to | |
368 | * register description and PRM. | |
369 | */ | |
370 | if (mode->hdisplay != adjusted_mode->hdisplay || | |
371 | mode->vdisplay != adjusted_mode->vdisplay) | |
372 | pfit_control = (PFIT_ENABLE | VERT_AUTO_SCALE | | |
373 | HORIZ_AUTO_SCALE | VERT_INTERP_BILINEAR | | |
374 | HORIZ_INTERP_BILINEAR); | |
375 | else | |
376 | pfit_control = 0; | |
377 | ||
378 | if (dev_priv->lvds_dither) | |
379 | pfit_control |= PANEL_8TO6_DITHER_ENABLE; | |
380 | ||
381 | REG_WRITE(PFIT_CONTROL, pfit_control); | |
382 | } | |
383 | ||
384 | /** | |
385 | * Detect the LVDS connection. | |
386 | * | |
387 | * This always returns CONNECTOR_STATUS_CONNECTED. | |
388 | * This connector should only have | |
389 | * been set up if the LVDS was actually connected anyway. | |
390 | */ | |
391 | static enum drm_connector_status cdv_intel_lvds_detect( | |
392 | struct drm_connector *connector, bool force) | |
393 | { | |
394 | return connector_status_connected; | |
395 | } | |
396 | ||
397 | /** | |
398 | * Return the list of DDC modes if available, or the BIOS fixed mode otherwise. | |
399 | */ | |
400 | static int cdv_intel_lvds_get_modes(struct drm_connector *connector) | |
401 | { | |
402 | struct drm_device *dev = connector->dev; | |
a12d6a07 PJ |
403 | struct drm_psb_private *dev_priv = dev->dev_private; |
404 | struct psb_intel_encoder *psb_intel_encoder = | |
405 | psb_intel_attached_encoder(connector); | |
406 | struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev; | |
6a227d5f AC |
407 | int ret; |
408 | ||
a12d6a07 | 409 | ret = psb_intel_ddc_get_modes(connector, &psb_intel_encoder->i2c_bus->adapter); |
6a227d5f AC |
410 | |
411 | if (ret) | |
412 | return ret; | |
413 | ||
414 | /* Didn't get an EDID, so | |
415 | * Set wide sync ranges so we get all modes | |
416 | * handed to valid_mode for checking | |
417 | */ | |
418 | connector->display_info.min_vfreq = 0; | |
419 | connector->display_info.max_vfreq = 200; | |
420 | connector->display_info.min_hfreq = 0; | |
421 | connector->display_info.max_hfreq = 200; | |
422 | if (mode_dev->panel_fixed_mode != NULL) { | |
423 | struct drm_display_mode *mode = | |
424 | drm_mode_duplicate(dev, mode_dev->panel_fixed_mode); | |
425 | drm_mode_probed_add(connector, mode); | |
426 | return 1; | |
427 | } | |
428 | ||
429 | return 0; | |
430 | } | |
431 | ||
432 | /** | |
433 | * cdv_intel_lvds_destroy - unregister and free LVDS structures | |
434 | * @connector: connector to free | |
435 | * | |
436 | * Unregister the DDC bus for this connector then free the driver private | |
437 | * structure. | |
438 | */ | |
439 | void cdv_intel_lvds_destroy(struct drm_connector *connector) | |
440 | { | |
a12d6a07 PJ |
441 | struct psb_intel_encoder *psb_intel_encoder = |
442 | psb_intel_attached_encoder(connector); | |
6a227d5f | 443 | |
a12d6a07 PJ |
444 | if (psb_intel_encoder->i2c_bus) |
445 | psb_intel_i2c_destroy(psb_intel_encoder->i2c_bus); | |
6a227d5f AC |
446 | drm_sysfs_connector_remove(connector); |
447 | drm_connector_cleanup(connector); | |
448 | kfree(connector); | |
449 | } | |
450 | ||
451 | int cdv_intel_lvds_set_property(struct drm_connector *connector, | |
452 | struct drm_property *property, | |
453 | uint64_t value) | |
454 | { | |
455 | struct drm_encoder *encoder = connector->encoder; | |
456 | ||
457 | if (!strcmp(property->name, "scaling mode") && encoder) { | |
458 | struct psb_intel_crtc *crtc = | |
459 | to_psb_intel_crtc(encoder->crtc); | |
460 | uint64_t curValue; | |
461 | ||
462 | if (!crtc) | |
463 | return -1; | |
464 | ||
465 | switch (value) { | |
466 | case DRM_MODE_SCALE_FULLSCREEN: | |
467 | break; | |
468 | case DRM_MODE_SCALE_NO_SCALE: | |
469 | break; | |
470 | case DRM_MODE_SCALE_ASPECT: | |
471 | break; | |
472 | default: | |
473 | return -1; | |
474 | } | |
475 | ||
476 | if (drm_connector_property_get_value(connector, | |
477 | property, | |
478 | &curValue)) | |
479 | return -1; | |
480 | ||
481 | if (curValue == value) | |
482 | return 0; | |
483 | ||
484 | if (drm_connector_property_set_value(connector, | |
485 | property, | |
486 | value)) | |
487 | return -1; | |
488 | ||
489 | if (crtc->saved_mode.hdisplay != 0 && | |
490 | crtc->saved_mode.vdisplay != 0) { | |
491 | if (!drm_crtc_helper_set_mode(encoder->crtc, | |
492 | &crtc->saved_mode, | |
493 | encoder->crtc->x, | |
494 | encoder->crtc->y, | |
495 | encoder->crtc->fb)) | |
496 | return -1; | |
497 | } | |
498 | } else if (!strcmp(property->name, "backlight") && encoder) { | |
499 | if (drm_connector_property_set_value(connector, | |
500 | property, | |
501 | value)) | |
502 | return -1; | |
503 | else { | |
504 | #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE | |
505 | struct drm_psb_private *dev_priv = | |
506 | encoder->dev->dev_private; | |
507 | struct backlight_device *bd = | |
508 | dev_priv->backlight_device; | |
509 | bd->props.brightness = value; | |
510 | backlight_update_status(bd); | |
511 | #endif | |
512 | } | |
513 | } else if (!strcmp(property->name, "DPMS") && encoder) { | |
514 | struct drm_encoder_helper_funcs *helpers = | |
515 | encoder->helper_private; | |
516 | helpers->dpms(encoder, value); | |
517 | } | |
518 | return 0; | |
519 | } | |
520 | ||
521 | static const struct drm_encoder_helper_funcs | |
522 | cdv_intel_lvds_helper_funcs = { | |
523 | .dpms = cdv_intel_lvds_encoder_dpms, | |
524 | .mode_fixup = cdv_intel_lvds_mode_fixup, | |
525 | .prepare = cdv_intel_lvds_prepare, | |
526 | .mode_set = cdv_intel_lvds_mode_set, | |
527 | .commit = cdv_intel_lvds_commit, | |
528 | }; | |
529 | ||
530 | static const struct drm_connector_helper_funcs | |
531 | cdv_intel_lvds_connector_helper_funcs = { | |
532 | .get_modes = cdv_intel_lvds_get_modes, | |
533 | .mode_valid = cdv_intel_lvds_mode_valid, | |
534 | .best_encoder = psb_intel_best_encoder, | |
535 | }; | |
536 | ||
537 | static const struct drm_connector_funcs cdv_intel_lvds_connector_funcs = { | |
538 | .dpms = drm_helper_connector_dpms, | |
539 | .save = cdv_intel_lvds_save, | |
540 | .restore = cdv_intel_lvds_restore, | |
541 | .detect = cdv_intel_lvds_detect, | |
542 | .fill_modes = drm_helper_probe_single_connector_modes, | |
543 | .set_property = cdv_intel_lvds_set_property, | |
544 | .destroy = cdv_intel_lvds_destroy, | |
545 | }; | |
546 | ||
547 | ||
548 | static void cdv_intel_lvds_enc_destroy(struct drm_encoder *encoder) | |
549 | { | |
550 | drm_encoder_cleanup(encoder); | |
551 | } | |
552 | ||
553 | const struct drm_encoder_funcs cdv_intel_lvds_enc_funcs = { | |
554 | .destroy = cdv_intel_lvds_enc_destroy, | |
555 | }; | |
556 | ||
557 | /** | |
558 | * cdv_intel_lvds_init - setup LVDS connectors on this device | |
559 | * @dev: drm device | |
560 | * | |
561 | * Create the connector, register the LVDS DDC bus, and try to figure out what | |
562 | * modes we can display on the LVDS panel (if present). | |
563 | */ | |
564 | void cdv_intel_lvds_init(struct drm_device *dev, | |
565 | struct psb_intel_mode_device *mode_dev) | |
566 | { | |
a12d6a07 PJ |
567 | struct psb_intel_encoder *psb_intel_encoder; |
568 | struct psb_intel_connector *psb_intel_connector; | |
6a227d5f AC |
569 | struct cdv_intel_lvds_priv *lvds_priv; |
570 | struct drm_connector *connector; | |
571 | struct drm_encoder *encoder; | |
572 | struct drm_display_mode *scan; | |
573 | struct drm_crtc *crtc; | |
574 | struct drm_psb_private *dev_priv = dev->dev_private; | |
575 | u32 lvds; | |
576 | int pipe; | |
577 | ||
a12d6a07 PJ |
578 | psb_intel_encoder = kzalloc(sizeof(struct psb_intel_encoder), |
579 | GFP_KERNEL); | |
580 | if (!psb_intel_encoder) | |
6a227d5f AC |
581 | return; |
582 | ||
a12d6a07 PJ |
583 | psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), |
584 | GFP_KERNEL); | |
585 | if (!psb_intel_connector) | |
586 | goto failed_connector; | |
6a227d5f | 587 | |
a12d6a07 PJ |
588 | lvds_priv = kzalloc(sizeof(struct cdv_intel_lvds_priv), GFP_KERNEL); |
589 | if (!lvds_priv) | |
590 | goto failed_lvds_priv; | |
6a227d5f | 591 | |
a12d6a07 | 592 | psb_intel_encoder->dev_priv = lvds_priv; |
6a227d5f | 593 | |
a12d6a07 PJ |
594 | connector = &psb_intel_connector->base; |
595 | encoder = &psb_intel_encoder->base; | |
6a227d5f | 596 | |
a12d6a07 PJ |
597 | |
598 | drm_connector_init(dev, connector, | |
6a227d5f AC |
599 | &cdv_intel_lvds_connector_funcs, |
600 | DRM_MODE_CONNECTOR_LVDS); | |
601 | ||
a12d6a07 | 602 | drm_encoder_init(dev, encoder, |
6a227d5f AC |
603 | &cdv_intel_lvds_enc_funcs, |
604 | DRM_MODE_ENCODER_LVDS); | |
605 | ||
606 | ||
a12d6a07 PJ |
607 | psb_intel_connector_attach_encoder(psb_intel_connector, |
608 | psb_intel_encoder); | |
609 | psb_intel_encoder->type = INTEL_OUTPUT_LVDS; | |
6a227d5f AC |
610 | |
611 | drm_encoder_helper_add(encoder, &cdv_intel_lvds_helper_funcs); | |
612 | drm_connector_helper_add(connector, | |
613 | &cdv_intel_lvds_connector_helper_funcs); | |
614 | connector->display_info.subpixel_order = SubPixelHorizontalRGB; | |
615 | connector->interlace_allowed = false; | |
616 | connector->doublescan_allowed = false; | |
617 | ||
618 | /*Attach connector properties*/ | |
619 | drm_connector_attach_property(connector, | |
620 | dev->mode_config.scaling_mode_property, | |
621 | DRM_MODE_SCALE_FULLSCREEN); | |
622 | drm_connector_attach_property(connector, | |
623 | dev_priv->backlight_property, | |
624 | BRIGHTNESS_MAX_LEVEL); | |
625 | ||
626 | /** | |
627 | * Set up I2C bus | |
628 | * FIXME: distroy i2c_bus when exit | |
629 | */ | |
a12d6a07 | 630 | psb_intel_encoder->i2c_bus = psb_intel_i2c_create(dev, |
6a227d5f AC |
631 | GPIOB, |
632 | "LVDSBLC_B"); | |
a12d6a07 | 633 | if (!psb_intel_encoder->i2c_bus) { |
6a227d5f AC |
634 | dev_printk(KERN_ERR, |
635 | &dev->pdev->dev, "I2C bus registration failed.\n"); | |
636 | goto failed_blc_i2c; | |
637 | } | |
a12d6a07 PJ |
638 | psb_intel_encoder->i2c_bus->slave_addr = 0x2C; |
639 | dev_priv->lvds_i2c_bus = psb_intel_encoder->i2c_bus; | |
6a227d5f AC |
640 | |
641 | /* | |
642 | * LVDS discovery: | |
643 | * 1) check for EDID on DDC | |
644 | * 2) check for VBT data | |
645 | * 3) check to see if LVDS is already on | |
646 | * if none of the above, no panel | |
647 | * 4) make sure lid is open | |
648 | * if closed, act like it's not there for now | |
649 | */ | |
650 | ||
651 | /* Set up the DDC bus. */ | |
a12d6a07 | 652 | psb_intel_encoder->ddc_bus = psb_intel_i2c_create(dev, |
6a227d5f AC |
653 | GPIOC, |
654 | "LVDSDDC_C"); | |
a12d6a07 | 655 | if (!psb_intel_encoder->ddc_bus) { |
6a227d5f AC |
656 | dev_printk(KERN_ERR, &dev->pdev->dev, |
657 | "DDC bus registration " "failed.\n"); | |
658 | goto failed_ddc; | |
659 | } | |
660 | ||
661 | /* | |
662 | * Attempt to get the fixed panel mode from DDC. Assume that the | |
663 | * preferred mode is the right one. | |
664 | */ | |
a12d6a07 PJ |
665 | psb_intel_ddc_get_modes(connector, |
666 | &psb_intel_encoder->ddc_bus->adapter); | |
6a227d5f AC |
667 | list_for_each_entry(scan, &connector->probed_modes, head) { |
668 | if (scan->type & DRM_MODE_TYPE_PREFERRED) { | |
669 | mode_dev->panel_fixed_mode = | |
670 | drm_mode_duplicate(dev, scan); | |
671 | goto out; /* FIXME: check for quirks */ | |
672 | } | |
673 | } | |
674 | ||
675 | /* Failed to get EDID, what about VBT? do we need this?*/ | |
676 | if (dev_priv->lfp_lvds_vbt_mode) { | |
677 | mode_dev->panel_fixed_mode = | |
678 | drm_mode_duplicate(dev, dev_priv->lfp_lvds_vbt_mode); | |
679 | if (mode_dev->panel_fixed_mode) { | |
680 | mode_dev->panel_fixed_mode->type |= | |
681 | DRM_MODE_TYPE_PREFERRED; | |
682 | goto out; /* FIXME: check for quirks */ | |
683 | } | |
684 | } | |
685 | /* | |
686 | * If we didn't get EDID, try checking if the panel is already turned | |
687 | * on. If so, assume that whatever is currently programmed is the | |
688 | * correct mode. | |
689 | */ | |
690 | lvds = REG_READ(LVDS); | |
691 | pipe = (lvds & LVDS_PIPEB_SELECT) ? 1 : 0; | |
692 | crtc = psb_intel_get_crtc_from_pipe(dev, pipe); | |
693 | ||
694 | if (crtc && (lvds & LVDS_PORT_EN)) { | |
695 | mode_dev->panel_fixed_mode = | |
696 | cdv_intel_crtc_mode_get(dev, crtc); | |
697 | if (mode_dev->panel_fixed_mode) { | |
698 | mode_dev->panel_fixed_mode->type |= | |
699 | DRM_MODE_TYPE_PREFERRED; | |
700 | goto out; /* FIXME: check for quirks */ | |
701 | } | |
702 | } | |
703 | ||
704 | /* If we still don't have a mode after all that, give up. */ | |
705 | if (!mode_dev->panel_fixed_mode) { | |
706 | DRM_DEBUG | |
707 | ("Found no modes on the lvds, ignoring the LVDS\n"); | |
708 | goto failed_find; | |
709 | } | |
710 | ||
711 | out: | |
712 | drm_sysfs_connector_add(connector); | |
713 | return; | |
714 | ||
715 | failed_find: | |
716 | printk(KERN_ERR "Failed find\n"); | |
a12d6a07 PJ |
717 | if (psb_intel_encoder->ddc_bus) |
718 | psb_intel_i2c_destroy(psb_intel_encoder->ddc_bus); | |
6a227d5f AC |
719 | failed_ddc: |
720 | printk(KERN_ERR "Failed DDC\n"); | |
a12d6a07 PJ |
721 | if (psb_intel_encoder->i2c_bus) |
722 | psb_intel_i2c_destroy(psb_intel_encoder->i2c_bus); | |
6a227d5f AC |
723 | failed_blc_i2c: |
724 | printk(KERN_ERR "Failed BLC\n"); | |
725 | drm_encoder_cleanup(encoder); | |
726 | drm_connector_cleanup(connector); | |
a12d6a07 PJ |
727 | kfree(lvds_priv); |
728 | failed_lvds_priv: | |
729 | kfree(psb_intel_connector); | |
730 | failed_connector: | |
731 | kfree(psb_intel_encoder); | |
6a227d5f | 732 | } |