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