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