?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gma500: Fix dependencies
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / gma500 / mdfld_dsi_output.c
blobe911ef2431d136aaadad29f506ed2e002201e269
1 /*
2 * Copyright © 2010 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * jim liu <jim.liu@intel.com>
25 * Jackie Li<yaodong.li@intel.com>
26 */
27
28 #include "mdfld_dsi_output.h"
29 #include "mdfld_dsi_dbi.h"
30 #include "mdfld_dsi_dpi.h"
31 #include "mdfld_output.h"
32 #include <asm/intel_scu_ipc.h>
33 #include "mdfld_dsi_pkg_sender.h"
34 #include <linux/pm_runtime.h>
35
36 #define MDFLD_DSI_BRIGHTNESS_MAX_LEVEL 100
37
38 /* get the CABC LABC from command line. */
39 static int CABC_control = 1;
40 static int LABC_control = 1;
41
42 #ifdef MODULE
43 module_param (CABC_control, int, 0644);
44 module_param (LABC_control, int, 0644);
45 #else
46 static int __init parse_CABC_control(char *arg)
47 {
48 /* CABC control can be passed in as a cmdline parameter */
49 /* to enable this feature add CABC=1 to cmdline */
50 /* to disable this feature add CABC=0 to cmdline */
51 if (!arg)
52 return -EINVAL;
53
54 if (!strcasecmp(arg, "0"))
55 CABC_control = 0;
56 else if (!strcasecmp (arg, "1"))
57 CABC_control = 1;
58
59 return 0;
60 }
61 early_param ("CABC", parse_CABC_control);
62
63 static int __init parse_LABC_control(char *arg)
64 {
65 /* LABC control can be passed in as a cmdline parameter */
66 /* to enable this feature add LABC=1 to cmdline */
67 /* to disable this feature add LABC=0 to cmdline */
68 if (!arg)
69 return -EINVAL;
70
71 if (!strcasecmp(arg, "0"))
72 LABC_control = 0;
73 else if (!strcasecmp (arg, "1"))
74 LABC_control = 1;
75
76 return 0;
77 }
78 early_param ("LABC", parse_LABC_control);
79 #endif
80
81 /**
82 * make these MCS command global
83 * we don't need 'movl' everytime we send them.
84 * FIXME: these datas were provided by OEM, we should get them from GCT.
85 **/
86 static u32 mdfld_dbi_mcs_hysteresis[] = {
87 0x42000f57, 0x8c006400, 0xff00bf00, 0xffffffff,
88 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
89 0x38000aff, 0x82005000, 0xff00ab00, 0xffffffff,
90 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
91 0x000000ff,
92 };
93
94 static u32 mdfld_dbi_mcs_display_profile[] = {
95 0x50281450, 0x0000c882, 0x00000000, 0x00000000,
96 0x00000000,
97 };
98
99 static u32 mdfld_dbi_mcs_kbbc_profile[] = {
100 0x00ffcc60, 0x00000000, 0x00000000, 0x00000000,
101 };
102
103 static u32 mdfld_dbi_mcs_gamma_profile[] = {
104 0x81111158, 0x88888888, 0x88888888,
105 };
106
107 /*
108 * write hysteresis values.
109 */
110 static void mdfld_dsi_write_hysteresis (struct mdfld_dsi_config * dsi_config, int pipe)
111 {
112 struct mdfld_dsi_pkg_sender * sender = mdfld_dsi_get_pkg_sender(dsi_config);
113
114 if(!sender) {
115 WARN_ON(1);
116 return;
117 }
118 mdfld_dsi_send_mcs_long_hs(sender,
119 mdfld_dbi_mcs_hysteresis,
120 17,
121 MDFLD_DSI_SEND_PACKAGE);
122 }
123
124 /*
125 * write display profile values.
126 */
127 static void mdfld_dsi_write_display_profile (struct mdfld_dsi_config * dsi_config, int pipe)
128 {
129 struct mdfld_dsi_pkg_sender * sender = mdfld_dsi_get_pkg_sender(dsi_config);
130
131 if(!sender) {
132 WARN_ON(1);
133 return;
134 }
135 mdfld_dsi_send_mcs_long_hs(sender,
136 mdfld_dbi_mcs_display_profile,
137 5,
138 MDFLD_DSI_SEND_PACKAGE);
139 }
140
141 /*
142 * write KBBC profile values.
143 */
144 static void mdfld_dsi_write_kbbc_profile (struct mdfld_dsi_config * dsi_config, int pipe)
145 {
146 struct mdfld_dsi_pkg_sender * sender = mdfld_dsi_get_pkg_sender(dsi_config);
147
148 if(!sender) {
149 WARN_ON(1);
150 return;
151 }
152 mdfld_dsi_send_mcs_long_hs(sender,
153 mdfld_dbi_mcs_kbbc_profile,
154 4,
155 MDFLD_DSI_SEND_PACKAGE);
156 }
157
158 /**
159 * write gamma setting.
160 */
161 static void mdfld_dsi_write_gamma_setting (struct mdfld_dsi_config * dsi_config, int pipe)
162 {
163 struct mdfld_dsi_pkg_sender * sender = mdfld_dsi_get_pkg_sender(dsi_config);
164
165 if(!sender) {
166 WARN_ON(1);
167 return;
168 }
169 mdfld_dsi_send_mcs_long_hs(sender,
170 mdfld_dbi_mcs_gamma_profile,
171 3,
172 MDFLD_DSI_SEND_PACKAGE);
173 }
174
175 /**
176 * Check and see if the generic control or data buffer is empty and ready.
177 */
178 void mdfld_dsi_gen_fifo_ready (struct drm_device *dev, u32 gen_fifo_stat_reg, u32 fifo_stat)
179 {
180 u32 GEN_BF_time_out_count = 0;
181
182 /* Check MIPI Adatper command registers */
183 for (GEN_BF_time_out_count = 0; GEN_BF_time_out_count < GEN_FB_TIME_OUT; GEN_BF_time_out_count++)
184 {
185 if ((REG_READ(gen_fifo_stat_reg) & fifo_stat) == fifo_stat)
186 break;
187 udelay (100);
188 }
189
190 if (GEN_BF_time_out_count == GEN_FB_TIME_OUT)
191 dev_err(dev->dev,
192 "mdfld_dsi_gen_fifo_ready, Timeout. gen_fifo_stat_reg = 0x%x. \n",
193 gen_fifo_stat_reg);
194 }
195
196 /**
197 * Manage the DSI MIPI keyboard and display brightness.
198 * FIXME: this is exported to OSPM code. should work out an specific
199 * display interface to OSPM.
200 */
201 void mdfld_dsi_brightness_init (struct mdfld_dsi_config * dsi_config, int pipe)
202 {
203 struct mdfld_dsi_pkg_sender * sender = mdfld_dsi_get_pkg_sender(dsi_config);
204 struct drm_device * dev = sender->dev;
205 struct drm_psb_private * dev_priv = dev->dev_private;
206 u32 gen_ctrl_val;
207
208 if(!sender) {
209 WARN_ON(1);
210 return;
211 }
212 /* Set default display backlight value to 85% (0xd8)*/
213 mdfld_dsi_send_mcs_short_hs(sender,
214 write_display_brightness,
215 0xd8,
216 1,
217 MDFLD_DSI_SEND_PACKAGE);
218
219 /* Set minimum brightness setting of CABC function to 20% (0x33)*/
220 mdfld_dsi_send_mcs_short_hs(sender,
221 write_cabc_min_bright,
222 0x33,
223 1,
224 MDFLD_DSI_SEND_PACKAGE);
225
226 mdfld_dsi_write_hysteresis (dsi_config, pipe);
227 mdfld_dsi_write_display_profile (dsi_config, pipe);
228 mdfld_dsi_write_kbbc_profile (dsi_config, pipe);
229 mdfld_dsi_write_gamma_setting (dsi_config, pipe);
230
231 /* Enable backlight or/and LABC */
232 gen_ctrl_val = BRIGHT_CNTL_BLOCK_ON | DISPLAY_DIMMING_ON| BACKLIGHT_ON;
233 if (LABC_control == 1 || CABC_control == 1)
234 gen_ctrl_val |= DISPLAY_DIMMING_ON| DISPLAY_BRIGHTNESS_AUTO | GAMMA_AUTO;
235
236 if (LABC_control == 1)
237 gen_ctrl_val |= AMBIENT_LIGHT_SENSE_ON;
238
239 dev_priv->mipi_ctrl_display = gen_ctrl_val;
240
241 mdfld_dsi_send_mcs_short_hs(sender,
242 write_ctrl_display,
243 (u8)gen_ctrl_val,
244 1,
245 MDFLD_DSI_SEND_PACKAGE);
246
247 if (CABC_control == 0)
248 return;
249 mdfld_dsi_send_mcs_short_hs(sender,
250 write_ctrl_cabc,
251 UI_IMAGE,
252 1,
253 MDFLD_DSI_SEND_PACKAGE);
254 }
255
256 /**
257 * Manage the mipi display brightness.
258 * TODO: refine this interface later
259 */
260 void mdfld_dsi_brightness_control(struct drm_device *dev, int pipe, int level)
261 {
262 struct mdfld_dsi_pkg_sender *sender;
263 struct drm_psb_private *dev_priv;
264 struct mdfld_dsi_config *dsi_config;
265 u32 gen_ctrl_val = 0;
266 int p_type = TMD_VID;
267
268 if (!dev || (pipe != 0 && pipe != 2)) {
269 dev_err(dev->dev, "Invalid parameter\n");
270 return;
271 }
272
273 p_type = mdfld_get_panel_type(dev, 0);
274
275 dev_priv = dev->dev_private;
276
277 if(pipe)
278 dsi_config = dev_priv->dsi_configs[1];
279 else
280 dsi_config = dev_priv->dsi_configs[0];
281
282 sender = mdfld_dsi_get_pkg_sender(dsi_config);
283
284 if(!sender) {
285 WARN_ON(1);
286 return;
287 }
288
289 gen_ctrl_val = ((level * 0xff) / MDFLD_DSI_BRIGHTNESS_MAX_LEVEL) & 0xff;
290
291 dev_dbg(dev->dev, "pipe = %d, gen_ctrl_val = %d. \n", pipe, gen_ctrl_val);
292
293 if(p_type == TMD_VID || p_type == TMD_CMD){
294 /* Set display backlight value */
295 mdfld_dsi_send_mcs_short_hs(sender,
296 tmd_write_display_brightness,
297 (u8)gen_ctrl_val,
298 1,
299 MDFLD_DSI_SEND_PACKAGE);
300 } else {
301 /* Set display backlight value */
302 mdfld_dsi_send_mcs_short_hs(sender,
303 write_display_brightness,
304 (u8)gen_ctrl_val,
305 1,
306 MDFLD_DSI_SEND_PACKAGE);
307
308
309 /* Enable backlight control */
310 if (level == 0)
311 gen_ctrl_val = 0;
312 else
313 gen_ctrl_val = dev_priv->mipi_ctrl_display;
314
315 mdfld_dsi_send_mcs_short_hs(sender,
316 write_ctrl_display,
317 (u8)gen_ctrl_val,
318 1,
319 MDFLD_DSI_SEND_PACKAGE);
320 }
321 }
322
323 /*
324 * shut down DSI controller
325 */
326 void mdfld_dsi_controller_shutdown(struct mdfld_dsi_config * dsi_config, int pipe)
327 {
328 struct drm_device * dev;
329 u32 reg_offset = pipe ? MIPIC_REG_OFFSET : 0;
330 int retry = 100;
331
332 if (!dsi_config) {
333 WARN_ON(1);
334 return;
335 }
336
337 dev = dsi_config->dev;
338
339 if (!gma_power_begin(dev, true)) {
340 dev_err(dev->dev, "hw begin failed\n");
341 return;
342 }
343
344 if(!(REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) & DSI_DEVICE_READY))
345 goto shutdown_out;
346
347 /*send shut down package, clean packet send bit first*/
348 if(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT) {
349 REG_WRITE((MIPIA_INTR_STAT_REG + reg_offset),
350 (REG_READ(MIPIA_INTR_STAT_REG + reg_offset) | DSI_INTR_STATE_SPL_PKG_SENT));
351 }
352
353 /*send shut down package in HS*/
354 REG_WRITE((MIPIA_DPI_CONTROL_REG + reg_offset), DSI_DPI_CTRL_HS_SHUTDOWN);
355
356
357 /*
358 * make sure shut down is sent.
359 * FIXME: add max retry counter
360 */
361 while(!(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT)) {
362 retry--;
363
364 if(!retry) {
365 dev_err(dev->dev, "timeout\n");
366 break;
367 }
368 }
369
370 /*sleep 1 ms to ensure shutdown finished*/
371 msleep(100);
372
373 /*un-ready device*/
374 REG_WRITE((MIPIA_DEVICE_READY_REG + reg_offset),
375 (REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) & ~DSI_DEVICE_READY));
376
377 shutdown_out:
378 gma_power_end(dev);
379 }
380
381 void mdfld_dsi_controller_startup(struct mdfld_dsi_config * dsi_config, int pipe)
382 {
383 struct drm_device * dev;
384 u32 reg_offset = pipe ? MIPIC_REG_OFFSET : 0;
385 int retry = 100;
386
387
388 if (!dsi_config) {
389 WARN_ON(1);
390 return;
391 }
392
393 dev = dsi_config->dev;
394 dev_dbg(dev->dev, "starting up DSI controller on pipe %d...\n", pipe);
395
396 if (!gma_power_begin(dev, true)) {
397 dev_err(dev->dev, "hw begin failed\n");
398 return;
399 }
400
401 if((REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) & DSI_DEVICE_READY))
402 goto startup_out;
403
404 /*if config DPI, turn on DPI interface*/
405 if(dsi_config->type == MDFLD_DSI_ENCODER_DPI) {
406 if(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT) {
407 REG_WRITE((MIPIA_INTR_STAT_REG + reg_offset), DSI_INTR_STATE_SPL_PKG_SENT);
408 }
409
410 REG_WRITE((MIPIA_DPI_CONTROL_REG + reg_offset), DSI_DPI_CTRL_HS_TURN_ON);
411
412 /*
413 * make sure shut down is sent.
414 * FIXME: add max retry counter
415 */
416 while(!(REG_READ(MIPIA_INTR_STAT_REG + reg_offset) & DSI_INTR_STATE_SPL_PKG_SENT)) {
417 retry--;
418 if(!retry) {
419 dev_err(dev->dev, "timeout\n");
420 break;
421 }
422 }
423
424 msleep(100);
425 }
426
427 /*set device ready*/
428 REG_WRITE((MIPIA_DEVICE_READY_REG + reg_offset),
429 (REG_READ(MIPIA_DEVICE_READY_REG + reg_offset) | DSI_DEVICE_READY));
430
431 startup_out:
432 gma_power_end(dev);
433 }
434
435 /*
436 * NOTE: this function was used by OSPM.
437 * TODO: will be removed later, should work out display interfaces for OSPM
438 */
439 void mdfld_dsi_controller_init(struct mdfld_dsi_config * dsi_config, int pipe)
440 {
441 if(!dsi_config || ((pipe != 0) && (pipe != 2))) {
442 WARN_ON(1);
443 return;
444 }
445
446 if(dsi_config->type)
447 mdfld_dsi_dpi_controller_init(dsi_config, pipe);
448 else
449 mdfld_dsi_controller_dbi_init(dsi_config, pipe);
450 }
451
452 static void mdfld_dsi_connector_save(struct drm_connector * connector)
453 {
454 }
455
456 static void mdfld_dsi_connector_restore(struct drm_connector * connector)
457 {
458 }
459
460 static enum drm_connector_status mdfld_dsi_connector_detect(struct drm_connector * connector, bool force)
461 {
462 return connector_status_connected;
463 }
464
465 static int mdfld_dsi_connector_set_property(struct drm_connector * connector,
466 struct drm_property * property,
467 uint64_t value)
468 {
469 struct drm_encoder * encoder = connector->encoder;
470 struct backlight_device * psb_bd;
471 struct drm_psb_private * dev_priv = encoder->dev->dev_private;
472
473 if (!strcmp(property->name, "scaling mode") && encoder) {
474 struct psb_intel_crtc * psb_crtc = to_psb_intel_crtc(encoder->crtc);
475 bool bTransitionFromToCentered;
476 uint64_t curValue;
477
478 if (!psb_crtc)
479 goto set_prop_error;
480
481 switch (value) {
482 case DRM_MODE_SCALE_FULLSCREEN:
483 break;
484 case DRM_MODE_SCALE_NO_SCALE:
485 break;
486 case DRM_MODE_SCALE_ASPECT:
487 break;
488 default:
489 goto set_prop_error;
490 }
491
492 if (drm_connector_property_get_value(connector, property, &curValue))
493 goto set_prop_error;
494
495 if (curValue == value)
496 goto set_prop_done;
497
498 if (drm_connector_property_set_value(connector, property, value))
499 goto set_prop_error;
500
501 bTransitionFromToCentered = (curValue == DRM_MODE_SCALE_NO_SCALE) ||
502 (value == DRM_MODE_SCALE_NO_SCALE);
503
504 if (psb_crtc->saved_mode.hdisplay != 0 &&
505 psb_crtc->saved_mode.vdisplay != 0) {
506 if (bTransitionFromToCentered) {
507 if (!drm_crtc_helper_set_mode(encoder->crtc, &psb_crtc->saved_mode,
508 encoder->crtc->x, encoder->crtc->y, encoder->crtc->fb))
509 goto set_prop_error;
510 } else {
511 struct drm_encoder_helper_funcs *pEncHFuncs = encoder->helper_private;
512 pEncHFuncs->mode_set(encoder, &psb_crtc->saved_mode,
513 &psb_crtc->saved_adjusted_mode);
514 }
515 }
516 #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
517 } else if (!strcmp(property->name, "backlight") && encoder) {
518 dev_dbg(encoder->dev->dev, "backlight level = %d\n", (int)value);
519 if (drm_connector_property_set_value(connector, property, value))
520 goto set_prop_error;
521 else {
522 dev_dbg(encoder->dev->dev,
523 "set brightness to %d", (int)value);
524 psb_bd = dev_priv->backlight_device;
525 if (psb_bd) {
526 psb_bd->props.brightness = value;
527 backlight_update_status(psb_bd);
528 }
529 }
530 #endif
531 }
532 set_prop_done:
533 return 0;
534 set_prop_error:
535 return -1;
536 }
537
538 static void mdfld_dsi_connector_destroy(struct drm_connector *connector)
539 {
540 struct psb_intel_output * psb_output = to_psb_intel_output(connector);
541 struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
542 struct mdfld_dsi_pkg_sender * sender;
543
544 if(!dsi_connector)
545 return;
546
547 drm_sysfs_connector_remove(connector);
548 drm_connector_cleanup(connector);
549
550 sender = dsi_connector->pkg_sender;
551
552 mdfld_dsi_pkg_sender_destroy(sender);
553
554 kfree(dsi_connector);
555 }
556
557 static int mdfld_dsi_connector_get_modes(struct drm_connector * connector)
558 {
559 struct psb_intel_output * psb_output = to_psb_intel_output(connector);
560 struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
561 struct mdfld_dsi_config * dsi_config = mdfld_dsi_get_config(dsi_connector);
562 struct drm_display_mode * fixed_mode = dsi_config->fixed_mode;
563 struct drm_display_mode * dup_mode = NULL;
564 struct drm_device * dev = connector->dev;
565
566 connector->display_info.min_vfreq = 0;
567 connector->display_info.max_vfreq = 200;
568 connector->display_info.min_hfreq = 0;
569 connector->display_info.max_hfreq = 200;
570
571 if(fixed_mode) {
572 dev_dbg(dev->dev, "fixed_mode %dx%d\n",
573 fixed_mode->hdisplay, fixed_mode->vdisplay);
574
575 dup_mode = drm_mode_duplicate(dev, fixed_mode);
576 drm_mode_probed_add(connector, dup_mode);
577 return 1;
578 }
579 dev_err(dev->dev, "Didn't get any modes!\n");
580 return 0;
581 }
582
583 static int mdfld_dsi_connector_mode_valid(struct drm_connector * connector, struct drm_display_mode * mode)
584 {
585 struct psb_intel_output * psb_output = to_psb_intel_output(connector);
586 struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
587 struct mdfld_dsi_config * dsi_config = mdfld_dsi_get_config(dsi_connector);
588 struct drm_display_mode * fixed_mode = dsi_config->fixed_mode;
589
590 dev_dbg(connector->dev->dev, "mode %p, fixed mode %p\n",
591 mode, fixed_mode);
592
593 if(mode->flags & DRM_MODE_FLAG_DBLSCAN)
594 return MODE_NO_DBLESCAN;
595
596 if(mode->flags & DRM_MODE_FLAG_INTERLACE)
597 return MODE_NO_INTERLACE;
598
599 /**
600 * FIXME: current DC has no fitting unit, reject any mode setting request
601 * will figure out a way to do up-scaling(pannel fitting) later.
602 **/
603 if(fixed_mode) {
604 if(mode->hdisplay != fixed_mode->hdisplay)
605 return MODE_PANEL;
606
607 if(mode->vdisplay != fixed_mode->vdisplay)
608 return MODE_PANEL;
609 }
610 dev_dbg(connector->dev->dev, "mode ok\n");
611
612 return MODE_OK;
613 }
614
615 static void mdfld_dsi_connector_dpms(struct drm_connector *connector, int mode)
616 {
617 #ifdef CONFIG_PM_RUNTIME
618 struct drm_device * dev = connector->dev;
619 struct drm_psb_private * dev_priv = dev->dev_private;
620 bool panel_on, panel_on2;
621 #endif
622 /* First, execute DPMS */
623 drm_helper_connector_dpms(connector, mode);
624
625 #ifdef CONFIG_PM_RUNTIME
626 if(mdfld_panel_dpi(dev)) {
627 /* DPI panel */
628 panel_on = dev_priv->dpi_panel_on;
629 panel_on2 = dev_priv->dpi_panel_on2;
630 } else {
631 /* DBI panel */
632 panel_on = dev_priv->dbi_panel_on;
633 panel_on2 = dev_priv->dbi_panel_on2;
634 }
635
636 /* Then check all display panels + monitors status */
637 if(!panel_on && !panel_on2 && !(REG_READ(HDMIB_CONTROL)
638 & HDMIB_PORT_EN)) {
639 /*request rpm idle*/
640 if(dev_priv->rpm_enabled)
641 pm_request_idle(&dev->pdev->dev);
642 }
643 /*
644 * if rpm wasn't enabled yet, try to allow it
645 * FIXME: won't enable rpm for DPI since DPI
646 * CRTC setting is a little messy now.
647 * Enable it later!
648 */
649 #if 0
650 if(!dev_priv->rpm_enabled && !mdfld_panel_dpi(dev))
651 ospm_runtime_pm_allow(dev);
652 #endif
653 #endif
654 }
655
656 static struct drm_encoder * mdfld_dsi_connector_best_encoder(
657 struct drm_connector * connector)
658 {
659 struct psb_intel_output * psb_output = to_psb_intel_output(connector);
660 struct mdfld_dsi_connector * dsi_connector = MDFLD_DSI_CONNECTOR(psb_output);
661 struct mdfld_dsi_config * dsi_config = mdfld_dsi_get_config(dsi_connector);
662 struct mdfld_dsi_encoder * encoder = NULL;
663
664 if(dsi_config->type == MDFLD_DSI_ENCODER_DBI)
665 encoder = dsi_config->encoders[MDFLD_DSI_ENCODER_DBI];
666 else if (dsi_config->type == MDFLD_DSI_ENCODER_DPI)
667 encoder = dsi_config->encoders[MDFLD_DSI_ENCODER_DPI];
668
669 dev_dbg(connector->dev->dev, "get encoder %p\n", encoder);
670
671 if(!encoder) {
672 dev_err(connector->dev->dev,
673 "Invalid encoder for type %d\n", dsi_config->type);
674 return NULL;
675 }
676 dsi_config->encoder = encoder;
677 return &encoder->base;
678 }
679
680 /* DSI connector funcs */
681 static const struct drm_connector_funcs mdfld_dsi_connector_funcs = {
682 .dpms = /*drm_helper_connector_dpms*/mdfld_dsi_connector_dpms,
683 .save = mdfld_dsi_connector_save,
684 .restore = mdfld_dsi_connector_restore,
685 .detect = mdfld_dsi_connector_detect,
686 .fill_modes = drm_helper_probe_single_connector_modes,
687 .set_property = mdfld_dsi_connector_set_property,
688 .destroy = mdfld_dsi_connector_destroy,
689 };
690
691 /* DSI connector helper funcs */
692 static const struct drm_connector_helper_funcs mdfld_dsi_connector_helper_funcs = {
693 .get_modes = mdfld_dsi_connector_get_modes,
694 .mode_valid = mdfld_dsi_connector_mode_valid,
695 .best_encoder = mdfld_dsi_connector_best_encoder,
696 };
697
698 static int mdfld_dsi_get_default_config(struct drm_device * dev,
699 struct mdfld_dsi_config * config, int pipe)
700 {
701 if(!dev || !config) {
702 WARN_ON(1);
703 return -EINVAL;
704 }
705
706 config->bpp = 24;
707 config->type = mdfld_panel_dpi(dev);
708 config->lane_count = 2;
709 config->channel_num = 0;
710 /*NOTE: video mode is ignored when type is MDFLD_DSI_ENCODER_DBI*/
711 if (mdfld_get_panel_type(dev, pipe) == TMD_VID) {
712 config->video_mode = MDFLD_DSI_VIDEO_NON_BURST_MODE_SYNC_PULSE;
713 } else {
714 config->video_mode = MDFLD_DSI_VIDEO_BURST_MODE;
715 }
716
717 return 0;
718 }
719
720 /*
721 * Returns the panel fixed mode from configuration.
722 */
723 struct drm_display_mode *
724 mdfld_dsi_get_configuration_mode(struct mdfld_dsi_config * dsi_config, int pipe)
725 {
726 struct drm_device *dev = dsi_config->dev;
727 struct drm_display_mode *mode;
728 struct drm_psb_private *dev_priv = dev->dev_private;
729 struct mrst_timing_info *ti = &dev_priv->gct_data.DTD;
730 bool use_gct = false;
731
732 mode = kzalloc(sizeof(*mode), GFP_KERNEL);
733 if (!mode) {
734 dev_err(dev->dev, "Out of memory for mode\n");
735 return NULL;
736 }
737 if (use_gct) {
738 dev_dbg(dev->dev, "gct find MIPI panel.\n");
739
740 mode->hdisplay = (ti->hactive_hi << 8) | ti->hactive_lo;
741 mode->vdisplay = (ti->vactive_hi << 8) | ti->vactive_lo;
742 mode->hsync_start = mode->hdisplay + \
743 ((ti->hsync_offset_hi << 8) | \
744 ti->hsync_offset_lo);
745 mode->hsync_end = mode->hsync_start + \
746 ((ti->hsync_pulse_width_hi << 8) | \
747 ti->hsync_pulse_width_lo);
748 mode->htotal = mode->hdisplay + ((ti->hblank_hi << 8) | \
749 ti->hblank_lo);
750 mode->vsync_start = \
751 mode->vdisplay + ((ti->vsync_offset_hi << 8) | \
752 ti->vsync_offset_lo);
753 mode->vsync_end = \
754 mode->vsync_start + ((ti->vsync_pulse_width_hi << 8) | \
755 ti->vsync_pulse_width_lo);
756 mode->vtotal = mode->vdisplay + \
757 ((ti->vblank_hi << 8) | ti->vblank_lo);
758 mode->clock = ti->pixel_clock * 10;
759
760 dev_dbg(dev->dev, "hdisplay is %d\n", mode->hdisplay);
761 dev_dbg(dev->dev, "vdisplay is %d\n", mode->vdisplay);
762 dev_dbg(dev->dev, "HSS is %d\n", mode->hsync_start);
763 dev_dbg(dev->dev, "HSE is %d\n", mode->hsync_end);
764 dev_dbg(dev->dev, "htotal is %d\n", mode->htotal);
765 dev_dbg(dev->dev, "VSS is %d\n", mode->vsync_start);
766 dev_dbg(dev->dev, "VSE is %d\n", mode->vsync_end);
767 dev_dbg(dev->dev, "vtotal is %d\n", mode->vtotal);
768 dev_dbg(dev->dev, "clock is %d\n", mode->clock);
769 } else {
770 if(dsi_config->type == MDFLD_DSI_ENCODER_DPI) {
771 if (mdfld_get_panel_type(dev, pipe) == TMD_VID) {
772 mode->hdisplay = 480;
773 mode->vdisplay = 854;
774 mode->hsync_start = 487;
775 mode->hsync_end = 490;
776 mode->htotal = 499;
777 mode->vsync_start = 861;
778 mode->vsync_end = 865;
779 mode->vtotal = 873;
780 mode->clock = 33264;
781 } else {
782 mode->hdisplay = 864;
783 mode->vdisplay = 480;
784 mode->hsync_start = 873;
785 mode->hsync_end = 876;
786 mode->htotal = 887;
787 mode->vsync_start = 487;
788 mode->vsync_end = 490;
789 mode->vtotal = 499;
790 mode->clock = 33264;
791 }
792 } else if(dsi_config->type == MDFLD_DSI_ENCODER_DBI) {
793 mode->hdisplay = 864;
794 mode->vdisplay = 480;
795 mode->hsync_start = 872;
796 mode->hsync_end = 876;
797 mode->htotal = 884;
798 mode->vsync_start = 482;
799 mode->vsync_end = 494;
800 mode->vtotal = 486;
801 mode->clock = 25777;
802
803 }
804 }
805
806 drm_mode_set_name(mode);
807 drm_mode_set_crtcinfo(mode, 0);
808
809 mode->type |= DRM_MODE_TYPE_PREFERRED;
810
811 return mode;
812 }
813
814 /*
815 * MIPI output init
816 * @dev drm device
817 * @pipe pipe number. 0 or 2
818 * @config
819 *
820 * Do the initialization of a MIPI output, including create DRM mode objects
821 * initialization of DSI output on @pipe
822 */
823 void mdfld_dsi_output_init(struct drm_device * dev,
824 int pipe,
825 struct mdfld_dsi_config * config,
826 struct panel_funcs* p_cmd_funcs,
827 struct panel_funcs* p_vid_funcs)
828 {
829 struct mdfld_dsi_config * dsi_config;
830 struct mdfld_dsi_connector * dsi_connector;
831 struct psb_intel_output * psb_output;
832 struct drm_connector * connector;
833 struct mdfld_dsi_encoder * encoder;
834 struct drm_psb_private * dev_priv = dev->dev_private;
835 struct panel_info dsi_panel_info;
836 u32 width_mm, height_mm;
837
838 dev_dbg(dev->dev, "init DSI output on pipe %d\n", pipe);
839
840 if(!dev || ((pipe != 0) && (pipe != 2))) {
841 WARN_ON(1);
842 return;
843 }
844
845 /*create a new connetor*/
846 dsi_connector = kzalloc(sizeof(struct mdfld_dsi_connector), GFP_KERNEL);
847 if(!dsi_connector) {
848 DRM_ERROR("No memory");
849 return;
850 }
851
852 dsi_connector->pipe = pipe;
853
854 /*set DSI config*/
855 if(config) {
856 dsi_config = config;
857 } else {
858 dsi_config = kzalloc(sizeof(struct mdfld_dsi_config), GFP_KERNEL);
859 if(!dsi_config) {
860 dev_err(dev->dev,
861 "cannot allocate memory for DSI config\n");
862 goto dsi_init_err0;
863 }
864
865 mdfld_dsi_get_default_config(dev, dsi_config, pipe);
866 }
867
868 dsi_connector->private = dsi_config;
869
870 dsi_config->changed = 1;
871 dsi_config->dev = dev;
872
873 /*init fixed mode basing on DSI config type*/
874 if(dsi_config->type == MDFLD_DSI_ENCODER_DBI) {
875 dsi_config->fixed_mode = p_cmd_funcs->get_config_mode(dev);
876 if(p_cmd_funcs->get_panel_info(dev, pipe, &dsi_panel_info))
877 goto dsi_init_err0;
878 } else if(dsi_config->type == MDFLD_DSI_ENCODER_DPI) {
879 dsi_config->fixed_mode = p_vid_funcs->get_config_mode(dev);
880 if(p_vid_funcs->get_panel_info(dev, pipe, &dsi_panel_info))
881 goto dsi_init_err0;
882 }
883
884 width_mm = dsi_panel_info.width_mm;
885 height_mm = dsi_panel_info.height_mm;
886
887 dsi_config->mode = dsi_config->fixed_mode;
888 dsi_config->connector = dsi_connector;
889
890 if(!dsi_config->fixed_mode) {
891 dev_err(dev->dev, "No pannel fixed mode was found\n");
892 goto dsi_init_err0;
893 }
894
895 if(pipe && dev_priv->dsi_configs[0]) {
896 dsi_config->dvr_ic_inited = 0;
897 dev_priv->dsi_configs[1] = dsi_config;
898 } else if(pipe == 0) {
899 dsi_config->dvr_ic_inited = 1;
900 dev_priv->dsi_configs[0] = dsi_config;
901 } else {
902 dev_err(dev->dev, "Trying to init MIPI1 before MIPI0\n");
903 goto dsi_init_err0;
904 }
905
906 /*init drm connector object*/
907 psb_output = &dsi_connector->base;
908
909 psb_output->type = (pipe == 0) ? INTEL_OUTPUT_MIPI : INTEL_OUTPUT_MIPI2;
910
911 connector = &psb_output->base;
912 drm_connector_init(dev, connector, &mdfld_dsi_connector_funcs, DRM_MODE_CONNECTOR_MIPI);
913 drm_connector_helper_add(connector, &mdfld_dsi_connector_helper_funcs);
914
915 connector->display_info.subpixel_order = SubPixelHorizontalRGB;
916 connector->display_info.width_mm = width_mm;
917 connector->display_info.height_mm = height_mm;
918 connector->interlace_allowed = false;
919 connector->doublescan_allowed = false;
920
921 /*attach properties*/
922 drm_connector_attach_property(connector, dev->mode_config.scaling_mode_property, DRM_MODE_SCALE_FULLSCREEN);
923 drm_connector_attach_property(connector, dev_priv->backlight_property, MDFLD_DSI_BRIGHTNESS_MAX_LEVEL);
924
925 /*init DBI & DPI encoders*/
926 if(p_cmd_funcs) {
927 encoder = mdfld_dsi_dbi_init(dev, dsi_connector, p_cmd_funcs);
928 if(!encoder) {
929 dev_err(dev->dev, "Create DBI encoder failed\n");
930 goto dsi_init_err1;
931 }
932 encoder->private = dsi_config;
933 dsi_config->encoders[MDFLD_DSI_ENCODER_DBI] = encoder;
934 if(pipe == 2)
935 dev_priv->encoder2 = encoder;
936
937 if(pipe == 0)
938 dev_priv->encoder0 = encoder;
939
940 }
941
942 if(p_vid_funcs) {
943 encoder = mdfld_dsi_dpi_init(dev, dsi_connector, p_vid_funcs);
944 if(!encoder) {
945 dev_err(dev->dev, "Create DPI encoder failed\n");
946 goto dsi_init_err1;
947 }
948 encoder->private = dsi_config;
949 dsi_config->encoders[MDFLD_DSI_ENCODER_DPI] = encoder;
950
951 if(pipe == 2)
952 dev_priv->encoder2 = encoder;
953
954 if(pipe == 0)
955 dev_priv->encoder0 = encoder;
956 }
957
958 drm_sysfs_connector_add(connector);
959
960 /*init DSI package sender on this output*/
961 if(mdfld_dsi_pkg_sender_init(dsi_connector, pipe)) {
962 dev_err(dev->dev,
963 "Package Sender initialization failed on pipe %d\n",
964 pipe);
965 goto dsi_init_err2;
966 }
967
968 dev_dbg(dev->dev, "successfully\n");
969 return;
970
971 /*TODO: add code to destroy outputs on error*/
972 dsi_init_err2:
973 drm_sysfs_connector_remove(connector);
974 dsi_init_err1:
975 drm_connector_cleanup(connector);
976 kfree(dsi_config->fixed_mode);
977 kfree(dsi_config);
978 dsi_init_err0:
979 kfree(dsi_connector);
980 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree