0fb4ea5f597f33b4582c5bba373e8de0e1388af0
[linux-2.6.git] / arch / arm / mach-tegra / include / mach / dc.h
1 /*
2  * arch/arm/mach-tegra/include/mach/dc.h
3  *
4  * Copyright (C) 2010 Google, Inc.
5  *
6  * Author:
7  *      Erik Gilling <konkers@google.com>
8  *
9  * Copyright (c) 2010-2013, NVIDIA CORPORATION, All rights reserved.
10  *
11  * This software is licensed under the terms of the GNU General Public
12  * License version 2, as published by the Free Software Foundation, and
13  * may be copied, distributed, and modified under those terms.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  */
21
22 #ifndef __MACH_TEGRA_DC_H
23 #define __MACH_TEGRA_DC_H
24
25 #include <linux/pm.h>
26 #include <linux/types.h>
27 #include <linux/fb.h>
28 #include <drm/drm_fixed.h>
29
30 #define TEGRA_MAX_DC            2
31 #define DC_N_WINDOWS            3
32 #define DEFAULT_FPGA_FREQ_KHZ   160000
33
34
35 /* DSI pixel data format */
36 enum {
37         TEGRA_DSI_PIXEL_FORMAT_16BIT_P,
38         TEGRA_DSI_PIXEL_FORMAT_18BIT_P,
39         TEGRA_DSI_PIXEL_FORMAT_18BIT_NP,
40         TEGRA_DSI_PIXEL_FORMAT_24BIT_P,
41 };
42
43 /* DSI virtual channel number */
44 enum {
45         TEGRA_DSI_VIRTUAL_CHANNEL_0,
46         TEGRA_DSI_VIRTUAL_CHANNEL_1,
47         TEGRA_DSI_VIRTUAL_CHANNEL_2,
48         TEGRA_DSI_VIRTUAL_CHANNEL_3,
49 };
50
51 /* DSI transmit method for video data */
52 enum {
53         TEGRA_DSI_VIDEO_TYPE_VIDEO_MODE,
54         TEGRA_DSI_VIDEO_TYPE_COMMAND_MODE,
55 };
56
57 /* DSI HS clock mode */
58 enum {
59         TEGRA_DSI_VIDEO_CLOCK_CONTINUOUS,
60         TEGRA_DSI_VIDEO_CLOCK_TX_ONLY,
61 };
62
63 /* DSI burst mode setting in video mode. Each mode is assigned with a
64  * fixed value. The rationale behind this is to avoid change of these
65  * values, since the calculation of dsi clock depends on them. */
66 enum {
67         TEGRA_DSI_VIDEO_NONE_BURST_MODE = 0,
68         TEGRA_DSI_VIDEO_NONE_BURST_MODE_WITH_SYNC_END = 1,
69         TEGRA_DSI_VIDEO_BURST_MODE_LOWEST_SPEED = 2,
70         TEGRA_DSI_VIDEO_BURST_MODE_LOW_SPEED = 3,
71         TEGRA_DSI_VIDEO_BURST_MODE_MEDIUM_SPEED = 4,
72         TEGRA_DSI_VIDEO_BURST_MODE_FAST_SPEED = 5,
73         TEGRA_DSI_VIDEO_BURST_MODE_FASTEST_SPEED = 6,
74 };
75
76 enum {
77         TEGRA_DSI_GANGED_SYMMETRIC_LEFT_RIGHT = 1,
78         TEGRA_DSI_GANGED_SYMMETRIC_EVEN_ODD = 2,
79 };
80
81 enum {
82         TEGRA_DSI_PACKET_CMD,
83         TEGRA_DSI_DELAY_MS,
84         TEGRA_DSI_GPIO_SET,
85         TEGRA_DSI_SEND_FRAME,
86 };
87
88 struct tegra_dsi_cmd {
89         u8      cmd_type;
90         u8      data_id;
91         union {
92                 u16 data_len;
93                 u16 delay_ms;
94                 unsigned gpio;
95                 u16 frame_cnt;
96                 struct {
97                         u8 data0;
98                         u8 data1;
99                 } sp;
100         } sp_len_dly;
101         u8      *pdata;
102 };
103
104 #define DSI_GENERIC_LONG_WRITE                  0x29
105 #define DSI_GENERIC_SHORT_WRITE_1_PARAMS        0x13
106 #define DSI_GENERIC_SHORT_WRITE_2_PARAMS        0x23
107 #define DSI_DCS_WRITE_0_PARAM                   0x05
108 #define DSI_DCS_WRITE_1_PARAM                   0x15
109
110 #define DSI_DCS_SET_ADDR_MODE                   0x36
111 #define DSI_DCS_EXIT_SLEEP_MODE                 0x11
112 #define DSI_DCS_ENTER_SLEEP_MODE                0x10
113 #define DSI_DCS_SET_DISPLAY_ON                  0x29
114 #define DSI_DCS_SET_DISPLAY_OFF                 0x28
115 #define DSI_DCS_SET_TEARING_EFFECT_OFF          0x34
116 #define DSI_DCS_SET_TEARING_EFFECT_ON           0x35
117 #define DSI_DCS_NO_OP                           0x0
118
119 #define DSI_CMD_SHORT(di, p0, p1)       { \
120                                         .cmd_type = TEGRA_DSI_PACKET_CMD, \
121                                         .data_id = di, \
122                                         .sp_len_dly.sp.data0 = p0, \
123                                         .sp_len_dly.sp.data1 = p1, \
124                                         }
125 #define DSI_DLY_MS(ms)  { \
126                         .cmd_type = TEGRA_DSI_DELAY_MS, \
127                         .sp_len_dly.delay_ms = ms, \
128                         }
129
130 #define DSI_GPIO_SET(rst_gpio, on)      { \
131                                         .cmd_type = TEGRA_DSI_GPIO_SET, \
132                                         .data_id = on, \
133                                         .sp_len_dly.gpio = rst_gpio, \
134                                         }
135
136 #define DSI_CMD_LONG(di, ptr)   { \
137                                 .cmd_type = TEGRA_DSI_PACKET_CMD, \
138                                 .data_id = di, \
139                                 .sp_len_dly.data_len = ARRAY_SIZE(ptr), \
140                                 .pdata = ptr, \
141                                 }
142
143 #define DSI_SEND_FRAME(cnt)     { \
144                         .cmd_type = TEGRA_DSI_SEND_FRAME, \
145                         .sp_len_dly.frame_cnt = cnt, \
146                         }
147
148 struct dsi_phy_timing_ns {
149         u16             t_hsdexit_ns;
150         u16             t_hstrail_ns;
151         u16             t_datzero_ns;
152         u16             t_hsprepare_ns;
153
154         u16             t_clktrail_ns;
155         u16             t_clkpost_ns;
156         u16             t_clkzero_ns;
157         u16             t_tlpx_ns;
158
159         u16             t_clkprepare_ns;
160         u16             t_clkpre_ns;
161         u16             t_wakeup_ns;
162
163         u16             t_taget_ns;
164         u16             t_tasure_ns;
165         u16             t_tago_ns;
166 };
167
168 enum {
169         CMD_VS          = 0x01,
170         CMD_VE          = 0x11,
171
172         CMD_HS          = 0x21,
173         CMD_HE          = 0x31,
174
175         CMD_EOT         = 0x08,
176         CMD_NULL        = 0x09,
177         CMD_SHORTW      = 0x15,
178         CMD_BLNK        = 0x19,
179         CMD_LONGW       = 0x39,
180
181         CMD_RGB         = 0x00,
182         CMD_RGB_16BPP   = 0x0E,
183         CMD_RGB_18BPP   = 0x1E,
184         CMD_RGB_18BPPNP = 0x2E,
185         CMD_RGB_24BPP   = 0x3E,
186 };
187
188 enum {
189         TEGRA_DSI_DISABLE,
190         TEGRA_DSI_ENABLE,
191 };
192
193 #define PKT_ID0(id)     ((((id) & 0x3f) << 3) | \
194                         (((TEGRA_DSI_ENABLE) & 0x1) << 9))
195 #define PKT_LEN0(len)   (((len) & 0x7) << 0)
196 #define PKT_ID1(id)     ((((id) & 0x3f) << 13) | \
197                         (((TEGRA_DSI_ENABLE) & 0x1) << 19))
198 #define PKT_LEN1(len)   (((len) & 0x7) << 10)
199 #define PKT_ID2(id)     ((((id) & 0x3f) << 23) | \
200                         (((TEGRA_DSI_ENABLE) & 0x1) << 29))
201 #define PKT_LEN2(len)   (((len) & 0x7) << 20)
202 #define PKT_ID3(id)     ((((id) & 0x3f) << 3) | \
203                         (((TEGRA_DSI_ENABLE) & 0x1) << 9))
204 #define PKT_LEN3(len)   (((len) & 0x7) << 0)
205 #define PKT_ID4(id)     ((((id) & 0x3f) << 13) | \
206                         (((TEGRA_DSI_ENABLE) & 0x1) << 19))
207 #define PKT_LEN4(len)   (((len) & 0x7) << 10)
208 #define PKT_ID5(id)     ((((id) & 0x3f) << 23) | \
209                         (((TEGRA_DSI_ENABLE) & 0x1) << 29))
210 #define PKT_LEN5(len)   (((len) & 0x7) << 20)
211 #define PKT_LP          (((TEGRA_DSI_ENABLE) & 0x1) << 30)
212 #define NUMOF_PKT_SEQ   12
213
214 enum {
215         DSI_VS_0 = 0x0,
216         DSI_VS_1 = 0x1,
217 };
218
219 enum {
220         DSI_INSTANCE_0,
221         DSI_INSTANCE_1,
222 };
223
224 /* Aggressiveness level of DSI suspend. The higher, the more aggressive. */
225 #define DSI_NO_SUSPEND                  0
226 #define DSI_HOST_SUSPEND_LV0            1
227 #define DSI_HOST_SUSPEND_LV1            2
228 #define DSI_HOST_SUSPEND_LV2            3
229
230 struct tegra_dsi_out {
231         u8              n_data_lanes;                   /* required */
232         u8              pixel_format;                   /* required */
233         u8              refresh_rate;                   /* required */
234         u8              rated_refresh_rate;
235         u8              panel_reset;                    /* required */
236         u8              virtual_channel;                /* required */
237         u8              dsi_instance;
238         u8              chip_id;
239         u8              chip_rev;
240         u8              controller_vs;
241
242         bool            panel_has_frame_buffer; /* required*/
243
244         /* Deprecated. Use DSI_SEND_FRAME panel command instead. */
245         bool            panel_send_dc_frames;
246
247         struct tegra_dsi_cmd    *dsi_init_cmd;          /* required */
248         u16             n_init_cmd;                     /* required */
249
250         struct tegra_dsi_cmd    *dsi_early_suspend_cmd;
251         u16             n_early_suspend_cmd;
252
253         struct tegra_dsi_cmd    *dsi_late_resume_cmd;
254         u16             n_late_resume_cmd;
255
256         struct tegra_dsi_cmd    *dsi_suspend_cmd;       /* required */
257         u16             n_suspend_cmd;                  /* required */
258
259         u8              video_data_type;                /* required */
260         u8              video_clock_mode;
261         u8              video_burst_mode;
262         u8              ganged_type;
263
264         u8              suspend_aggr;
265
266         u16             panel_buffer_size_byte;
267         u16             panel_reset_timeout_msec;
268
269         bool            hs_cmd_mode_supported;
270         bool            hs_cmd_mode_on_blank_supported;
271         bool            enable_hs_clock_on_lp_cmd_mode;
272         bool            no_pkt_seq_eot; /* 1st generation panel may not
273                                          * support eot. Don't set it for
274                                          * most panels. */
275         bool            te_polarity_low;
276         bool            power_saving_suspend;
277         bool            dsi2lvds_bridge_enable;
278         bool            dsi2edp_bridge_enable;
279
280         u32             max_panel_freq_khz;
281         u32             lp_cmd_mode_freq_khz;
282         u32             lp_read_cmd_mode_freq_khz;
283         u32             hs_clk_in_lp_cmd_mode_freq_khz;
284         u32             burst_mode_freq_khz;
285         u32             fpga_freq_khz;
286
287         u32             te_gpio;
288
289         const u32               *pkt_seq;
290
291         struct dsi_phy_timing_ns phy_timing;
292
293         u8              *bl_name;
294
295         bool            lp00_pre_panel_wakeup;
296         bool            ulpm_not_supported;
297 };
298
299 enum {
300         TEGRA_DC_STEREO_MODE_2D,
301         TEGRA_DC_STEREO_MODE_3D
302 };
303
304 enum {
305         TEGRA_DC_STEREO_LANDSCAPE,
306         TEGRA_DC_STEREO_PORTRAIT
307 };
308
309 struct tegra_stereo_out {
310         int  mode_2d_3d;
311         int  orientation;
312
313         void (*set_mode)(int mode);
314         void (*set_orientation)(int orientation);
315 };
316
317 struct tegra_dc_mode {
318         int     pclk;
319         int     rated_pclk;
320         int     h_ref_to_sync;
321         int     v_ref_to_sync;
322         int     h_sync_width;
323         int     v_sync_width;
324         int     h_back_porch;
325         int     v_back_porch;
326         int     h_active;
327         int     v_active;
328         int     h_front_porch;
329         int     v_front_porch;
330         int     stereo_mode;
331         u32     flags;
332         u8      avi_m;
333 };
334
335 #define TEGRA_DC_MODE_FLAG_NEG_V_SYNC   (1 << 0)
336 #define TEGRA_DC_MODE_FLAG_NEG_H_SYNC   (1 << 1)
337
338 /* aspect ratio. 0 means unspecified or default. */
339 #define TEGRA_DC_MODE_AVI_M_4_3         0x1
340 #define TEGRA_DC_MODE_AVI_M_16_9        0x2
341
342 enum {
343         TEGRA_DC_OUT_RGB,
344         TEGRA_DC_OUT_HDMI,
345         TEGRA_DC_OUT_DSI,
346 };
347
348 struct tegra_dc_out_pin {
349         int     name;
350         int     pol;
351 };
352
353 enum {
354         TEGRA_DC_OUT_PIN_DATA_ENABLE,
355         TEGRA_DC_OUT_PIN_H_SYNC,
356         TEGRA_DC_OUT_PIN_V_SYNC,
357         TEGRA_DC_OUT_PIN_PIXEL_CLOCK,
358 };
359
360 enum {
361         TEGRA_DC_OUT_PIN_POL_LOW,
362         TEGRA_DC_OUT_PIN_POL_HIGH,
363 };
364
365 enum {
366         TEGRA_DC_DISABLE_DITHER = 1,
367         TEGRA_DC_ORDERED_DITHER,
368         TEGRA_DC_ERRDIFF_DITHER,
369 };
370
371 typedef u8 tegra_dc_bl_output[256];
372 typedef u8 *p_tegra_dc_bl_output;
373
374 struct tegra_dc_sd_blp {
375         u16 time_constant;
376         u8 step;
377 };
378
379 struct tegra_dc_sd_fc {
380         u8 time_limit;
381         u8 threshold;
382 };
383
384 struct tegra_dc_sd_rgb {
385         u8 r;
386         u8 g;
387         u8 b;
388 };
389
390 struct tegra_dc_sd_agg_priorities {
391         u8 pri_lvl;
392         u8 agg[4];
393 };
394
395 struct tegra_dc_sd_window {
396         u16 h_position;
397         u16 v_position;
398         u16 h_size;
399         u16 v_size;
400 };
401
402 struct tegra_dc_sd_settings {
403         unsigned enable;
404         bool use_auto_pwm;
405         u8 hw_update_delay;
406         u8 aggressiveness;
407         short bin_width;
408         u8 phase_in_settings;
409         u8 phase_in_adjustments;
410         u8 cmd;
411         u8 final_agg;
412         u16 cur_agg_step;
413         u16 phase_settings_step;
414         u16 phase_adj_step;
415         u16 num_phase_in_steps;
416
417         struct tegra_dc_sd_agg_priorities agg_priorities;
418
419         bool use_vid_luma;
420         struct tegra_dc_sd_rgb coeff;
421
422         bool k_limit_enable;
423         u16 k_limit;
424
425         bool sd_window_enable;
426         struct tegra_dc_sd_window sd_window;
427
428         bool soft_clipping_enable;
429         u8 soft_clipping_threshold;
430
431         bool smooth_k_enable;
432         u16 smooth_k_incr;
433
434         bool sd_proc_control;
435         bool soft_clipping_correction;
436         bool use_vpulse2;
437
438         struct tegra_dc_sd_fc fc;
439         struct tegra_dc_sd_blp blp;
440         u8 bltf[4][4][4];
441         struct tegra_dc_sd_rgb lut[4][9];
442
443         atomic_t *sd_brightness;
444         char *bl_device_name;
445         struct backlight_device *bl_device;
446 };
447
448 enum {
449         NO_CMD = 0x0,
450         ENABLE = 0x1,
451         DISABLE = 0x2,
452         PHASE_IN = 0x4,
453         AGG_CHG = 0x8,
454 };
455
456 enum {
457         TEGRA_PIN_OUT_CONFIG_SEL_LHP0_LD21,
458         TEGRA_PIN_OUT_CONFIG_SEL_LHP1_LD18,
459         TEGRA_PIN_OUT_CONFIG_SEL_LHP2_LD19,
460         TEGRA_PIN_OUT_CONFIG_SEL_LVP0_LVP0_Out,
461         TEGRA_PIN_OUT_CONFIG_SEL_LVP1_LD20,
462
463         TEGRA_PIN_OUT_CONFIG_SEL_LM1_M1,
464         TEGRA_PIN_OUT_CONFIG_SEL_LM1_LD21,
465         TEGRA_PIN_OUT_CONFIG_SEL_LM1_PM1,
466
467         TEGRA_PIN_OUT_CONFIG_SEL_LDI_LD22,
468         TEGRA_PIN_OUT_CONFIG_SEL_LPP_LD23,
469         TEGRA_PIN_OUT_CONFIG_SEL_LDC_SDC,
470         TEGRA_PIN_OUT_CONFIG_SEL_LSPI_DE,
471 };
472
473 struct tegra_dc_out {
474         int                             type;
475         unsigned                        flags;
476
477         /* size in mm */
478         unsigned                        h_size;
479         unsigned                        v_size;
480
481         int                             dcc_bus;
482         int                             hotplug_gpio;
483         int                             hotplug_state; /* 0 normal 1 force on */
484         const char                      *parent_clk;
485         const char                      *parent_clk_backup;
486
487         unsigned                        max_pixclock;
488         unsigned                        order;
489         unsigned                        align;
490         unsigned                        depth;
491         unsigned                        dither;
492
493         struct tegra_dc_mode            *modes;
494         int                             n_modes;
495
496         struct tegra_dsi_out            *dsi;
497         struct tegra_hdmi_out           *hdmi_out;
498         struct tegra_stereo_out         *stereo;
499
500         unsigned                        height; /* mm */
501         unsigned                        width; /* mm */
502
503         struct tegra_dc_out_pin         *out_pins;
504         unsigned                        n_out_pins;
505
506         struct tegra_dc_sd_settings     *sd_settings;
507
508         u8                      *out_sel_configs;
509         unsigned                n_out_sel_configs;
510         bool                    user_needs_vblank;
511         struct completion       user_vblank_comp;
512
513         int     (*enable)(struct device *);
514         int     (*postpoweron)(struct device *);
515         int     (*prepoweroff)(void);
516         int     (*disable)(void);
517
518         int     (*hotplug_init)(struct device *);
519         int     (*postsuspend)(void);
520         void    (*hotplug_report)(bool);
521 };
522
523 /* bits for tegra_dc_out.flags */
524 #define TEGRA_DC_OUT_HOTPLUG_HIGH               (0 << 1)
525 #define TEGRA_DC_OUT_HOTPLUG_LOW                (1 << 1)
526 #define TEGRA_DC_OUT_HOTPLUG_MASK               (1 << 1)
527 #define TEGRA_DC_OUT_NVHDCP_POLICY_ALWAYS_ON    (0 << 2)
528 #define TEGRA_DC_OUT_NVHDCP_POLICY_ON_DEMAND    (1 << 2)
529 #define TEGRA_DC_OUT_NVHDCP_POLICY_MASK         (1 << 2)
530 #define TEGRA_DC_OUT_CONTINUOUS_MODE            (0 << 3)
531 #define TEGRA_DC_OUT_ONE_SHOT_MODE              (1 << 3)
532 #define TEGRA_DC_OUT_N_SHOT_MODE                (1 << 4)
533 #define TEGRA_DC_OUT_ONE_SHOT_LP_MODE           (1 << 5)
534 #define TEGRA_DC_OUT_INITIALIZED_MODE           (1 << 6)
535
536 #define TEGRA_DC_ALIGN_MSB              0
537 #define TEGRA_DC_ALIGN_LSB              1
538
539 #define TEGRA_DC_ORDER_RED_BLUE         0
540 #define TEGRA_DC_ORDER_BLUE_RED         1
541
542 /* Errands use the interrupts */
543 #define V_BLANK_FLIP            0
544 #define V_BLANK_NVSD            1
545
546 #define V_PULSE2_FLIP           0
547 #define V_PULSE2_NVSD           1
548
549 struct tegra_dc;
550 struct nvmap_handle_ref;
551
552 struct tegra_dc_csc {
553         unsigned short yof;
554         unsigned short kyrgb;
555         unsigned short kur;
556         unsigned short kvr;
557         unsigned short kug;
558         unsigned short kvg;
559         unsigned short kub;
560         unsigned short kvb;
561 };
562
563 /* palette lookup table */
564 struct tegra_dc_lut {
565         u8 r[256];
566         u8 g[256];
567         u8 b[256];
568 };
569
570 struct tegra_dc_cmu_csc {
571         u16 krr;
572         u16 kgr;
573         u16 kbr;
574         u16 krg;
575         u16 kgg;
576         u16 kbg;
577         u16 krb;
578         u16 kgb;
579         u16 kbb;
580 };
581
582 struct tegra_dc_cmu {
583         u16 lut1[256];
584         struct tegra_dc_cmu_csc csc;
585         u8 lut2[960];
586 };
587
588 struct tegra_dc_win {
589         u8                      idx;
590         u8                      ppflags; /* see TEGRA_WIN_PPFLAG* */
591         u8                      global_alpha;
592         u32                     fmt;
593         u32                     flags;
594
595         void                    *virt_addr;
596         dma_addr_t              phys_addr;
597         dma_addr_t              phys_addr_u;
598         dma_addr_t              phys_addr_v;
599         unsigned                stride;
600         unsigned                stride_uv;
601         fixed20_12              x;
602         fixed20_12              y;
603         fixed20_12              w;
604         fixed20_12              h;
605         unsigned                out_x;
606         unsigned                out_y;
607         unsigned                out_w;
608         unsigned                out_h;
609         unsigned                z;
610
611         struct tegra_dc_csc     csc;
612
613         int                     dirty;
614         int                     underflows;
615         struct tegra_dc         *dc;
616
617         struct nvmap_handle_ref *cur_handle;
618         unsigned                bandwidth;
619         unsigned                new_bandwidth;
620         struct tegra_dc_lut     lut;
621 };
622
623 #define TEGRA_WIN_PPFLAG_CP_ENABLE      (1 << 0) /* enable RGB color lut */
624 #define TEGRA_WIN_PPFLAG_CP_FBOVERRIDE  (1 << 1) /* override fbdev color lut */
625
626 #define TEGRA_WIN_FLAG_ENABLED          (1 << 0)
627 #define TEGRA_WIN_FLAG_BLEND_PREMULT    (1 << 1)
628 #define TEGRA_WIN_FLAG_BLEND_COVERAGE   (1 << 2)
629 #define TEGRA_WIN_FLAG_INVERT_H         (1 << 3)
630 #define TEGRA_WIN_FLAG_INVERT_V         (1 << 4)
631 #define TEGRA_WIN_FLAG_TILED            (1 << 5)
632 #define TEGRA_WIN_FLAG_H_FILTER         (1 << 6)
633 #define TEGRA_WIN_FLAG_V_FILTER         (1 << 7)
634 #define TEGRA_WIN_FLAG_SCAN_COLUMN      (1 << 9)
635
636
637 #define TEGRA_WIN_BLEND_FLAGS_MASK \
638         (TEGRA_WIN_FLAG_BLEND_PREMULT | TEGRA_WIN_FLAG_BLEND_COVERAGE)
639
640 /* Note: These are the actual values written to the DC_WIN_COLOR_DEPTH register
641  * and may change in new tegra architectures.
642  */
643 #define TEGRA_WIN_FMT_P1                0
644 #define TEGRA_WIN_FMT_P2                1
645 #define TEGRA_WIN_FMT_P4                2
646 #define TEGRA_WIN_FMT_P8                3
647 #define TEGRA_WIN_FMT_B4G4R4A4          4
648 #define TEGRA_WIN_FMT_B5G5R5A           5
649 #define TEGRA_WIN_FMT_B5G6R5            6
650 #define TEGRA_WIN_FMT_AB5G5R5           7
651 #define TEGRA_WIN_FMT_B8G8R8A8          12
652 #define TEGRA_WIN_FMT_R8G8B8A8          13
653 #define TEGRA_WIN_FMT_B6x2G6x2R6x2A8    14
654 #define TEGRA_WIN_FMT_R6x2G6x2B6x2A8    15
655 #define TEGRA_WIN_FMT_YCbCr422          16
656 #define TEGRA_WIN_FMT_YUV422            17
657 #define TEGRA_WIN_FMT_YCbCr420P         18
658 #define TEGRA_WIN_FMT_YUV420P           19
659 #define TEGRA_WIN_FMT_YCbCr422P         20
660 #define TEGRA_WIN_FMT_YUV422P           21
661 #define TEGRA_WIN_FMT_YCbCr422R         22
662 #define TEGRA_WIN_FMT_YUV422R           23
663 #define TEGRA_WIN_FMT_YCbCr422RA        24
664 #define TEGRA_WIN_FMT_YUV422RA          25
665
666 struct tegra_fb_data {
667         int             win;
668
669         int             xres;
670         int             yres;
671         int             bits_per_pixel; /* -1 means autodetect */
672
673         unsigned long   flags;
674 };
675
676 #define TEGRA_FB_FLIP_ON_PROBE          (1 << 0)
677
678 struct tegra_dc_platform_data {
679         unsigned long           flags;
680         unsigned long           emc_clk_rate;
681         struct tegra_dc_out     *default_out;
682         struct tegra_fb_data    *fb;
683
684 #ifdef CONFIG_TEGRA_DC_CMU
685         bool                    cmu_enable;
686         struct tegra_dc_cmu     *cmu;
687 #endif
688 };
689
690 #define TEGRA_DC_FLAG_ENABLED           (1 << 0)
691 #define TEGRA_DC_FLAG_CMU_DISABLE       (0 << 1)
692 #define TEGRA_DC_FLAG_CMU_ENABLE        (1 << 1)
693
694 int tegra_dc_get_stride(struct tegra_dc *dc, unsigned win);
695 struct tegra_dc *tegra_dc_get_dc(unsigned idx);
696 struct tegra_dc_win *tegra_dc_get_window(struct tegra_dc *dc, unsigned win);
697 bool tegra_dc_get_connected(struct tegra_dc *);
698 bool tegra_dc_hpd(struct tegra_dc *dc);
699
700
701 void tegra_dc_get_fbvblank(struct tegra_dc *dc, struct fb_vblank *vblank);
702 int tegra_dc_wait_for_vsync(struct tegra_dc *dc);
703 void tegra_dc_blank(struct tegra_dc *dc);
704
705 void tegra_dc_enable(struct tegra_dc *dc);
706 void tegra_dc_disable(struct tegra_dc *dc);
707 int tegra_dc_set_default_videomode(struct tegra_dc *dc);
708
709
710 u32 tegra_dc_get_syncpt_id(const struct tegra_dc *dc, int i);
711 u32 tegra_dc_incr_syncpt_max(struct tegra_dc *dc, int i);
712 void tegra_dc_incr_syncpt_min(struct tegra_dc *dc, int i, u32 val);
713
714 /* tegra_dc_update_windows and tegra_dc_sync_windows do not support windows
715  * with differenct dcs in one call
716  */
717 int tegra_dc_update_windows(struct tegra_dc_win *windows[], int n);
718 int tegra_dc_sync_windows(struct tegra_dc_win *windows[], int n);
719 int tegra_dc_config_frame_end_intr(struct tegra_dc *dc, bool enable);
720 bool tegra_dc_is_within_n_vsync(struct tegra_dc *dc, s64 ts);
721 bool tegra_dc_does_vsync_separate(struct tegra_dc *dc, s64 new_ts, s64 old_ts);
722
723 int tegra_dc_set_mode(struct tegra_dc *dc, const struct tegra_dc_mode *mode);
724 struct fb_videomode;
725 int tegra_dc_to_fb_videomode(struct fb_videomode *fbmode,
726         const struct tegra_dc_mode *mode);
727 int tegra_dc_set_fb_mode(struct tegra_dc *dc, const struct fb_videomode *fbmode,
728         bool stereo_mode);
729
730 unsigned tegra_dc_get_out_height(const struct tegra_dc *dc);
731 unsigned tegra_dc_get_out_width(const struct tegra_dc *dc);
732 unsigned tegra_dc_get_out_max_pixclock(const struct tegra_dc *dc);
733
734 /* PM0 and PM1 signal control */
735 #define TEGRA_PWM_PM0 0
736 #define TEGRA_PWM_PM1 1
737
738 struct tegra_dc_pwm_params {
739         int which_pwm;
740         int gpio_conf_to_sfio;
741         unsigned int period;
742         unsigned int clk_div;
743         unsigned int clk_select;
744         unsigned int duty_cycle;
745 };
746
747 void tegra_dc_config_pwm(struct tegra_dc *dc, struct tegra_dc_pwm_params *cfg);
748
749 int tegra_dsi_send_panel_short_cmd(struct tegra_dc *dc, u8 *pdata, u8 data_len);
750
751 int tegra_dc_update_csc(struct tegra_dc *dc, int win_index);
752
753 int tegra_dc_update_lut(struct tegra_dc *dc, int win_index, int fboveride);
754
755 /*
756  * In order to get a dc's current EDID, first call tegra_dc_get_edid() from an
757  * interruptible context.  The returned value (if non-NULL) points to a
758  * snapshot of the current state; after copying data from it, call
759  * tegra_dc_put_edid() on that pointer.  Do not dereference anything through
760  * that pointer after calling tegra_dc_put_edid().
761  */
762 struct tegra_dc_edid {
763         size_t          len;
764         u8              buf[0];
765 };
766 struct tegra_dc_edid *tegra_dc_get_edid(struct tegra_dc *dc);
767 void tegra_dc_put_edid(struct tegra_dc_edid *edid);
768
769 int tegra_dc_set_flip_callback(void (*callback)(void));
770 int tegra_dc_unset_flip_callback(void);
771 int tegra_dc_get_panel_sync_rate(void);
772
773 int tegra_dc_get_out(const struct tegra_dc *dc);
774
775 #ifdef CONFIG_PM_SLEEP
776 void tegra_log_resume_time(void);
777 void tegra_log_suspend_time(void);
778 #else
779 #define tegra_log_resume_time()
780 #define tegra_log_suspend_time()
781 #endif
782
783 /* table of electrical settings, must be in acending order. */
784 struct tmds_config {
785         int pclk;
786         u32 pll0;
787         u32 pll1;
788         u32 pe_current; /* pre-emphasis */
789         u32 drive_current;
790         u32 peak_current; /* for TEGRA_11x_SOC */
791 };
792
793 struct tegra_hdmi_out {
794         struct tmds_config *tmds_config;
795         int n_tmds_config;
796 };
797 #endif