drivers/gpu/drm/msm/mdp4/mdp4.xml.h

   1 #ifndef MDP4_XML
   2 #define MDP4_XML
   3
   4 /* Autogenerated file, DO NOT EDIT manually!
   5
   6 This file was generated by the rules-ng-ng headergen tool in this git repository:
   7 http://0x04.net/cgit/index.cgi/rules-ng-ng
   8 git clone git://0x04.net/rules-ng-ng
   9
  10 The rules-ng-ng source files this header was generated from are:
  11 - /home/robclark/src/freedreno/envytools/rnndb/msm.xml                 (    595 bytes, from 2013-07-05 19:21:12)
  12 - /home/robclark/src/freedreno/envytools/rnndb/freedreno_copyright.xml (   1453 bytes, from 2013-03-31 16:51:27)
  13 - /home/robclark/src/freedreno/envytools/rnndb/mdp4/mdp4.xml           (  19332 bytes, from 2013-08-16 22:16:36)
  14 - /home/robclark/src/freedreno/envytools/rnndb/dsi/dsi.xml             (  11712 bytes, from 2013-08-17 17:13:43)
  15 - /home/robclark/src/freedreno/envytools/rnndb/dsi/sfpb.xml            (    344 bytes, from 2013-08-11 19:26:32)
  16 - /home/robclark/src/freedreno/envytools/rnndb/dsi/mmss_cc.xml         (   1544 bytes, from 2013-08-16 19:17:05)
  17 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/qfprom.xml         (    600 bytes, from 2013-07-05 19:21:12)
  18 - /home/robclark/src/freedreno/envytools/rnndb/hdmi/hdmi.xml           (  19288 bytes, from 2013-08-11 18:14:15)
  19
  20 Copyright (C) 2013 by the following authors:
  21 - Rob Clark <robdclark@gmail.com> (robclark)
  22
  23 Permission is hereby granted, free of charge, to any person obtaining
  24 a copy of this software and associated documentation files (the
  25 "Software"), to deal in the Software without restriction, including
  26 without limitation the rights to use, copy, modify, merge, publish,
  27 distribute, sublicense, and/or sell copies of the Software, and to
  28 permit persons to whom the Software is furnished to do so, subject to
  29 the following conditions:
  30
  31 The above copyright notice and this permission notice (including the
  32 next paragraph) shall be included in all copies or substantial
  33 portions of the Software.
  34
  35 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  36 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  37 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  38 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  39 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  40 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  41 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  42 */
  43
  44
  45 enum mpd4_bpc {
  46         BPC1 = 0,
  47         BPC5 = 1,
  48         BPC6 = 2,
  49         BPC8 = 3,
  50 };
  51
  52 enum mpd4_bpc_alpha {
  53         BPC1A = 0,
  54         BPC4A = 1,
  55         BPC6A = 2,
  56         BPC8A = 3,
  57 };
  58
  59 enum mpd4_alpha_type {
  60         FG_CONST = 0,
  61         BG_CONST = 1,
  62         FG_PIXEL = 2,
  63         BG_PIXEL = 3,
  64 };
  65
  66 enum mpd4_pipe {
  67         VG1 = 0,
  68         VG2 = 1,
  69         RGB1 = 2,
  70         RGB2 = 3,
  71         RGB3 = 4,
  72         VG3 = 5,
  73         VG4 = 6,
  74 };
  75
  76 enum mpd4_mixer {
  77         MIXER0 = 0,
  78         MIXER1 = 1,
  79         MIXER2 = 2,
  80 };
  81
  82 enum mpd4_mixer_stage_id {
  83         STAGE_UNUSED = 0,
  84         STAGE_BASE = 1,
  85         STAGE0 = 2,
  86         STAGE1 = 3,
  87         STAGE2 = 4,
  88         STAGE3 = 5,
  89 };
  90
  91 enum mdp4_intf {
  92         INTF_LCDC_DTV = 0,
  93         INTF_DSI_VIDEO = 1,
  94         INTF_DSI_CMD = 2,
  95         INTF_EBI2_TV = 3,
  96 };
  97
  98 enum mdp4_cursor_format {
  99         CURSOR_ARGB = 1,
 100         CURSOR_XRGB = 2,
 101 };
 102
 103 enum mdp4_dma {
 104         DMA_P = 0,
 105         DMA_S = 1,
 106         DMA_E = 2,
 107 };
 108
 109 #define MDP4_IRQ_OVERLAY0_DONE                                  0x00000001
 110 #define MDP4_IRQ_OVERLAY1_DONE                                  0x00000002
 111 #define MDP4_IRQ_DMA_S_DONE                                     0x00000004
 112 #define MDP4_IRQ_DMA_E_DONE                                     0x00000008
 113 #define MDP4_IRQ_DMA_P_DONE                                     0x00000010
 114 #define MDP4_IRQ_VG1_HISTOGRAM                                  0x00000020
 115 #define MDP4_IRQ_VG2_HISTOGRAM                                  0x00000040
 116 #define MDP4_IRQ_PRIMARY_VSYNC                                  0x00000080
 117 #define MDP4_IRQ_PRIMARY_INTF_UDERRUN                           0x00000100
 118 #define MDP4_IRQ_EXTERNAL_VSYNC                                 0x00000200
 119 #define MDP4_IRQ_EXTERNAL_INTF_UDERRUN                          0x00000400
 120 #define MDP4_IRQ_PRIMARY_RDPTR                                  0x00000800
 121 #define MDP4_IRQ_DMA_P_HISTOGRAM                                0x00020000
 122 #define MDP4_IRQ_DMA_S_HISTOGRAM                                0x04000000
 123 #define MDP4_IRQ_OVERLAY2_DONE                                  0x40000000
 124 #define REG_MDP4_VERSION                                        0x00000000
 125 #define MDP4_VERSION_MINOR__MASK                                0x00ff0000
 126 #define MDP4_VERSION_MINOR__SHIFT                               16
 127 static inline uint32_t MDP4_VERSION_MINOR(uint32_t val)
 128 {
 129         return ((val) << MDP4_VERSION_MINOR__SHIFT) & MDP4_VERSION_MINOR__MASK;
 130 }
 131 #define MDP4_VERSION_MAJOR__MASK                                0xff000000
 132 #define MDP4_VERSION_MAJOR__SHIFT                               24
 133 static inline uint32_t MDP4_VERSION_MAJOR(uint32_t val)
 134 {
 135         return ((val) << MDP4_VERSION_MAJOR__SHIFT) & MDP4_VERSION_MAJOR__MASK;
 136 }
 137
 138 #define REG_MDP4_OVLP0_KICK                                     0x00000004
 139
 140 #define REG_MDP4_OVLP1_KICK                                     0x00000008
 141
 142 #define REG_MDP4_OVLP2_KICK                                     0x000000d0
 143
 144 #define REG_MDP4_DMA_P_KICK                                     0x0000000c
 145
 146 #define REG_MDP4_DMA_S_KICK                                     0x00000010
 147
 148 #define REG_MDP4_DMA_E_KICK                                     0x00000014
 149
 150 #define REG_MDP4_DISP_STATUS                                    0x00000018
 151
 152 #define REG_MDP4_DISP_INTF_SEL                                  0x00000038
 153 #define MDP4_DISP_INTF_SEL_PRIM__MASK                           0x00000003
 154 #define MDP4_DISP_INTF_SEL_PRIM__SHIFT                          0
 155 static inline uint32_t MDP4_DISP_INTF_SEL_PRIM(enum mdp4_intf val)
 156 {
 157         return ((val) << MDP4_DISP_INTF_SEL_PRIM__SHIFT) & MDP4_DISP_INTF_SEL_PRIM__MASK;
 158 }
 159 #define MDP4_DISP_INTF_SEL_SEC__MASK                            0x0000000c
 160 #define MDP4_DISP_INTF_SEL_SEC__SHIFT                           2
 161 static inline uint32_t MDP4_DISP_INTF_SEL_SEC(enum mdp4_intf val)
 162 {
 163         return ((val) << MDP4_DISP_INTF_SEL_SEC__SHIFT) & MDP4_DISP_INTF_SEL_SEC__MASK;
 164 }
 165 #define MDP4_DISP_INTF_SEL_EXT__MASK                            0x00000030
 166 #define MDP4_DISP_INTF_SEL_EXT__SHIFT                           4
 167 static inline uint32_t MDP4_DISP_INTF_SEL_EXT(enum mdp4_intf val)
 168 {
 169         return ((val) << MDP4_DISP_INTF_SEL_EXT__SHIFT) & MDP4_DISP_INTF_SEL_EXT__MASK;
 170 }
 171 #define MDP4_DISP_INTF_SEL_DSI_VIDEO                            0x00000040
 172 #define MDP4_DISP_INTF_SEL_DSI_CMD                              0x00000080
 173
 174 #define REG_MDP4_RESET_STATUS                                   0x0000003c
 175
 176 #define REG_MDP4_READ_CNFG                                      0x0000004c
 177
 178 #define REG_MDP4_INTR_ENABLE                                    0x00000050
 179
 180 #define REG_MDP4_INTR_STATUS                                    0x00000054
 181
 182 #define REG_MDP4_INTR_CLEAR                                     0x00000058
 183
 184 #define REG_MDP4_EBI2_LCD0                                      0x00000060
 185
 186 #define REG_MDP4_EBI2_LCD1                                      0x00000064
 187
 188 #define REG_MDP4_PORTMAP_MODE                                   0x00000070
 189
 190 #define REG_MDP4_CS_CONTROLLER0                                 0x000000c0
 191
 192 #define REG_MDP4_CS_CONTROLLER1                                 0x000000c4
 193
 194 #define REG_MDP4_LAYERMIXER2_IN_CFG                             0x000100f0
 195 #define MDP4_LAYERMIXER2_IN_CFG_PIPE0__MASK                     0x00000007
 196 #define MDP4_LAYERMIXER2_IN_CFG_PIPE0__SHIFT                    0
 197 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE0(enum mpd4_mixer_stage_id val)
 198 {
 199         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE0__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE0__MASK;
 200 }
 201 #define MDP4_LAYERMIXER2_IN_CFG_PIPE0_MIXER1                    0x00000008
 202 #define MDP4_LAYERMIXER2_IN_CFG_PIPE1__MASK                     0x00000070
 203 #define MDP4_LAYERMIXER2_IN_CFG_PIPE1__SHIFT                    4
 204 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE1(enum mpd4_mixer_stage_id val)
 205 {
 206         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE1__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE1__MASK;
 207 }
 208 #define MDP4_LAYERMIXER2_IN_CFG_PIPE1_MIXER1                    0x00000080
 209 #define MDP4_LAYERMIXER2_IN_CFG_PIPE2__MASK                     0x00000700
 210 #define MDP4_LAYERMIXER2_IN_CFG_PIPE2__SHIFT                    8
 211 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE2(enum mpd4_mixer_stage_id val)
 212 {
 213         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE2__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE2__MASK;
 214 }
 215 #define MDP4_LAYERMIXER2_IN_CFG_PIPE2_MIXER1                    0x00000800
 216 #define MDP4_LAYERMIXER2_IN_CFG_PIPE3__MASK                     0x00007000
 217 #define MDP4_LAYERMIXER2_IN_CFG_PIPE3__SHIFT                    12
 218 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE3(enum mpd4_mixer_stage_id val)
 219 {
 220         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE3__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE3__MASK;
 221 }
 222 #define MDP4_LAYERMIXER2_IN_CFG_PIPE3_MIXER1                    0x00008000
 223 #define MDP4_LAYERMIXER2_IN_CFG_PIPE4__MASK                     0x00070000
 224 #define MDP4_LAYERMIXER2_IN_CFG_PIPE4__SHIFT                    16
 225 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE4(enum mpd4_mixer_stage_id val)
 226 {
 227         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE4__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE4__MASK;
 228 }
 229 #define MDP4_LAYERMIXER2_IN_CFG_PIPE4_MIXER1                    0x00080000
 230 #define MDP4_LAYERMIXER2_IN_CFG_PIPE5__MASK                     0x00700000
 231 #define MDP4_LAYERMIXER2_IN_CFG_PIPE5__SHIFT                    20
 232 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE5(enum mpd4_mixer_stage_id val)
 233 {
 234         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE5__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE5__MASK;
 235 }
 236 #define MDP4_LAYERMIXER2_IN_CFG_PIPE5_MIXER1                    0x00800000
 237 #define MDP4_LAYERMIXER2_IN_CFG_PIPE6__MASK                     0x07000000
 238 #define MDP4_LAYERMIXER2_IN_CFG_PIPE6__SHIFT                    24
 239 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE6(enum mpd4_mixer_stage_id val)
 240 {
 241         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE6__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE6__MASK;
 242 }
 243 #define MDP4_LAYERMIXER2_IN_CFG_PIPE6_MIXER1                    0x08000000
 244 #define MDP4_LAYERMIXER2_IN_CFG_PIPE7__MASK                     0x70000000
 245 #define MDP4_LAYERMIXER2_IN_CFG_PIPE7__SHIFT                    28
 246 static inline uint32_t MDP4_LAYERMIXER2_IN_CFG_PIPE7(enum mpd4_mixer_stage_id val)
 247 {
 248         return ((val) << MDP4_LAYERMIXER2_IN_CFG_PIPE7__SHIFT) & MDP4_LAYERMIXER2_IN_CFG_PIPE7__MASK;
 249 }
 250 #define MDP4_LAYERMIXER2_IN_CFG_PIPE7_MIXER1                    0x80000000
 251
 252 #define REG_MDP4_LAYERMIXER_IN_CFG_UPDATE_METHOD                0x000100fc
 253
 254 #define REG_MDP4_LAYERMIXER_IN_CFG                              0x00010100
 255 #define MDP4_LAYERMIXER_IN_CFG_PIPE0__MASK                      0x00000007
 256 #define MDP4_LAYERMIXER_IN_CFG_PIPE0__SHIFT                     0
 257 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE0(enum mpd4_mixer_stage_id val)
 258 {
 259         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE0__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE0__MASK;
 260 }
 261 #define MDP4_LAYERMIXER_IN_CFG_PIPE0_MIXER1                     0x00000008
 262 #define MDP4_LAYERMIXER_IN_CFG_PIPE1__MASK                      0x00000070
 263 #define MDP4_LAYERMIXER_IN_CFG_PIPE1__SHIFT                     4
 264 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE1(enum mpd4_mixer_stage_id val)
 265 {
 266         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE1__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE1__MASK;
 267 }
 268 #define MDP4_LAYERMIXER_IN_CFG_PIPE1_MIXER1                     0x00000080
 269 #define MDP4_LAYERMIXER_IN_CFG_PIPE2__MASK                      0x00000700
 270 #define MDP4_LAYERMIXER_IN_CFG_PIPE2__SHIFT                     8
 271 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE2(enum mpd4_mixer_stage_id val)
 272 {
 273         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE2__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE2__MASK;
 274 }
 275 #define MDP4_LAYERMIXER_IN_CFG_PIPE2_MIXER1                     0x00000800
 276 #define MDP4_LAYERMIXER_IN_CFG_PIPE3__MASK                      0x00007000
 277 #define MDP4_LAYERMIXER_IN_CFG_PIPE3__SHIFT                     12
 278 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE3(enum mpd4_mixer_stage_id val)
 279 {
 280         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE3__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE3__MASK;
 281 }
 282 #define MDP4_LAYERMIXER_IN_CFG_PIPE3_MIXER1                     0x00008000
 283 #define MDP4_LAYERMIXER_IN_CFG_PIPE4__MASK                      0x00070000
 284 #define MDP4_LAYERMIXER_IN_CFG_PIPE4__SHIFT                     16
 285 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE4(enum mpd4_mixer_stage_id val)
 286 {
 287         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE4__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE4__MASK;
 288 }
 289 #define MDP4_LAYERMIXER_IN_CFG_PIPE4_MIXER1                     0x00080000
 290 #define MDP4_LAYERMIXER_IN_CFG_PIPE5__MASK                      0x00700000
 291 #define MDP4_LAYERMIXER_IN_CFG_PIPE5__SHIFT                     20
 292 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE5(enum mpd4_mixer_stage_id val)
 293 {
 294         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE5__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE5__MASK;
 295 }
 296 #define MDP4_LAYERMIXER_IN_CFG_PIPE5_MIXER1                     0x00800000
 297 #define MDP4_LAYERMIXER_IN_CFG_PIPE6__MASK                      0x07000000
 298 #define MDP4_LAYERMIXER_IN_CFG_PIPE6__SHIFT                     24
 299 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE6(enum mpd4_mixer_stage_id val)
 300 {
 301         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE6__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE6__MASK;
 302 }
 303 #define MDP4_LAYERMIXER_IN_CFG_PIPE6_MIXER1                     0x08000000
 304 #define MDP4_LAYERMIXER_IN_CFG_PIPE7__MASK                      0x70000000
 305 #define MDP4_LAYERMIXER_IN_CFG_PIPE7__SHIFT                     28
 306 static inline uint32_t MDP4_LAYERMIXER_IN_CFG_PIPE7(enum mpd4_mixer_stage_id val)
 307 {
 308         return ((val) << MDP4_LAYERMIXER_IN_CFG_PIPE7__SHIFT) & MDP4_LAYERMIXER_IN_CFG_PIPE7__MASK;
 309 }
 310 #define MDP4_LAYERMIXER_IN_CFG_PIPE7_MIXER1                     0x80000000
 311
 312 #define REG_MDP4_VG2_SRC_FORMAT                                 0x00030050
 313
 314 #define REG_MDP4_VG2_CONST_COLOR                                0x00031008
 315
 316 #define REG_MDP4_OVERLAY_FLUSH                                  0x00018000
 317 #define MDP4_OVERLAY_FLUSH_OVLP0                                0x00000001
 318 #define MDP4_OVERLAY_FLUSH_OVLP1                                0x00000002
 319 #define MDP4_OVERLAY_FLUSH_VG1                                  0x00000004
 320 #define MDP4_OVERLAY_FLUSH_VG2                                  0x00000008
 321 #define MDP4_OVERLAY_FLUSH_RGB1                                 0x00000010
 322 #define MDP4_OVERLAY_FLUSH_RGB2                                 0x00000020
 323
 324 static inline uint32_t __offset_OVLP(uint32_t idx)
 325 {
 326         switch (idx) {
 327                 case 0: return 0x00010000;
 328                 case 1: return 0x00018000;
 329                 case 2: return 0x00088000;
 330                 default: return INVALID_IDX(idx);
 331         }
 332 }
 333 static inline uint32_t REG_MDP4_OVLP(uint32_t i0) { return 0x00000000 + __offset_OVLP(i0); }
 334
 335 static inline uint32_t REG_MDP4_OVLP_CFG(uint32_t i0) { return 0x00000004 + __offset_OVLP(i0); }
 336
 337 static inline uint32_t REG_MDP4_OVLP_SIZE(uint32_t i0) { return 0x00000008 + __offset_OVLP(i0); }
 338 #define MDP4_OVLP_SIZE_HEIGHT__MASK                             0xffff0000
 339 #define MDP4_OVLP_SIZE_HEIGHT__SHIFT                            16
 340 static inline uint32_t MDP4_OVLP_SIZE_HEIGHT(uint32_t val)
 341 {
 342         return ((val) << MDP4_OVLP_SIZE_HEIGHT__SHIFT) & MDP4_OVLP_SIZE_HEIGHT__MASK;
 343 }
 344 #define MDP4_OVLP_SIZE_WIDTH__MASK                              0x0000ffff
 345 #define MDP4_OVLP_SIZE_WIDTH__SHIFT                             0
 346 static inline uint32_t MDP4_OVLP_SIZE_WIDTH(uint32_t val)
 347 {
 348         return ((val) << MDP4_OVLP_SIZE_WIDTH__SHIFT) & MDP4_OVLP_SIZE_WIDTH__MASK;
 349 }
 350
 351 static inline uint32_t REG_MDP4_OVLP_BASE(uint32_t i0) { return 0x0000000c + __offset_OVLP(i0); }
 352
 353 static inline uint32_t REG_MDP4_OVLP_STRIDE(uint32_t i0) { return 0x00000010 + __offset_OVLP(i0); }
 354
 355 static inline uint32_t REG_MDP4_OVLP_OPMODE(uint32_t i0) { return 0x00000014 + __offset_OVLP(i0); }
 356
 357 static inline uint32_t __offset_STAGE(uint32_t idx)
 358 {
 359         switch (idx) {
 360                 case 0: return 0x00000104;
 361                 case 1: return 0x00000124;
 362                 case 2: return 0x00000144;
 363                 case 3: return 0x00000160;
 364                 default: return INVALID_IDX(idx);
 365         }
 366 }
 367 static inline uint32_t REG_MDP4_OVLP_STAGE(uint32_t i0, uint32_t i1) { return 0x00000000 + __offset_OVLP(i0) + __offset_STAGE(i1); }
 368
 369 static inline uint32_t REG_MDP4_OVLP_STAGE_OP(uint32_t i0, uint32_t i1) { return 0x00000000 + __offset_OVLP(i0) + __offset_STAGE(i1); }
 370 #define MDP4_OVLP_STAGE_OP_FG_ALPHA__MASK                       0x00000003
 371 #define MDP4_OVLP_STAGE_OP_FG_ALPHA__SHIFT                      0
 372 static inline uint32_t MDP4_OVLP_STAGE_OP_FG_ALPHA(enum mpd4_alpha_type val)
 373 {
 374         return ((val) << MDP4_OVLP_STAGE_OP_FG_ALPHA__SHIFT) & MDP4_OVLP_STAGE_OP_FG_ALPHA__MASK;
 375 }
 376 #define MDP4_OVLP_STAGE_OP_FG_INV_ALPHA                         0x00000004
 377 #define MDP4_OVLP_STAGE_OP_FG_MOD_ALPHA                         0x00000008
 378 #define MDP4_OVLP_STAGE_OP_BG_ALPHA__MASK                       0x00000030
 379 #define MDP4_OVLP_STAGE_OP_BG_ALPHA__SHIFT                      4
 380 static inline uint32_t MDP4_OVLP_STAGE_OP_BG_ALPHA(enum mpd4_alpha_type val)
 381 {
 382         return ((val) << MDP4_OVLP_STAGE_OP_BG_ALPHA__SHIFT) & MDP4_OVLP_STAGE_OP_BG_ALPHA__MASK;
 383 }
 384 #define MDP4_OVLP_STAGE_OP_BG_INV_ALPHA                         0x00000040
 385 #define MDP4_OVLP_STAGE_OP_BG_MOD_ALPHA                         0x00000080
 386 #define MDP4_OVLP_STAGE_OP_FG_TRANSP                            0x00000100
 387 #define MDP4_OVLP_STAGE_OP_BG_TRANSP                            0x00000200
 388
 389 static inline uint32_t REG_MDP4_OVLP_STAGE_FG_ALPHA(uint32_t i0, uint32_t i1) { return 0x00000004 + __offset_OVLP(i0) + __offset_STAGE(i1); }
 390
 391 static inline uint32_t REG_MDP4_OVLP_STAGE_BG_ALPHA(uint32_t i0, uint32_t i1) { return 0x00000008 + __offset_OVLP(i0) + __offset_STAGE(i1); }
 392
 393 static inline uint32_t REG_MDP4_OVLP_STAGE_TRANSP_LOW0(uint32_t i0, uint32_t i1) { return 0x0000000c + __offset_OVLP(i0) + __offset_STAGE(i1); }
 394
 395 static inline uint32_t REG_MDP4_OVLP_STAGE_TRANSP_LOW1(uint32_t i0, uint32_t i1) { return 0x00000010 + __offset_OVLP(i0) + __offset_STAGE(i1); }
 396
 397 static inline uint32_t REG_MDP4_OVLP_STAGE_TRANSP_HIGH0(uint32_t i0, uint32_t i1) { return 0x00000014 + __offset_OVLP(i0) + __offset_STAGE(i1); }
 398
 399 static inline uint32_t REG_MDP4_OVLP_STAGE_TRANSP_HIGH1(uint32_t i0, uint32_t i1) { return 0x00000018 + __offset_OVLP(i0) + __offset_STAGE(i1); }
 400
 401 static inline uint32_t __offset_STAGE_CO3(uint32_t idx)
 402 {
 403         switch (idx) {
 404                 case 0: return 0x00001004;
 405                 case 1: return 0x00001404;
 406                 case 2: return 0x00001804;
 407                 case 3: return 0x00001b84;
 408                 default: return INVALID_IDX(idx);
 409         }
 410 }
 411 static inline uint32_t REG_MDP4_OVLP_STAGE_CO3(uint32_t i0, uint32_t i1) { return 0x00000000 + __offset_OVLP(i0) + __offset_STAGE_CO3(i1); }
 412
 413 static inline uint32_t REG_MDP4_OVLP_STAGE_CO3_SEL(uint32_t i0, uint32_t i1) { return 0x00000000 + __offset_OVLP(i0) + __offset_STAGE_CO3(i1); }
 414 #define MDP4_OVLP_STAGE_CO3_SEL_FG_ALPHA                        0x00000001
 415
 416 static inline uint32_t REG_MDP4_OVLP_TRANSP_LOW0(uint32_t i0) { return 0x00000180 + __offset_OVLP(i0); }
 417
 418 static inline uint32_t REG_MDP4_OVLP_TRANSP_LOW1(uint32_t i0) { return 0x00000184 + __offset_OVLP(i0); }
 419
 420 static inline uint32_t REG_MDP4_OVLP_TRANSP_HIGH0(uint32_t i0) { return 0x00000188 + __offset_OVLP(i0); }
 421
 422 static inline uint32_t REG_MDP4_OVLP_TRANSP_HIGH1(uint32_t i0) { return 0x0000018c + __offset_OVLP(i0); }
 423
 424 static inline uint32_t REG_MDP4_OVLP_CSC_CONFIG(uint32_t i0) { return 0x00000200 + __offset_OVLP(i0); }
 425
 426 static inline uint32_t REG_MDP4_OVLP_CSC(uint32_t i0) { return 0x00002000 + __offset_OVLP(i0); }
 427
 428
 429 static inline uint32_t REG_MDP4_OVLP_CSC_MV(uint32_t i0, uint32_t i1) { return 0x00002400 + __offset_OVLP(i0) + 0x4*i1; }
 430
 431 static inline uint32_t REG_MDP4_OVLP_CSC_MV_VAL(uint32_t i0, uint32_t i1) { return 0x00002400 + __offset_OVLP(i0) + 0x4*i1; }
 432
 433 static inline uint32_t REG_MDP4_OVLP_CSC_PRE_BV(uint32_t i0, uint32_t i1) { return 0x00002500 + __offset_OVLP(i0) + 0x4*i1; }
 434
 435 static inline uint32_t REG_MDP4_OVLP_CSC_PRE_BV_VAL(uint32_t i0, uint32_t i1) { return 0x00002500 + __offset_OVLP(i0) + 0x4*i1; }
 436
 437 static inline uint32_t REG_MDP4_OVLP_CSC_POST_BV(uint32_t i0, uint32_t i1) { return 0x00002580 + __offset_OVLP(i0) + 0x4*i1; }
 438
 439 static inline uint32_t REG_MDP4_OVLP_CSC_POST_BV_VAL(uint32_t i0, uint32_t i1) { return 0x00002580 + __offset_OVLP(i0) + 0x4*i1; }
 440
 441 static inline uint32_t REG_MDP4_OVLP_CSC_PRE_LV(uint32_t i0, uint32_t i1) { return 0x00002600 + __offset_OVLP(i0) + 0x4*i1; }
 442
 443 static inline uint32_t REG_MDP4_OVLP_CSC_PRE_LV_VAL(uint32_t i0, uint32_t i1) { return 0x00002600 + __offset_OVLP(i0) + 0x4*i1; }
 444
 445 static inline uint32_t REG_MDP4_OVLP_CSC_POST_LV(uint32_t i0, uint32_t i1) { return 0x00002680 + __offset_OVLP(i0) + 0x4*i1; }
 446
 447 static inline uint32_t REG_MDP4_OVLP_CSC_POST_LV_VAL(uint32_t i0, uint32_t i1) { return 0x00002680 + __offset_OVLP(i0) + 0x4*i1; }
 448
 449 #define REG_MDP4_DMA_P_OP_MODE                                  0x00090070
 450
 451 static inline uint32_t REG_MDP4_LUTN(uint32_t i0) { return 0x00094800 + 0x400*i0; }
 452
 453 static inline uint32_t REG_MDP4_LUTN_LUT(uint32_t i0, uint32_t i1) { return 0x00094800 + 0x400*i0 + 0x4*i1; }
 454
 455 static inline uint32_t REG_MDP4_LUTN_LUT_VAL(uint32_t i0, uint32_t i1) { return 0x00094800 + 0x400*i0 + 0x4*i1; }
 456
 457 #define REG_MDP4_DMA_S_OP_MODE                                  0x000a0028
 458
 459 static inline uint32_t REG_MDP4_DMA_E_QUANT(uint32_t i0) { return 0x000b0070 + 0x4*i0; }
 460
 461 static inline uint32_t __offset_DMA(enum mdp4_dma idx)
 462 {
 463         switch (idx) {
 464                 case DMA_P: return 0x00090000;
 465                 case DMA_S: return 0x000a0000;
 466                 case DMA_E: return 0x000b0000;
 467                 default: return INVALID_IDX(idx);
 468         }
 469 }
 470 static inline uint32_t REG_MDP4_DMA(enum mdp4_dma i0) { return 0x00000000 + __offset_DMA(i0); }
 471
 472 static inline uint32_t REG_MDP4_DMA_CONFIG(enum mdp4_dma i0) { return 0x00000000 + __offset_DMA(i0); }
 473 #define MDP4_DMA_CONFIG_G_BPC__MASK                             0x00000003
 474 #define MDP4_DMA_CONFIG_G_BPC__SHIFT                            0
 475 static inline uint32_t MDP4_DMA_CONFIG_G_BPC(enum mpd4_bpc val)
 476 {
 477         return ((val) << MDP4_DMA_CONFIG_G_BPC__SHIFT) & MDP4_DMA_CONFIG_G_BPC__MASK;
 478 }
 479 #define MDP4_DMA_CONFIG_B_BPC__MASK                             0x0000000c
 480 #define MDP4_DMA_CONFIG_B_BPC__SHIFT                            2
 481 static inline uint32_t MDP4_DMA_CONFIG_B_BPC(enum mpd4_bpc val)
 482 {
 483         return ((val) << MDP4_DMA_CONFIG_B_BPC__SHIFT) & MDP4_DMA_CONFIG_B_BPC__MASK;
 484 }
 485 #define MDP4_DMA_CONFIG_R_BPC__MASK                             0x00000030
 486 #define MDP4_DMA_CONFIG_R_BPC__SHIFT                            4
 487 static inline uint32_t MDP4_DMA_CONFIG_R_BPC(enum mpd4_bpc val)
 488 {
 489         return ((val) << MDP4_DMA_CONFIG_R_BPC__SHIFT) & MDP4_DMA_CONFIG_R_BPC__MASK;
 490 }
 491 #define MDP4_DMA_CONFIG_PACK_ALIGN_MSB                          0x00000080
 492 #define MDP4_DMA_CONFIG_PACK__MASK                              0x0000ff00
 493 #define MDP4_DMA_CONFIG_PACK__SHIFT                             8
 494 static inline uint32_t MDP4_DMA_CONFIG_PACK(uint32_t val)
 495 {
 496         return ((val) << MDP4_DMA_CONFIG_PACK__SHIFT) & MDP4_DMA_CONFIG_PACK__MASK;
 497 }
 498 #define MDP4_DMA_CONFIG_DEFLKR_EN                               0x01000000
 499 #define MDP4_DMA_CONFIG_DITHER_EN                               0x01000000
 500
 501 static inline uint32_t REG_MDP4_DMA_SRC_SIZE(enum mdp4_dma i0) { return 0x00000004 + __offset_DMA(i0); }
 502 #define MDP4_DMA_SRC_SIZE_HEIGHT__MASK                          0xffff0000
 503 #define MDP4_DMA_SRC_SIZE_HEIGHT__SHIFT                         16
 504 static inline uint32_t MDP4_DMA_SRC_SIZE_HEIGHT(uint32_t val)
 505 {
 506         return ((val) << MDP4_DMA_SRC_SIZE_HEIGHT__SHIFT) & MDP4_DMA_SRC_SIZE_HEIGHT__MASK;
 507 }
 508 #define MDP4_DMA_SRC_SIZE_WIDTH__MASK                           0x0000ffff
 509 #define MDP4_DMA_SRC_SIZE_WIDTH__SHIFT                          0
 510 static inline uint32_t MDP4_DMA_SRC_SIZE_WIDTH(uint32_t val)
 511 {
 512         return ((val) << MDP4_DMA_SRC_SIZE_WIDTH__SHIFT) & MDP4_DMA_SRC_SIZE_WIDTH__MASK;
 513 }
 514
 515 static inline uint32_t REG_MDP4_DMA_SRC_BASE(enum mdp4_dma i0) { return 0x00000008 + __offset_DMA(i0); }
 516
 517 static inline uint32_t REG_MDP4_DMA_SRC_STRIDE(enum mdp4_dma i0) { return 0x0000000c + __offset_DMA(i0); }
 518
 519 static inline uint32_t REG_MDP4_DMA_DST_SIZE(enum mdp4_dma i0) { return 0x00000010 + __offset_DMA(i0); }
 520 #define MDP4_DMA_DST_SIZE_HEIGHT__MASK                          0xffff0000
 521 #define MDP4_DMA_DST_SIZE_HEIGHT__SHIFT                         16
 522 static inline uint32_t MDP4_DMA_DST_SIZE_HEIGHT(uint32_t val)
 523 {
 524         return ((val) << MDP4_DMA_DST_SIZE_HEIGHT__SHIFT) & MDP4_DMA_DST_SIZE_HEIGHT__MASK;
 525 }
 526 #define MDP4_DMA_DST_SIZE_WIDTH__MASK                           0x0000ffff
 527 #define MDP4_DMA_DST_SIZE_WIDTH__SHIFT                          0
 528 static inline uint32_t MDP4_DMA_DST_SIZE_WIDTH(uint32_t val)
 529 {
 530         return ((val) << MDP4_DMA_DST_SIZE_WIDTH__SHIFT) & MDP4_DMA_DST_SIZE_WIDTH__MASK;
 531 }
 532
 533 static inline uint32_t REG_MDP4_DMA_CURSOR_SIZE(enum mdp4_dma i0) { return 0x00000044 + __offset_DMA(i0); }
 534 #define MDP4_DMA_CURSOR_SIZE_WIDTH__MASK                        0x0000007f
 535 #define MDP4_DMA_CURSOR_SIZE_WIDTH__SHIFT                       0
 536 static inline uint32_t MDP4_DMA_CURSOR_SIZE_WIDTH(uint32_t val)
 537 {
 538         return ((val) << MDP4_DMA_CURSOR_SIZE_WIDTH__SHIFT) & MDP4_DMA_CURSOR_SIZE_WIDTH__MASK;
 539 }
 540 #define MDP4_DMA_CURSOR_SIZE_HEIGHT__MASK                       0x007f0000
 541 #define MDP4_DMA_CURSOR_SIZE_HEIGHT__SHIFT                      16
 542 static inline uint32_t MDP4_DMA_CURSOR_SIZE_HEIGHT(uint32_t val)
 543 {
 544         return ((val) << MDP4_DMA_CURSOR_SIZE_HEIGHT__SHIFT) & MDP4_DMA_CURSOR_SIZE_HEIGHT__MASK;
 545 }
 546
 547 static inline uint32_t REG_MDP4_DMA_CURSOR_BASE(enum mdp4_dma i0) { return 0x00000048 + __offset_DMA(i0); }
 548
 549 static inline uint32_t REG_MDP4_DMA_CURSOR_POS(enum mdp4_dma i0) { return 0x0000004c + __offset_DMA(i0); }
 550 #define MDP4_DMA_CURSOR_POS_X__MASK                             0x0000ffff
 551 #define MDP4_DMA_CURSOR_POS_X__SHIFT                            0
 552 static inline uint32_t MDP4_DMA_CURSOR_POS_X(uint32_t val)
 553 {
 554         return ((val) << MDP4_DMA_CURSOR_POS_X__SHIFT) & MDP4_DMA_CURSOR_POS_X__MASK;
 555 }
 556 #define MDP4_DMA_CURSOR_POS_Y__MASK                             0xffff0000
 557 #define MDP4_DMA_CURSOR_POS_Y__SHIFT                            16
 558 static inline uint32_t MDP4_DMA_CURSOR_POS_Y(uint32_t val)
 559 {
 560         return ((val) << MDP4_DMA_CURSOR_POS_Y__SHIFT) & MDP4_DMA_CURSOR_POS_Y__MASK;
 561 }
 562
 563 static inline uint32_t REG_MDP4_DMA_CURSOR_BLEND_CONFIG(enum mdp4_dma i0) { return 0x00000060 + __offset_DMA(i0); }
 564 #define MDP4_DMA_CURSOR_BLEND_CONFIG_CURSOR_EN                  0x00000001
 565 #define MDP4_DMA_CURSOR_BLEND_CONFIG_FORMAT__MASK               0x00000006
 566 #define MDP4_DMA_CURSOR_BLEND_CONFIG_FORMAT__SHIFT              1
 567 static inline uint32_t MDP4_DMA_CURSOR_BLEND_CONFIG_FORMAT(enum mdp4_cursor_format val)
 568 {
 569         return ((val) << MDP4_DMA_CURSOR_BLEND_CONFIG_FORMAT__SHIFT) & MDP4_DMA_CURSOR_BLEND_CONFIG_FORMAT__MASK;
 570 }
 571 #define MDP4_DMA_CURSOR_BLEND_CONFIG_TRANSP_EN                  0x00000008
 572
 573 static inline uint32_t REG_MDP4_DMA_CURSOR_BLEND_PARAM(enum mdp4_dma i0) { return 0x00000064 + __offset_DMA(i0); }
 574
 575 static inline uint32_t REG_MDP4_DMA_BLEND_TRANS_LOW(enum mdp4_dma i0) { return 0x00000068 + __offset_DMA(i0); }
 576
 577 static inline uint32_t REG_MDP4_DMA_BLEND_TRANS_HIGH(enum mdp4_dma i0) { return 0x0000006c + __offset_DMA(i0); }
 578
 579 static inline uint32_t REG_MDP4_DMA_FETCH_CONFIG(enum mdp4_dma i0) { return 0x00001004 + __offset_DMA(i0); }
 580
 581 static inline uint32_t REG_MDP4_DMA_CSC(enum mdp4_dma i0) { return 0x00003000 + __offset_DMA(i0); }
 582
 583
 584 static inline uint32_t REG_MDP4_DMA_CSC_MV(enum mdp4_dma i0, uint32_t i1) { return 0x00003400 + __offset_DMA(i0) + 0x4*i1; }
 585
 586 static inline uint32_t REG_MDP4_DMA_CSC_MV_VAL(enum mdp4_dma i0, uint32_t i1) { return 0x00003400 + __offset_DMA(i0) + 0x4*i1; }
 587
 588 static inline uint32_t REG_MDP4_DMA_CSC_PRE_BV(enum mdp4_dma i0, uint32_t i1) { return 0x00003500 + __offset_DMA(i0) + 0x4*i1; }
 589
 590 static inline uint32_t REG_MDP4_DMA_CSC_PRE_BV_VAL(enum mdp4_dma i0, uint32_t i1) { return 0x00003500 + __offset_DMA(i0) + 0x4*i1; }
 591
 592 static inline uint32_t REG_MDP4_DMA_CSC_POST_BV(enum mdp4_dma i0, uint32_t i1) { return 0x00003580 + __offset_DMA(i0) + 0x4*i1; }
 593
 594 static inline uint32_t REG_MDP4_DMA_CSC_POST_BV_VAL(enum mdp4_dma i0, uint32_t i1) { return 0x00003580 + __offset_DMA(i0) + 0x4*i1; }
 595
 596 static inline uint32_t REG_MDP4_DMA_CSC_PRE_LV(enum mdp4_dma i0, uint32_t i1) { return 0x00003600 + __offset_DMA(i0) + 0x4*i1; }
 597
 598 static inline uint32_t REG_MDP4_DMA_CSC_PRE_LV_VAL(enum mdp4_dma i0, uint32_t i1) { return 0x00003600 + __offset_DMA(i0) + 0x4*i1; }
 599
 600 static inline uint32_t REG_MDP4_DMA_CSC_POST_LV(enum mdp4_dma i0, uint32_t i1) { return 0x00003680 + __offset_DMA(i0) + 0x4*i1; }
 601
 602 static inline uint32_t REG_MDP4_DMA_CSC_POST_LV_VAL(enum mdp4_dma i0, uint32_t i1) { return 0x00003680 + __offset_DMA(i0) + 0x4*i1; }
 603
 604 static inline uint32_t REG_MDP4_PIPE(enum mpd4_pipe i0) { return 0x00020000 + 0x10000*i0; }
 605
 606 static inline uint32_t REG_MDP4_PIPE_SRC_SIZE(enum mpd4_pipe i0) { return 0x00020000 + 0x10000*i0; }
 607 #define MDP4_PIPE_SRC_SIZE_HEIGHT__MASK                         0xffff0000
 608 #define MDP4_PIPE_SRC_SIZE_HEIGHT__SHIFT                        16
 609 static inline uint32_t MDP4_PIPE_SRC_SIZE_HEIGHT(uint32_t val)
 610 {
 611         return ((val) << MDP4_PIPE_SRC_SIZE_HEIGHT__SHIFT) & MDP4_PIPE_SRC_SIZE_HEIGHT__MASK;
 612 }
 613 #define MDP4_PIPE_SRC_SIZE_WIDTH__MASK                          0x0000ffff
 614 #define MDP4_PIPE_SRC_SIZE_WIDTH__SHIFT                         0
 615 static inline uint32_t MDP4_PIPE_SRC_SIZE_WIDTH(uint32_t val)
 616 {
 617         return ((val) << MDP4_PIPE_SRC_SIZE_WIDTH__SHIFT) & MDP4_PIPE_SRC_SIZE_WIDTH__MASK;
 618 }
 619
 620 static inline uint32_t REG_MDP4_PIPE_SRC_XY(enum mpd4_pipe i0) { return 0x00020004 + 0x10000*i0; }
 621 #define MDP4_PIPE_SRC_XY_Y__MASK                                0xffff0000
 622 #define MDP4_PIPE_SRC_XY_Y__SHIFT                               16
 623 static inline uint32_t MDP4_PIPE_SRC_XY_Y(uint32_t val)
 624 {
 625         return ((val) << MDP4_PIPE_SRC_XY_Y__SHIFT) & MDP4_PIPE_SRC_XY_Y__MASK;
 626 }
 627 #define MDP4_PIPE_SRC_XY_X__MASK                                0x0000ffff
 628 #define MDP4_PIPE_SRC_XY_X__SHIFT                               0
 629 static inline uint32_t MDP4_PIPE_SRC_XY_X(uint32_t val)
 630 {
 631         return ((val) << MDP4_PIPE_SRC_XY_X__SHIFT) & MDP4_PIPE_SRC_XY_X__MASK;
 632 }
 633
 634 static inline uint32_t REG_MDP4_PIPE_DST_SIZE(enum mpd4_pipe i0) { return 0x00020008 + 0x10000*i0; }
 635 #define MDP4_PIPE_DST_SIZE_HEIGHT__MASK                         0xffff0000
 636 #define MDP4_PIPE_DST_SIZE_HEIGHT__SHIFT                        16
 637 static inline uint32_t MDP4_PIPE_DST_SIZE_HEIGHT(uint32_t val)
 638 {
 639         return ((val) << MDP4_PIPE_DST_SIZE_HEIGHT__SHIFT) & MDP4_PIPE_DST_SIZE_HEIGHT__MASK;
 640 }
 641 #define MDP4_PIPE_DST_SIZE_WIDTH__MASK                          0x0000ffff
 642 #define MDP4_PIPE_DST_SIZE_WIDTH__SHIFT                         0
 643 static inline uint32_t MDP4_PIPE_DST_SIZE_WIDTH(uint32_t val)
 644 {
 645         return ((val) << MDP4_PIPE_DST_SIZE_WIDTH__SHIFT) & MDP4_PIPE_DST_SIZE_WIDTH__MASK;
 646 }
 647
 648 static inline uint32_t REG_MDP4_PIPE_DST_XY(enum mpd4_pipe i0) { return 0x0002000c + 0x10000*i0; }
 649 #define MDP4_PIPE_DST_XY_Y__MASK                                0xffff0000
 650 #define MDP4_PIPE_DST_XY_Y__SHIFT                               16
 651 static inline uint32_t MDP4_PIPE_DST_XY_Y(uint32_t val)
 652 {
 653         return ((val) << MDP4_PIPE_DST_XY_Y__SHIFT) & MDP4_PIPE_DST_XY_Y__MASK;
 654 }
 655 #define MDP4_PIPE_DST_XY_X__MASK                                0x0000ffff
 656 #define MDP4_PIPE_DST_XY_X__SHIFT                               0
 657 static inline uint32_t MDP4_PIPE_DST_XY_X(uint32_t val)
 658 {
 659         return ((val) << MDP4_PIPE_DST_XY_X__SHIFT) & MDP4_PIPE_DST_XY_X__MASK;
 660 }
 661
 662 static inline uint32_t REG_MDP4_PIPE_SRCP0_BASE(enum mpd4_pipe i0) { return 0x00020010 + 0x10000*i0; }
 663
 664 static inline uint32_t REG_MDP4_PIPE_SRCP1_BASE(enum mpd4_pipe i0) { return 0x00020014 + 0x10000*i0; }
 665
 666 static inline uint32_t REG_MDP4_PIPE_SRCP2_BASE(enum mpd4_pipe i0) { return 0x00020018 + 0x10000*i0; }
 667
 668 static inline uint32_t REG_MDP4_PIPE_SRC_STRIDE_A(enum mpd4_pipe i0) { return 0x00020040 + 0x10000*i0; }
 669 #define MDP4_PIPE_SRC_STRIDE_A_P0__MASK                         0x0000ffff
 670 #define MDP4_PIPE_SRC_STRIDE_A_P0__SHIFT                        0
 671 static inline uint32_t MDP4_PIPE_SRC_STRIDE_A_P0(uint32_t val)
 672 {
 673         return ((val) << MDP4_PIPE_SRC_STRIDE_A_P0__SHIFT) & MDP4_PIPE_SRC_STRIDE_A_P0__MASK;
 674 }
 675 #define MDP4_PIPE_SRC_STRIDE_A_P1__MASK                         0xffff0000
 676 #define MDP4_PIPE_SRC_STRIDE_A_P1__SHIFT                        16
 677 static inline uint32_t MDP4_PIPE_SRC_STRIDE_A_P1(uint32_t val)
 678 {
 679         return ((val) << MDP4_PIPE_SRC_STRIDE_A_P1__SHIFT) & MDP4_PIPE_SRC_STRIDE_A_P1__MASK;
 680 }
 681
 682 static inline uint32_t REG_MDP4_PIPE_SRC_STRIDE_B(enum mpd4_pipe i0) { return 0x00020044 + 0x10000*i0; }
 683 #define MDP4_PIPE_SRC_STRIDE_B_P2__MASK                         0x0000ffff
 684 #define MDP4_PIPE_SRC_STRIDE_B_P2__SHIFT                        0
 685 static inline uint32_t MDP4_PIPE_SRC_STRIDE_B_P2(uint32_t val)
 686 {
 687         return ((val) << MDP4_PIPE_SRC_STRIDE_B_P2__SHIFT) & MDP4_PIPE_SRC_STRIDE_B_P2__MASK;
 688 }
 689 #define MDP4_PIPE_SRC_STRIDE_B_P3__MASK                         0xffff0000
 690 #define MDP4_PIPE_SRC_STRIDE_B_P3__SHIFT                        16
 691 static inline uint32_t MDP4_PIPE_SRC_STRIDE_B_P3(uint32_t val)
 692 {
 693         return ((val) << MDP4_PIPE_SRC_STRIDE_B_P3__SHIFT) & MDP4_PIPE_SRC_STRIDE_B_P3__MASK;
 694 }
 695
 696 static inline uint32_t REG_MDP4_PIPE_FRAME_SIZE(enum mpd4_pipe i0) { return 0x00020048 + 0x10000*i0; }
 697 #define MDP4_PIPE_FRAME_SIZE_HEIGHT__MASK                       0xffff0000
 698 #define MDP4_PIPE_FRAME_SIZE_HEIGHT__SHIFT                      16
 699 static inline uint32_t MDP4_PIPE_FRAME_SIZE_HEIGHT(uint32_t val)
 700 {
 701         return ((val) << MDP4_PIPE_FRAME_SIZE_HEIGHT__SHIFT) & MDP4_PIPE_FRAME_SIZE_HEIGHT__MASK;
 702 }
 703 #define MDP4_PIPE_FRAME_SIZE_WIDTH__MASK                        0x0000ffff
 704 #define MDP4_PIPE_FRAME_SIZE_WIDTH__SHIFT                       0
 705 static inline uint32_t MDP4_PIPE_FRAME_SIZE_WIDTH(uint32_t val)
 706 {
 707         return ((val) << MDP4_PIPE_FRAME_SIZE_WIDTH__SHIFT) & MDP4_PIPE_FRAME_SIZE_WIDTH__MASK;
 708 }
 709
 710 static inline uint32_t REG_MDP4_PIPE_SRC_FORMAT(enum mpd4_pipe i0) { return 0x00020050 + 0x10000*i0; }
 711 #define MDP4_PIPE_SRC_FORMAT_G_BPC__MASK                        0x00000003
 712 #define MDP4_PIPE_SRC_FORMAT_G_BPC__SHIFT                       0
 713 static inline uint32_t MDP4_PIPE_SRC_FORMAT_G_BPC(enum mpd4_bpc val)
 714 {
 715         return ((val) << MDP4_PIPE_SRC_FORMAT_G_BPC__SHIFT) & MDP4_PIPE_SRC_FORMAT_G_BPC__MASK;
 716 }
 717 #define MDP4_PIPE_SRC_FORMAT_B_BPC__MASK                        0x0000000c
 718 #define MDP4_PIPE_SRC_FORMAT_B_BPC__SHIFT                       2
 719 static inline uint32_t MDP4_PIPE_SRC_FORMAT_B_BPC(enum mpd4_bpc val)
 720 {
 721         return ((val) << MDP4_PIPE_SRC_FORMAT_B_BPC__SHIFT) & MDP4_PIPE_SRC_FORMAT_B_BPC__MASK;
 722 }
 723 #define MDP4_PIPE_SRC_FORMAT_R_BPC__MASK                        0x00000030
 724 #define MDP4_PIPE_SRC_FORMAT_R_BPC__SHIFT                       4
 725 static inline uint32_t MDP4_PIPE_SRC_FORMAT_R_BPC(enum mpd4_bpc val)
 726 {
 727         return ((val) << MDP4_PIPE_SRC_FORMAT_R_BPC__SHIFT) & MDP4_PIPE_SRC_FORMAT_R_BPC__MASK;
 728 }
 729 #define MDP4_PIPE_SRC_FORMAT_A_BPC__MASK                        0x000000c0
 730 #define MDP4_PIPE_SRC_FORMAT_A_BPC__SHIFT                       6
 731 static inline uint32_t MDP4_PIPE_SRC_FORMAT_A_BPC(enum mpd4_bpc_alpha val)
 732 {
 733         return ((val) << MDP4_PIPE_SRC_FORMAT_A_BPC__SHIFT) & MDP4_PIPE_SRC_FORMAT_A_BPC__MASK;
 734 }
 735 #define MDP4_PIPE_SRC_FORMAT_ALPHA_ENABLE                       0x00000100
 736 #define MDP4_PIPE_SRC_FORMAT_CPP__MASK                          0x00000600
 737 #define MDP4_PIPE_SRC_FORMAT_CPP__SHIFT                         9
 738 static inline uint32_t MDP4_PIPE_SRC_FORMAT_CPP(uint32_t val)
 739 {
 740         return ((val) << MDP4_PIPE_SRC_FORMAT_CPP__SHIFT) & MDP4_PIPE_SRC_FORMAT_CPP__MASK;
 741 }
 742 #define MDP4_PIPE_SRC_FORMAT_ROTATED_90                         0x00001000
 743 #define MDP4_PIPE_SRC_FORMAT_UNPACK_COUNT__MASK                 0x00006000
 744 #define MDP4_PIPE_SRC_FORMAT_UNPACK_COUNT__SHIFT                13
 745 static inline uint32_t MDP4_PIPE_SRC_FORMAT_UNPACK_COUNT(uint32_t val)
 746 {
 747         return ((val) << MDP4_PIPE_SRC_FORMAT_UNPACK_COUNT__SHIFT) & MDP4_PIPE_SRC_FORMAT_UNPACK_COUNT__MASK;
 748 }
 749 #define MDP4_PIPE_SRC_FORMAT_UNPACK_TIGHT                       0x00020000
 750 #define MDP4_PIPE_SRC_FORMAT_UNPACK_ALIGN_MSB                   0x00040000
 751 #define MDP4_PIPE_SRC_FORMAT_SOLID_FILL                         0x00400000
 752
 753 static inline uint32_t REG_MDP4_PIPE_SRC_UNPACK(enum mpd4_pipe i0) { return 0x00020054 + 0x10000*i0; }
 754 #define MDP4_PIPE_SRC_UNPACK_ELEM0__MASK                        0x000000ff
 755 #define MDP4_PIPE_SRC_UNPACK_ELEM0__SHIFT                       0
 756 static inline uint32_t MDP4_PIPE_SRC_UNPACK_ELEM0(uint32_t val)
 757 {
 758         return ((val) << MDP4_PIPE_SRC_UNPACK_ELEM0__SHIFT) & MDP4_PIPE_SRC_UNPACK_ELEM0__MASK;
 759 }
 760 #define MDP4_PIPE_SRC_UNPACK_ELEM1__MASK                        0x0000ff00
 761 #define MDP4_PIPE_SRC_UNPACK_ELEM1__SHIFT                       8
 762 static inline uint32_t MDP4_PIPE_SRC_UNPACK_ELEM1(uint32_t val)
 763 {
 764         return ((val) << MDP4_PIPE_SRC_UNPACK_ELEM1__SHIFT) & MDP4_PIPE_SRC_UNPACK_ELEM1__MASK;
 765 }
 766 #define MDP4_PIPE_SRC_UNPACK_ELEM2__MASK                        0x00ff0000
 767 #define MDP4_PIPE_SRC_UNPACK_ELEM2__SHIFT                       16
 768 static inline uint32_t MDP4_PIPE_SRC_UNPACK_ELEM2(uint32_t val)
 769 {
 770         return ((val) << MDP4_PIPE_SRC_UNPACK_ELEM2__SHIFT) & MDP4_PIPE_SRC_UNPACK_ELEM2__MASK;
 771 }
 772 #define MDP4_PIPE_SRC_UNPACK_ELEM3__MASK                        0xff000000
 773 #define MDP4_PIPE_SRC_UNPACK_ELEM3__SHIFT                       24
 774 static inline uint32_t MDP4_PIPE_SRC_UNPACK_ELEM3(uint32_t val)
 775 {
 776         return ((val) << MDP4_PIPE_SRC_UNPACK_ELEM3__SHIFT) & MDP4_PIPE_SRC_UNPACK_ELEM3__MASK;
 777 }
 778
 779 static inline uint32_t REG_MDP4_PIPE_OP_MODE(enum mpd4_pipe i0) { return 0x00020058 + 0x10000*i0; }
 780 #define MDP4_PIPE_OP_MODE_SCALEX_EN                             0x00000001
 781 #define MDP4_PIPE_OP_MODE_SCALEY_EN                             0x00000002
 782 #define MDP4_PIPE_OP_MODE_SRC_YCBCR                             0x00000200
 783 #define MDP4_PIPE_OP_MODE_DST_YCBCR                             0x00000400
 784 #define MDP4_PIPE_OP_MODE_CSC_EN                                0x00000800
 785 #define MDP4_PIPE_OP_MODE_FLIP_LR                               0x00002000
 786 #define MDP4_PIPE_OP_MODE_FLIP_UD                               0x00004000
 787 #define MDP4_PIPE_OP_MODE_DITHER_EN                             0x00008000
 788 #define MDP4_PIPE_OP_MODE_IGC_LUT_EN                            0x00010000
 789 #define MDP4_PIPE_OP_MODE_DEINT_EN                              0x00040000
 790 #define MDP4_PIPE_OP_MODE_DEINT_ODD_REF                         0x00080000
 791
 792 static inline uint32_t REG_MDP4_PIPE_PHASEX_STEP(enum mpd4_pipe i0) { return 0x0002005c + 0x10000*i0; }
 793
 794 static inline uint32_t REG_MDP4_PIPE_PHASEY_STEP(enum mpd4_pipe i0) { return 0x00020060 + 0x10000*i0; }
 795
 796 static inline uint32_t REG_MDP4_PIPE_FETCH_CONFIG(enum mpd4_pipe i0) { return 0x00021004 + 0x10000*i0; }
 797
 798 static inline uint32_t REG_MDP4_PIPE_SOLID_COLOR(enum mpd4_pipe i0) { return 0x00021008 + 0x10000*i0; }
 799
 800 static inline uint32_t REG_MDP4_PIPE_CSC(enum mpd4_pipe i0) { return 0x00024000 + 0x10000*i0; }
 801
 802
 803 static inline uint32_t REG_MDP4_PIPE_CSC_MV(enum mpd4_pipe i0, uint32_t i1) { return 0x00024400 + 0x10000*i0 + 0x4*i1; }
 804
 805 static inline uint32_t REG_MDP4_PIPE_CSC_MV_VAL(enum mpd4_pipe i0, uint32_t i1) { return 0x00024400 + 0x10000*i0 + 0x4*i1; }
 806
 807 static inline uint32_t REG_MDP4_PIPE_CSC_PRE_BV(enum mpd4_pipe i0, uint32_t i1) { return 0x00024500 + 0x10000*i0 + 0x4*i1; }
 808
 809 static inline uint32_t REG_MDP4_PIPE_CSC_PRE_BV_VAL(enum mpd4_pipe i0, uint32_t i1) { return 0x00024500 + 0x10000*i0 + 0x4*i1; }
 810
 811 static inline uint32_t REG_MDP4_PIPE_CSC_POST_BV(enum mpd4_pipe i0, uint32_t i1) { return 0x00024580 + 0x10000*i0 + 0x4*i1; }
 812
 813 static inline uint32_t REG_MDP4_PIPE_CSC_POST_BV_VAL(enum mpd4_pipe i0, uint32_t i1) { return 0x00024580 + 0x10000*i0 + 0x4*i1; }
 814
 815 static inline uint32_t REG_MDP4_PIPE_CSC_PRE_LV(enum mpd4_pipe i0, uint32_t i1) { return 0x00024600 + 0x10000*i0 + 0x4*i1; }
 816
 817 static inline uint32_t REG_MDP4_PIPE_CSC_PRE_LV_VAL(enum mpd4_pipe i0, uint32_t i1) { return 0x00024600 + 0x10000*i0 + 0x4*i1; }
 818
 819 static inline uint32_t REG_MDP4_PIPE_CSC_POST_LV(enum mpd4_pipe i0, uint32_t i1) { return 0x00024680 + 0x10000*i0 + 0x4*i1; }
 820
 821 static inline uint32_t REG_MDP4_PIPE_CSC_POST_LV_VAL(enum mpd4_pipe i0, uint32_t i1) { return 0x00024680 + 0x10000*i0 + 0x4*i1; }
 822
 823 #define REG_MDP4_LCDC                                           0x000c0000
 824
 825 #define REG_MDP4_LCDC_ENABLE                                    0x000c0000
 826
 827 #define REG_MDP4_LCDC_HSYNC_CTRL                                0x000c0004
 828 #define MDP4_LCDC_HSYNC_CTRL_PULSEW__MASK                       0x0000ffff
 829 #define MDP4_LCDC_HSYNC_CTRL_PULSEW__SHIFT                      0
 830 static inline uint32_t MDP4_LCDC_HSYNC_CTRL_PULSEW(uint32_t val)
 831 {
 832         return ((val) << MDP4_LCDC_HSYNC_CTRL_PULSEW__SHIFT) & MDP4_LCDC_HSYNC_CTRL_PULSEW__MASK;
 833 }
 834 #define MDP4_LCDC_HSYNC_CTRL_PERIOD__MASK                       0xffff0000
 835 #define MDP4_LCDC_HSYNC_CTRL_PERIOD__SHIFT                      16
 836 static inline uint32_t MDP4_LCDC_HSYNC_CTRL_PERIOD(uint32_t val)
 837 {
 838         return ((val) << MDP4_LCDC_HSYNC_CTRL_PERIOD__SHIFT) & MDP4_LCDC_HSYNC_CTRL_PERIOD__MASK;
 839 }
 840
 841 #define REG_MDP4_LCDC_VSYNC_PERIOD                              0x000c0008
 842
 843 #define REG_MDP4_LCDC_VSYNC_LEN                                 0x000c000c
 844
 845 #define REG_MDP4_LCDC_DISPLAY_HCTRL                             0x000c0010
 846 #define MDP4_LCDC_DISPLAY_HCTRL_START__MASK                     0x0000ffff
 847 #define MDP4_LCDC_DISPLAY_HCTRL_START__SHIFT                    0
 848 static inline uint32_t MDP4_LCDC_DISPLAY_HCTRL_START(uint32_t val)
 849 {
 850         return ((val) << MDP4_LCDC_DISPLAY_HCTRL_START__SHIFT) & MDP4_LCDC_DISPLAY_HCTRL_START__MASK;
 851 }
 852 #define MDP4_LCDC_DISPLAY_HCTRL_END__MASK                       0xffff0000
 853 #define MDP4_LCDC_DISPLAY_HCTRL_END__SHIFT                      16
 854 static inline uint32_t MDP4_LCDC_DISPLAY_HCTRL_END(uint32_t val)
 855 {
 856         return ((val) << MDP4_LCDC_DISPLAY_HCTRL_END__SHIFT) & MDP4_LCDC_DISPLAY_HCTRL_END__MASK;
 857 }
 858
 859 #define REG_MDP4_LCDC_DISPLAY_VSTART                            0x000c0014
 860
 861 #define REG_MDP4_LCDC_DISPLAY_VEND                              0x000c0018
 862
 863 #define REG_MDP4_LCDC_ACTIVE_HCTL                               0x000c001c
 864 #define MDP4_LCDC_ACTIVE_HCTL_START__MASK                       0x00007fff
 865 #define MDP4_LCDC_ACTIVE_HCTL_START__SHIFT                      0
 866 static inline uint32_t MDP4_LCDC_ACTIVE_HCTL_START(uint32_t val)
 867 {
 868         return ((val) << MDP4_LCDC_ACTIVE_HCTL_START__SHIFT) & MDP4_LCDC_ACTIVE_HCTL_START__MASK;
 869 }
 870 #define MDP4_LCDC_ACTIVE_HCTL_END__MASK                         0x7fff0000
 871 #define MDP4_LCDC_ACTIVE_HCTL_END__SHIFT                        16
 872 static inline uint32_t MDP4_LCDC_ACTIVE_HCTL_END(uint32_t val)
 873 {
 874         return ((val) << MDP4_LCDC_ACTIVE_HCTL_END__SHIFT) & MDP4_LCDC_ACTIVE_HCTL_END__MASK;
 875 }
 876 #define MDP4_LCDC_ACTIVE_HCTL_ACTIVE_START_X                    0x80000000
 877
 878 #define REG_MDP4_LCDC_ACTIVE_VSTART                             0x000c0020
 879
 880 #define REG_MDP4_LCDC_ACTIVE_VEND                               0x000c0024
 881
 882 #define REG_MDP4_LCDC_BORDER_CLR                                0x000c0028
 883
 884 #define REG_MDP4_LCDC_UNDERFLOW_CLR                             0x000c002c
 885 #define MDP4_LCDC_UNDERFLOW_CLR_COLOR__MASK                     0x00ffffff
 886 #define MDP4_LCDC_UNDERFLOW_CLR_COLOR__SHIFT                    0
 887 static inline uint32_t MDP4_LCDC_UNDERFLOW_CLR_COLOR(uint32_t val)
 888 {
 889         return ((val) << MDP4_LCDC_UNDERFLOW_CLR_COLOR__SHIFT) & MDP4_LCDC_UNDERFLOW_CLR_COLOR__MASK;
 890 }
 891 #define MDP4_LCDC_UNDERFLOW_CLR_ENABLE_RECOVERY                 0x80000000
 892
 893 #define REG_MDP4_LCDC_HSYNC_SKEW                                0x000c0030
 894
 895 #define REG_MDP4_LCDC_TEST_CNTL                                 0x000c0034
 896
 897 #define REG_MDP4_LCDC_CTRL_POLARITY                             0x000c0038
 898 #define MDP4_LCDC_CTRL_POLARITY_HSYNC_LOW                       0x00000001
 899 #define MDP4_LCDC_CTRL_POLARITY_VSYNC_LOW                       0x00000002
 900 #define MDP4_LCDC_CTRL_POLARITY_DATA_EN_LOW                     0x00000004
 901
 902 #define REG_MDP4_DTV                                            0x000d0000
 903
 904 #define REG_MDP4_DTV_ENABLE                                     0x000d0000
 905
 906 #define REG_MDP4_DTV_HSYNC_CTRL                                 0x000d0004
 907 #define MDP4_DTV_HSYNC_CTRL_PULSEW__MASK                        0x0000ffff
 908 #define MDP4_DTV_HSYNC_CTRL_PULSEW__SHIFT                       0
 909 static inline uint32_t MDP4_DTV_HSYNC_CTRL_PULSEW(uint32_t val)
 910 {
 911         return ((val) << MDP4_DTV_HSYNC_CTRL_PULSEW__SHIFT) & MDP4_DTV_HSYNC_CTRL_PULSEW__MASK;
 912 }
 913 #define MDP4_DTV_HSYNC_CTRL_PERIOD__MASK                        0xffff0000
 914 #define MDP4_DTV_HSYNC_CTRL_PERIOD__SHIFT                       16
 915 static inline uint32_t MDP4_DTV_HSYNC_CTRL_PERIOD(uint32_t val)
 916 {
 917         return ((val) << MDP4_DTV_HSYNC_CTRL_PERIOD__SHIFT) & MDP4_DTV_HSYNC_CTRL_PERIOD__MASK;
 918 }
 919
 920 #define REG_MDP4_DTV_VSYNC_PERIOD                               0x000d0008
 921
 922 #define REG_MDP4_DTV_VSYNC_LEN                                  0x000d000c
 923
 924 #define REG_MDP4_DTV_DISPLAY_HCTRL                              0x000d0018
 925 #define MDP4_DTV_DISPLAY_HCTRL_START__MASK                      0x0000ffff
 926 #define MDP4_DTV_DISPLAY_HCTRL_START__SHIFT                     0
 927 static inline uint32_t MDP4_DTV_DISPLAY_HCTRL_START(uint32_t val)
 928 {
 929         return ((val) << MDP4_DTV_DISPLAY_HCTRL_START__SHIFT) & MDP4_DTV_DISPLAY_HCTRL_START__MASK;
 930 }
 931 #define MDP4_DTV_DISPLAY_HCTRL_END__MASK                        0xffff0000
 932 #define MDP4_DTV_DISPLAY_HCTRL_END__SHIFT                       16
 933 static inline uint32_t MDP4_DTV_DISPLAY_HCTRL_END(uint32_t val)
 934 {
 935         return ((val) << MDP4_DTV_DISPLAY_HCTRL_END__SHIFT) & MDP4_DTV_DISPLAY_HCTRL_END__MASK;
 936 }
 937
 938 #define REG_MDP4_DTV_DISPLAY_VSTART                             0x000d001c
 939
 940 #define REG_MDP4_DTV_DISPLAY_VEND                               0x000d0020
 941
 942 #define REG_MDP4_DTV_ACTIVE_HCTL                                0x000d002c
 943 #define MDP4_DTV_ACTIVE_HCTL_START__MASK                        0x00007fff
 944 #define MDP4_DTV_ACTIVE_HCTL_START__SHIFT                       0
 945 static inline uint32_t MDP4_DTV_ACTIVE_HCTL_START(uint32_t val)
 946 {
 947         return ((val) << MDP4_DTV_ACTIVE_HCTL_START__SHIFT) & MDP4_DTV_ACTIVE_HCTL_START__MASK;
 948 }
 949 #define MDP4_DTV_ACTIVE_HCTL_END__MASK                          0x7fff0000
 950 #define MDP4_DTV_ACTIVE_HCTL_END__SHIFT                         16
 951 static inline uint32_t MDP4_DTV_ACTIVE_HCTL_END(uint32_t val)
 952 {
 953         return ((val) << MDP4_DTV_ACTIVE_HCTL_END__SHIFT) & MDP4_DTV_ACTIVE_HCTL_END__MASK;
 954 }
 955 #define MDP4_DTV_ACTIVE_HCTL_ACTIVE_START_X                     0x80000000
 956
 957 #define REG_MDP4_DTV_ACTIVE_VSTART                              0x000d0030
 958
 959 #define REG_MDP4_DTV_ACTIVE_VEND                                0x000d0038
 960
 961 #define REG_MDP4_DTV_BORDER_CLR                                 0x000d0040
 962
 963 #define REG_MDP4_DTV_UNDERFLOW_CLR                              0x000d0044
 964 #define MDP4_DTV_UNDERFLOW_CLR_COLOR__MASK                      0x00ffffff
 965 #define MDP4_DTV_UNDERFLOW_CLR_COLOR__SHIFT                     0
 966 static inline uint32_t MDP4_DTV_UNDERFLOW_CLR_COLOR(uint32_t val)
 967 {
 968         return ((val) << MDP4_DTV_UNDERFLOW_CLR_COLOR__SHIFT) & MDP4_DTV_UNDERFLOW_CLR_COLOR__MASK;
 969 }
 970 #define MDP4_DTV_UNDERFLOW_CLR_ENABLE_RECOVERY                  0x80000000
 971
 972 #define REG_MDP4_DTV_HSYNC_SKEW                                 0x000d0048
 973
 974 #define REG_MDP4_DTV_TEST_CNTL                                  0x000d004c
 975
 976 #define REG_MDP4_DTV_CTRL_POLARITY                              0x000d0050
 977 #define MDP4_DTV_CTRL_POLARITY_HSYNC_LOW                        0x00000001
 978 #define MDP4_DTV_CTRL_POLARITY_VSYNC_LOW                        0x00000002
 979 #define MDP4_DTV_CTRL_POLARITY_DATA_EN_LOW                      0x00000004
 980
 981 #define REG_MDP4_DSI                                            0x000e0000
 982
 983 #define REG_MDP4_DSI_ENABLE                                     0x000e0000
 984
 985 #define REG_MDP4_DSI_HSYNC_CTRL                                 0x000e0004
 986 #define MDP4_DSI_HSYNC_CTRL_PULSEW__MASK                        0x0000ffff
 987 #define MDP4_DSI_HSYNC_CTRL_PULSEW__SHIFT                       0
 988 static inline uint32_t MDP4_DSI_HSYNC_CTRL_PULSEW(uint32_t val)
 989 {
 990         return ((val) << MDP4_DSI_HSYNC_CTRL_PULSEW__SHIFT) & MDP4_DSI_HSYNC_CTRL_PULSEW__MASK;
 991 }
 992 #define MDP4_DSI_HSYNC_CTRL_PERIOD__MASK                        0xffff0000
 993 #define MDP4_DSI_HSYNC_CTRL_PERIOD__SHIFT                       16
 994 static inline uint32_t MDP4_DSI_HSYNC_CTRL_PERIOD(uint32_t val)
 995 {
 996         return ((val) << MDP4_DSI_HSYNC_CTRL_PERIOD__SHIFT) & MDP4_DSI_HSYNC_CTRL_PERIOD__MASK;
 997 }
 998
 999 #define REG_MDP4_DSI_VSYNC_PERIOD                               0x000e0008
1000
1001 #define REG_MDP4_DSI_VSYNC_LEN                                  0x000e000c
1002
1003 #define REG_MDP4_DSI_DISPLAY_HCTRL                              0x000e0010
1004 #define MDP4_DSI_DISPLAY_HCTRL_START__MASK                      0x0000ffff
1005 #define MDP4_DSI_DISPLAY_HCTRL_START__SHIFT                     0
1006 static inline uint32_t MDP4_DSI_DISPLAY_HCTRL_START(uint32_t val)
1007 {
1008         return ((val) << MDP4_DSI_DISPLAY_HCTRL_START__SHIFT) & MDP4_DSI_DISPLAY_HCTRL_START__MASK;
1009 }
1010 #define MDP4_DSI_DISPLAY_HCTRL_END__MASK                        0xffff0000
1011 #define MDP4_DSI_DISPLAY_HCTRL_END__SHIFT                       16
1012 static inline uint32_t MDP4_DSI_DISPLAY_HCTRL_END(uint32_t val)
1013 {
1014         return ((val) << MDP4_DSI_DISPLAY_HCTRL_END__SHIFT) & MDP4_DSI_DISPLAY_HCTRL_END__MASK;
1015 }
1016
1017 #define REG_MDP4_DSI_DISPLAY_VSTART                             0x000e0014
1018
1019 #define REG_MDP4_DSI_DISPLAY_VEND                               0x000e0018
1020
1021 #define REG_MDP4_DSI_ACTIVE_HCTL                                0x000e001c
1022 #define MDP4_DSI_ACTIVE_HCTL_START__MASK                        0x00007fff
1023 #define MDP4_DSI_ACTIVE_HCTL_START__SHIFT                       0
1024 static inline uint32_t MDP4_DSI_ACTIVE_HCTL_START(uint32_t val)
1025 {
1026         return ((val) << MDP4_DSI_ACTIVE_HCTL_START__SHIFT) & MDP4_DSI_ACTIVE_HCTL_START__MASK;
1027 }
1028 #define MDP4_DSI_ACTIVE_HCTL_END__MASK                          0x7fff0000
1029 #define MDP4_DSI_ACTIVE_HCTL_END__SHIFT                         16
1030 static inline uint32_t MDP4_DSI_ACTIVE_HCTL_END(uint32_t val)
1031 {
1032         return ((val) << MDP4_DSI_ACTIVE_HCTL_END__SHIFT) & MDP4_DSI_ACTIVE_HCTL_END__MASK;
1033 }
1034 #define MDP4_DSI_ACTIVE_HCTL_ACTIVE_START_X                     0x80000000
1035
1036 #define REG_MDP4_DSI_ACTIVE_VSTART                              0x000e0020
1037
1038 #define REG_MDP4_DSI_ACTIVE_VEND                                0x000e0024
1039
1040 #define REG_MDP4_DSI_BORDER_CLR                                 0x000e0028
1041
1042 #define REG_MDP4_DSI_UNDERFLOW_CLR                              0x000e002c
1043 #define MDP4_DSI_UNDERFLOW_CLR_COLOR__MASK                      0x00ffffff
1044 #define MDP4_DSI_UNDERFLOW_CLR_COLOR__SHIFT                     0
1045 static inline uint32_t MDP4_DSI_UNDERFLOW_CLR_COLOR(uint32_t val)
1046 {
1047         return ((val) << MDP4_DSI_UNDERFLOW_CLR_COLOR__SHIFT) & MDP4_DSI_UNDERFLOW_CLR_COLOR__MASK;
1048 }
1049 #define MDP4_DSI_UNDERFLOW_CLR_ENABLE_RECOVERY                  0x80000000
1050
1051 #define REG_MDP4_DSI_HSYNC_SKEW                                 0x000e0030
1052
1053 #define REG_MDP4_DSI_TEST_CNTL                                  0x000e0034
1054
1055 #define REG_MDP4_DSI_CTRL_POLARITY                              0x000e0038
1056 #define MDP4_DSI_CTRL_POLARITY_HSYNC_LOW                        0x00000001
1057 #define MDP4_DSI_CTRL_POLARITY_VSYNC_LOW                        0x00000002
1058 #define MDP4_DSI_CTRL_POLARITY_DATA_EN_LOW                      0x00000004
1059
1060
1061 #endif /* MDP4_XML */