drivers/gpu/drm/msm/disp/dpu1/dpu_formats.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (c) 2015-2018, The Linux Foundation. All rights reserved.
   3  */
   4
   5 #define pr_fmt(fmt)     "[drm:%s:%d] " fmt, __func__, __LINE__
   6
   7 #include <uapi/drm/drm_fourcc.h>
   8
   9 #include "msm_media_info.h"
  10 #include "dpu_kms.h"
  11 #include "dpu_formats.h"
  12
  13 #define DPU_UBWC_META_MACRO_W_H         16
  14 #define DPU_UBWC_META_BLOCK_SIZE        256
  15 #define DPU_UBWC_PLANE_SIZE_ALIGNMENT   4096
  16
  17 #define DPU_TILE_HEIGHT_DEFAULT 1
  18 #define DPU_TILE_HEIGHT_TILED   4
  19 #define DPU_TILE_HEIGHT_UBWC    4
  20 #define DPU_TILE_HEIGHT_NV12    8
  21
  22 #define DPU_MAX_IMG_WIDTH               0x3FFF
  23 #define DPU_MAX_IMG_HEIGHT              0x3FFF
  24
  25 /**
  26  * DPU supported format packing, bpp, and other format
  27  * information.
  28  * DPU currently only supports interleaved RGB formats
  29  * UBWC support for a pixel format is indicated by the flag,
  30  * there is additional meta data plane for such formats
  31  */
  32
  33 #define INTERLEAVED_RGB_FMT(fmt, a, r, g, b, e0, e1, e2, e3, uc, alpha,   \
  34 bp, flg, fm, np)                                                          \
  35 {                                                                         \
  36         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
  37         .fetch_planes = DPU_PLANE_INTERLEAVED,                            \
  38         .alpha_enable = alpha,                                            \
  39         .element = { (e0), (e1), (e2), (e3) },                            \
  40         .bits = { g, b, r, a },                                           \
  41         .chroma_sample = DPU_CHROMA_RGB,                                  \
  42         .unpack_align_msb = 0,                                            \
  43         .unpack_tight = 1,                                                \
  44         .unpack_count = uc,                                               \
  45         .bpp = bp,                                                        \
  46         .fetch_mode = fm,                                                 \
  47         .flag = {(flg)},                                                  \
  48         .num_planes = np,                                                 \
  49         .tile_height = DPU_TILE_HEIGHT_DEFAULT                            \
  50 }
  51
  52 #define INTERLEAVED_RGB_FMT_TILED(fmt, a, r, g, b, e0, e1, e2, e3, uc,    \
  53 alpha, bp, flg, fm, np, th)                                               \
  54 {                                                                         \
  55         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
  56         .fetch_planes = DPU_PLANE_INTERLEAVED,                            \
  57         .alpha_enable = alpha,                                            \
  58         .element = { (e0), (e1), (e2), (e3) },                            \
  59         .bits = { g, b, r, a },                                           \
  60         .chroma_sample = DPU_CHROMA_RGB,                                  \
  61         .unpack_align_msb = 0,                                            \
  62         .unpack_tight = 1,                                                \
  63         .unpack_count = uc,                                               \
  64         .bpp = bp,                                                        \
  65         .fetch_mode = fm,                                                 \
  66         .flag = {(flg)},                                                  \
  67         .num_planes = np,                                                 \
  68         .tile_height = th                                                 \
  69 }
  70
  71
  72 #define INTERLEAVED_YUV_FMT(fmt, a, r, g, b, e0, e1, e2, e3,              \
  73 alpha, chroma, count, bp, flg, fm, np)                                    \
  74 {                                                                         \
  75         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
  76         .fetch_planes = DPU_PLANE_INTERLEAVED,                            \
  77         .alpha_enable = alpha,                                            \
  78         .element = { (e0), (e1), (e2), (e3)},                             \
  79         .bits = { g, b, r, a },                                           \
  80         .chroma_sample = chroma,                                          \
  81         .unpack_align_msb = 0,                                            \
  82         .unpack_tight = 1,                                                \
  83         .unpack_count = count,                                            \
  84         .bpp = bp,                                                        \
  85         .fetch_mode = fm,                                                 \
  86         .flag = {(flg)},                                                  \
  87         .num_planes = np,                                                 \
  88         .tile_height = DPU_TILE_HEIGHT_DEFAULT                            \
  89 }
  90
  91 #define PSEUDO_YUV_FMT(fmt, a, r, g, b, e0, e1, chroma, flg, fm, np)      \
  92 {                                                                         \
  93         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
  94         .fetch_planes = DPU_PLANE_PSEUDO_PLANAR,                          \
  95         .alpha_enable = false,                                            \
  96         .element = { (e0), (e1), 0, 0 },                                  \
  97         .bits = { g, b, r, a },                                           \
  98         .chroma_sample = chroma,                                          \
  99         .unpack_align_msb = 0,                                            \
 100         .unpack_tight = 1,                                                \
 101         .unpack_count = 2,                                                \
 102         .bpp = 2,                                                         \
 103         .fetch_mode = fm,                                                 \
 104         .flag = {(flg)},                                                  \
 105         .num_planes = np,                                                 \
 106         .tile_height = DPU_TILE_HEIGHT_DEFAULT                            \
 107 }
 108
 109 #define PSEUDO_YUV_FMT_TILED(fmt, a, r, g, b, e0, e1, chroma,             \
 110 flg, fm, np, th)                                                          \
 111 {                                                                         \
 112         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
 113         .fetch_planes = DPU_PLANE_PSEUDO_PLANAR,                          \
 114         .alpha_enable = false,                                            \
 115         .element = { (e0), (e1), 0, 0 },                                  \
 116         .bits = { g, b, r, a },                                           \
 117         .chroma_sample = chroma,                                          \
 118         .unpack_align_msb = 0,                                            \
 119         .unpack_tight = 1,                                                \
 120         .unpack_count = 2,                                                \
 121         .bpp = 2,                                                         \
 122         .fetch_mode = fm,                                                 \
 123         .flag = {(flg)},                                                  \
 124         .num_planes = np,                                                 \
 125         .tile_height = th                                                 \
 126 }
 127
 128 #define PSEUDO_YUV_FMT_LOOSE(fmt, a, r, g, b, e0, e1, chroma, flg, fm, np)\
 129 {                                                                         \
 130         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
 131         .fetch_planes = DPU_PLANE_PSEUDO_PLANAR,                          \
 132         .alpha_enable = false,                                            \
 133         .element = { (e0), (e1), 0, 0 },                                  \
 134         .bits = { g, b, r, a },                                           \
 135         .chroma_sample = chroma,                                          \
 136         .unpack_align_msb = 1,                                            \
 137         .unpack_tight = 0,                                                \
 138         .unpack_count = 2,                                                \
 139         .bpp = 2,                                                         \
 140         .fetch_mode = fm,                                                 \
 141         .flag = {(flg)},                                                  \
 142         .num_planes = np,                                                 \
 143         .tile_height = DPU_TILE_HEIGHT_DEFAULT                            \
 144 }
 145
 146 #define PSEUDO_YUV_FMT_LOOSE_TILED(fmt, a, r, g, b, e0, e1, chroma,       \
 147 flg, fm, np, th)                                                          \
 148 {                                                                         \
 149         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
 150         .fetch_planes = DPU_PLANE_PSEUDO_PLANAR,                          \
 151         .alpha_enable = false,                                            \
 152         .element = { (e0), (e1), 0, 0 },                                  \
 153         .bits = { g, b, r, a },                                           \
 154         .chroma_sample = chroma,                                          \
 155         .unpack_align_msb = 1,                                            \
 156         .unpack_tight = 0,                                                \
 157         .unpack_count = 2,                                                \
 158         .bpp = 2,                                                         \
 159         .fetch_mode = fm,                                                 \
 160         .flag = {(flg)},                                                  \
 161         .num_planes = np,                                                 \
 162         .tile_height = th                                                 \
 163 }
 164
 165
 166 #define PLANAR_YUV_FMT(fmt, a, r, g, b, e0, e1, e2, alpha, chroma, bp,    \
 167 flg, fm, np)                                                      \
 168 {                                                                         \
 169         .base.pixel_format = DRM_FORMAT_ ## fmt,                          \
 170         .fetch_planes = DPU_PLANE_PLANAR,                                 \
 171         .alpha_enable = alpha,                                            \
 172         .element = { (e0), (e1), (e2), 0 },                               \
 173         .bits = { g, b, r, a },                                           \
 174         .chroma_sample = chroma,                                          \
 175         .unpack_align_msb = 0,                                            \
 176         .unpack_tight = 1,                                                \
 177         .unpack_count = 1,                                                \
 178         .bpp = bp,                                                        \
 179         .fetch_mode = fm,                                                 \
 180         .flag = {(flg)},                                                  \
 181         .num_planes = np,                                                 \
 182         .tile_height = DPU_TILE_HEIGHT_DEFAULT                            \
 183 }
 184
 185 /*
 186  * struct dpu_media_color_map - maps drm format to media format
 187  * @format: DRM base pixel format
 188  * @color: Media API color related to DRM format
 189  */
 190 struct dpu_media_color_map {
 191         uint32_t format;
 192         uint32_t color;
 193 };
 194
 195 static const struct dpu_format dpu_format_map[] = {
 196         INTERLEAVED_RGB_FMT(ARGB8888,
 197                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 198                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 199                 true, 4, 0,
 200                 DPU_FETCH_LINEAR, 1),
 201
 202         INTERLEAVED_RGB_FMT(ABGR8888,
 203                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 204                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 205                 true, 4, 0,
 206                 DPU_FETCH_LINEAR, 1),
 207
 208         INTERLEAVED_RGB_FMT(XBGR8888,
 209                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 210                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 211                 false, 4, 0,
 212                 DPU_FETCH_LINEAR, 1),
 213
 214         INTERLEAVED_RGB_FMT(RGBA8888,
 215                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 216                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 217                 true, 4, 0,
 218                 DPU_FETCH_LINEAR, 1),
 219
 220         INTERLEAVED_RGB_FMT(BGRA8888,
 221                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 222                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 223                 true, 4, 0,
 224                 DPU_FETCH_LINEAR, 1),
 225
 226         INTERLEAVED_RGB_FMT(BGRX8888,
 227                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 228                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 229                 false, 4, 0,
 230                 DPU_FETCH_LINEAR, 1),
 231
 232         INTERLEAVED_RGB_FMT(XRGB8888,
 233                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 234                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 235                 false, 4, 0,
 236                 DPU_FETCH_LINEAR, 1),
 237
 238         INTERLEAVED_RGB_FMT(RGBX8888,
 239                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 240                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 241                 false, 4, 0,
 242                 DPU_FETCH_LINEAR, 1),
 243
 244         INTERLEAVED_RGB_FMT(RGB888,
 245                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 246                 C1_B_Cb, C0_G_Y, C2_R_Cr, 0, 3,
 247                 false, 3, 0,
 248                 DPU_FETCH_LINEAR, 1),
 249
 250         INTERLEAVED_RGB_FMT(BGR888,
 251                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 252                 C2_R_Cr, C0_G_Y, C1_B_Cb, 0, 3,
 253                 false, 3, 0,
 254                 DPU_FETCH_LINEAR, 1),
 255
 256         INTERLEAVED_RGB_FMT(RGB565,
 257                 0, COLOR_5BIT, COLOR_6BIT, COLOR_5BIT,
 258                 C1_B_Cb, C0_G_Y, C2_R_Cr, 0, 3,
 259                 false, 2, 0,
 260                 DPU_FETCH_LINEAR, 1),
 261
 262         INTERLEAVED_RGB_FMT(BGR565,
 263                 0, COLOR_5BIT, COLOR_6BIT, COLOR_5BIT,
 264                 C2_R_Cr, C0_G_Y, C1_B_Cb, 0, 3,
 265                 false, 2, 0,
 266                 DPU_FETCH_LINEAR, 1),
 267
 268         INTERLEAVED_RGB_FMT(ARGB1555,
 269                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 270                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 271                 true, 2, 0,
 272                 DPU_FETCH_LINEAR, 1),
 273
 274         INTERLEAVED_RGB_FMT(ABGR1555,
 275                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 276                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 277                 true, 2, 0,
 278                 DPU_FETCH_LINEAR, 1),
 279
 280         INTERLEAVED_RGB_FMT(RGBA5551,
 281                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 282                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 283                 true, 2, 0,
 284                 DPU_FETCH_LINEAR, 1),
 285
 286         INTERLEAVED_RGB_FMT(BGRA5551,
 287                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 288                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 289                 true, 2, 0,
 290                 DPU_FETCH_LINEAR, 1),
 291
 292         INTERLEAVED_RGB_FMT(XRGB1555,
 293                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 294                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 295                 false, 2, 0,
 296                 DPU_FETCH_LINEAR, 1),
 297
 298         INTERLEAVED_RGB_FMT(XBGR1555,
 299                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 300                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 301                 false, 2, 0,
 302                 DPU_FETCH_LINEAR, 1),
 303
 304         INTERLEAVED_RGB_FMT(RGBX5551,
 305                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 306                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 307                 false, 2, 0,
 308                 DPU_FETCH_LINEAR, 1),
 309
 310         INTERLEAVED_RGB_FMT(BGRX5551,
 311                 COLOR_ALPHA_1BIT, COLOR_5BIT, COLOR_5BIT, COLOR_5BIT,
 312                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 313                 false, 2, 0,
 314                 DPU_FETCH_LINEAR, 1),
 315
 316         INTERLEAVED_RGB_FMT(ARGB4444,
 317                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 318                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 319                 true, 2, 0,
 320                 DPU_FETCH_LINEAR, 1),
 321
 322         INTERLEAVED_RGB_FMT(ABGR4444,
 323                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 324                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 325                 true, 2, 0,
 326                 DPU_FETCH_LINEAR, 1),
 327
 328         INTERLEAVED_RGB_FMT(RGBA4444,
 329                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 330                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 331                 true, 2, 0,
 332                 DPU_FETCH_LINEAR, 1),
 333
 334         INTERLEAVED_RGB_FMT(BGRA4444,
 335                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 336                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 337                 true, 2, 0,
 338                 DPU_FETCH_LINEAR, 1),
 339
 340         INTERLEAVED_RGB_FMT(XRGB4444,
 341                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 342                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 343                 false, 2, 0,
 344                 DPU_FETCH_LINEAR, 1),
 345
 346         INTERLEAVED_RGB_FMT(XBGR4444,
 347                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 348                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 349                 false, 2, 0,
 350                 DPU_FETCH_LINEAR, 1),
 351
 352         INTERLEAVED_RGB_FMT(RGBX4444,
 353                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 354                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 355                 false, 2, 0,
 356                 DPU_FETCH_LINEAR, 1),
 357
 358         INTERLEAVED_RGB_FMT(BGRX4444,
 359                 COLOR_ALPHA_4BIT, COLOR_4BIT, COLOR_4BIT, COLOR_4BIT,
 360                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 361                 false, 2, 0,
 362                 DPU_FETCH_LINEAR, 1),
 363
 364         INTERLEAVED_RGB_FMT(BGRA1010102,
 365                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 366                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 367                 true, 4, DPU_FORMAT_FLAG_DX,
 368                 DPU_FETCH_LINEAR, 1),
 369
 370         INTERLEAVED_RGB_FMT(RGBA1010102,
 371                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 372                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 373                 true, 4, DPU_FORMAT_FLAG_DX,
 374                 DPU_FETCH_LINEAR, 1),
 375
 376         INTERLEAVED_RGB_FMT(ABGR2101010,
 377                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 378                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 379                 true, 4, DPU_FORMAT_FLAG_DX,
 380                 DPU_FETCH_LINEAR, 1),
 381
 382         INTERLEAVED_RGB_FMT(ARGB2101010,
 383                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 384                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 385                 true, 4, DPU_FORMAT_FLAG_DX,
 386                 DPU_FETCH_LINEAR, 1),
 387
 388         INTERLEAVED_RGB_FMT(XRGB2101010,
 389                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 390                 C1_B_Cb, C0_G_Y, C2_R_Cr, C3_ALPHA, 4,
 391                 false, 4, DPU_FORMAT_FLAG_DX,
 392                 DPU_FETCH_LINEAR, 1),
 393
 394         INTERLEAVED_RGB_FMT(BGRX1010102,
 395                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 396                 C3_ALPHA, C2_R_Cr, C0_G_Y, C1_B_Cb, 4,
 397                 false, 4, DPU_FORMAT_FLAG_DX,
 398                 DPU_FETCH_LINEAR, 1),
 399
 400         INTERLEAVED_RGB_FMT(XBGR2101010,
 401                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 402                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 403                 false, 4, DPU_FORMAT_FLAG_DX,
 404                 DPU_FETCH_LINEAR, 1),
 405
 406         INTERLEAVED_RGB_FMT(RGBX1010102,
 407                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 408                 C3_ALPHA, C1_B_Cb, C0_G_Y, C2_R_Cr, 4,
 409                 false, 4, DPU_FORMAT_FLAG_DX,
 410                 DPU_FETCH_LINEAR, 1),
 411
 412         PSEUDO_YUV_FMT(NV12,
 413                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 414                 C1_B_Cb, C2_R_Cr,
 415                 DPU_CHROMA_420, DPU_FORMAT_FLAG_YUV,
 416                 DPU_FETCH_LINEAR, 2),
 417
 418         PSEUDO_YUV_FMT(NV21,
 419                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 420                 C2_R_Cr, C1_B_Cb,
 421                 DPU_CHROMA_420, DPU_FORMAT_FLAG_YUV,
 422                 DPU_FETCH_LINEAR, 2),
 423
 424         PSEUDO_YUV_FMT(NV16,
 425                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 426                 C1_B_Cb, C2_R_Cr,
 427                 DPU_CHROMA_H2V1, DPU_FORMAT_FLAG_YUV,
 428                 DPU_FETCH_LINEAR, 2),
 429
 430         PSEUDO_YUV_FMT(NV61,
 431                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 432                 C2_R_Cr, C1_B_Cb,
 433                 DPU_CHROMA_H2V1, DPU_FORMAT_FLAG_YUV,
 434                 DPU_FETCH_LINEAR, 2),
 435
 436         INTERLEAVED_YUV_FMT(VYUY,
 437                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 438                 C2_R_Cr, C0_G_Y, C1_B_Cb, C0_G_Y,
 439                 false, DPU_CHROMA_H2V1, 4, 2, DPU_FORMAT_FLAG_YUV,
 440                 DPU_FETCH_LINEAR, 2),
 441
 442         INTERLEAVED_YUV_FMT(UYVY,
 443                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 444                 C1_B_Cb, C0_G_Y, C2_R_Cr, C0_G_Y,
 445                 false, DPU_CHROMA_H2V1, 4, 2, DPU_FORMAT_FLAG_YUV,
 446                 DPU_FETCH_LINEAR, 2),
 447
 448         INTERLEAVED_YUV_FMT(YUYV,
 449                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 450                 C0_G_Y, C1_B_Cb, C0_G_Y, C2_R_Cr,
 451                 false, DPU_CHROMA_H2V1, 4, 2, DPU_FORMAT_FLAG_YUV,
 452                 DPU_FETCH_LINEAR, 2),
 453
 454         INTERLEAVED_YUV_FMT(YVYU,
 455                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 456                 C0_G_Y, C2_R_Cr, C0_G_Y, C1_B_Cb,
 457                 false, DPU_CHROMA_H2V1, 4, 2, DPU_FORMAT_FLAG_YUV,
 458                 DPU_FETCH_LINEAR, 2),
 459
 460         PLANAR_YUV_FMT(YUV420,
 461                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 462                 C2_R_Cr, C1_B_Cb, C0_G_Y,
 463                 false, DPU_CHROMA_420, 1, DPU_FORMAT_FLAG_YUV,
 464                 DPU_FETCH_LINEAR, 3),
 465
 466         PLANAR_YUV_FMT(YVU420,
 467                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 468                 C1_B_Cb, C2_R_Cr, C0_G_Y,
 469                 false, DPU_CHROMA_420, 1, DPU_FORMAT_FLAG_YUV,
 470                 DPU_FETCH_LINEAR, 3),
 471 };
 472
 473 /*
 474  * UBWC formats table:
 475  * This table holds the UBWC formats supported.
 476  * If a compression ratio needs to be used for this or any other format,
 477  * the data will be passed by user-space.
 478  */
 479 static const struct dpu_format dpu_format_map_ubwc[] = {
 480         INTERLEAVED_RGB_FMT_TILED(BGR565,
 481                 0, COLOR_5BIT, COLOR_6BIT, COLOR_5BIT,
 482                 C2_R_Cr, C0_G_Y, C1_B_Cb, 0, 3,
 483                 false, 2, DPU_FORMAT_FLAG_COMPRESSED,
 484                 DPU_FETCH_UBWC, 2, DPU_TILE_HEIGHT_UBWC),
 485
 486         INTERLEAVED_RGB_FMT_TILED(ABGR8888,
 487                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 488                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 489                 true, 4, DPU_FORMAT_FLAG_COMPRESSED,
 490                 DPU_FETCH_UBWC, 2, DPU_TILE_HEIGHT_UBWC),
 491
 492         /* ARGB8888 and ABGR8888 purposely have the same color
 493          * ordering.  The hardware only supports ABGR8888 UBWC
 494          * natively.
 495          */
 496         INTERLEAVED_RGB_FMT_TILED(ARGB8888,
 497                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 498                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 499                 true, 4, DPU_FORMAT_FLAG_COMPRESSED,
 500                 DPU_FETCH_UBWC, 2, DPU_TILE_HEIGHT_UBWC),
 501
 502         INTERLEAVED_RGB_FMT_TILED(XBGR8888,
 503                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 504                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 505                 false, 4, DPU_FORMAT_FLAG_COMPRESSED,
 506                 DPU_FETCH_UBWC, 2, DPU_TILE_HEIGHT_UBWC),
 507
 508         INTERLEAVED_RGB_FMT_TILED(XRGB8888,
 509                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 510                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 511                 false, 4, DPU_FORMAT_FLAG_COMPRESSED,
 512                 DPU_FETCH_UBWC, 2, DPU_TILE_HEIGHT_UBWC),
 513
 514         INTERLEAVED_RGB_FMT_TILED(ABGR2101010,
 515                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 516                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 517                 true, 4, DPU_FORMAT_FLAG_DX | DPU_FORMAT_FLAG_COMPRESSED,
 518                 DPU_FETCH_UBWC, 2, DPU_TILE_HEIGHT_UBWC),
 519
 520         INTERLEAVED_RGB_FMT_TILED(XBGR2101010,
 521                 COLOR_8BIT, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 522                 C2_R_Cr, C0_G_Y, C1_B_Cb, C3_ALPHA, 4,
 523                 true, 4, DPU_FORMAT_FLAG_DX | DPU_FORMAT_FLAG_COMPRESSED,
 524                 DPU_FETCH_UBWC, 2, DPU_TILE_HEIGHT_UBWC),
 525
 526         PSEUDO_YUV_FMT_TILED(NV12,
 527                 0, COLOR_8BIT, COLOR_8BIT, COLOR_8BIT,
 528                 C1_B_Cb, C2_R_Cr,
 529                 DPU_CHROMA_420, DPU_FORMAT_FLAG_YUV |
 530                                 DPU_FORMAT_FLAG_COMPRESSED,
 531                 DPU_FETCH_UBWC, 4, DPU_TILE_HEIGHT_NV12),
 532 };
 533
 534 /* _dpu_get_v_h_subsample_rate - Get subsample rates for all formats we support
 535  *   Note: Not using the drm_format_*_subsampling since we have formats
 536  */
 537 static void _dpu_get_v_h_subsample_rate(
 538         enum dpu_chroma_samp_type chroma_sample,
 539         uint32_t *v_sample,
 540         uint32_t *h_sample)
 541 {
 542         if (!v_sample || !h_sample)
 543                 return;
 544
 545         switch (chroma_sample) {
 546         case DPU_CHROMA_H2V1:
 547                 *v_sample = 1;
 548                 *h_sample = 2;
 549                 break;
 550         case DPU_CHROMA_H1V2:
 551                 *v_sample = 2;
 552                 *h_sample = 1;
 553                 break;
 554         case DPU_CHROMA_420:
 555                 *v_sample = 2;
 556                 *h_sample = 2;
 557                 break;
 558         default:
 559                 *v_sample = 1;
 560                 *h_sample = 1;
 561                 break;
 562         }
 563 }
 564
 565 static int _dpu_format_get_media_color_ubwc(const struct dpu_format *fmt)
 566 {
 567         static const struct dpu_media_color_map dpu_media_ubwc_map[] = {
 568                 {DRM_FORMAT_ABGR8888, COLOR_FMT_RGBA8888_UBWC},
 569                 {DRM_FORMAT_ARGB8888, COLOR_FMT_RGBA8888_UBWC},
 570                 {DRM_FORMAT_XBGR8888, COLOR_FMT_RGBA8888_UBWC},
 571                 {DRM_FORMAT_XRGB8888, COLOR_FMT_RGBA8888_UBWC},
 572                 {DRM_FORMAT_ABGR2101010, COLOR_FMT_RGBA1010102_UBWC},
 573                 {DRM_FORMAT_XBGR2101010, COLOR_FMT_RGBA1010102_UBWC},
 574                 {DRM_FORMAT_BGR565, COLOR_FMT_RGB565_UBWC},
 575         };
 576         int color_fmt = -1;
 577         int i;
 578
 579         if (fmt->base.pixel_format == DRM_FORMAT_NV12) {
 580                 if (DPU_FORMAT_IS_DX(fmt)) {
 581                         if (fmt->unpack_tight)
 582                                 color_fmt = COLOR_FMT_NV12_BPP10_UBWC;
 583                         else
 584                                 color_fmt = COLOR_FMT_P010_UBWC;
 585                 } else
 586                         color_fmt = COLOR_FMT_NV12_UBWC;
 587                 return color_fmt;
 588         }
 589
 590         for (i = 0; i < ARRAY_SIZE(dpu_media_ubwc_map); ++i)
 591                 if (fmt->base.pixel_format == dpu_media_ubwc_map[i].format) {
 592                         color_fmt = dpu_media_ubwc_map[i].color;
 593                         break;
 594                 }
 595         return color_fmt;
 596 }
 597
 598 static int _dpu_format_get_plane_sizes_ubwc(
 599                 const struct dpu_format *fmt,
 600                 const uint32_t width,
 601                 const uint32_t height,
 602                 struct dpu_hw_fmt_layout *layout)
 603 {
 604         int i;
 605         int color;
 606         bool meta = DPU_FORMAT_IS_UBWC(fmt);
 607
 608         memset(layout, 0, sizeof(struct dpu_hw_fmt_layout));
 609         layout->format = fmt;
 610         layout->width = width;
 611         layout->height = height;
 612         layout->num_planes = fmt->num_planes;
 613
 614         color = _dpu_format_get_media_color_ubwc(fmt);
 615         if (color < 0) {
 616                 DRM_ERROR("UBWC format not supported for fmt: %4.4s\n",
 617                         (char *)&fmt->base.pixel_format);
 618                 return -EINVAL;
 619         }
 620
 621         if (DPU_FORMAT_IS_YUV(layout->format)) {
 622                 uint32_t y_sclines, uv_sclines;
 623                 uint32_t y_meta_scanlines = 0;
 624                 uint32_t uv_meta_scanlines = 0;
 625
 626                 layout->num_planes = 2;
 627                 layout->plane_pitch[0] = VENUS_Y_STRIDE(color, width);
 628                 y_sclines = VENUS_Y_SCANLINES(color, height);
 629                 layout->plane_size[0] = MSM_MEDIA_ALIGN(layout->plane_pitch[0] *
 630                         y_sclines, DPU_UBWC_PLANE_SIZE_ALIGNMENT);
 631
 632                 layout->plane_pitch[1] = VENUS_UV_STRIDE(color, width);
 633                 uv_sclines = VENUS_UV_SCANLINES(color, height);
 634                 layout->plane_size[1] = MSM_MEDIA_ALIGN(layout->plane_pitch[1] *
 635                         uv_sclines, DPU_UBWC_PLANE_SIZE_ALIGNMENT);
 636
 637                 if (!meta)
 638                         goto done;
 639
 640                 layout->num_planes += 2;
 641                 layout->plane_pitch[2] = VENUS_Y_META_STRIDE(color, width);
 642                 y_meta_scanlines = VENUS_Y_META_SCANLINES(color, height);
 643                 layout->plane_size[2] = MSM_MEDIA_ALIGN(layout->plane_pitch[2] *
 644                         y_meta_scanlines, DPU_UBWC_PLANE_SIZE_ALIGNMENT);
 645
 646                 layout->plane_pitch[3] = VENUS_UV_META_STRIDE(color, width);
 647                 uv_meta_scanlines = VENUS_UV_META_SCANLINES(color, height);
 648                 layout->plane_size[3] = MSM_MEDIA_ALIGN(layout->plane_pitch[3] *
 649                         uv_meta_scanlines, DPU_UBWC_PLANE_SIZE_ALIGNMENT);
 650
 651         } else {
 652                 uint32_t rgb_scanlines, rgb_meta_scanlines;
 653
 654                 layout->num_planes = 1;
 655
 656                 layout->plane_pitch[0] = VENUS_RGB_STRIDE(color, width);
 657                 rgb_scanlines = VENUS_RGB_SCANLINES(color, height);
 658                 layout->plane_size[0] = MSM_MEDIA_ALIGN(layout->plane_pitch[0] *
 659                         rgb_scanlines, DPU_UBWC_PLANE_SIZE_ALIGNMENT);
 660
 661                 if (!meta)
 662                         goto done;
 663                 layout->num_planes += 2;
 664                 layout->plane_pitch[2] = VENUS_RGB_META_STRIDE(color, width);
 665                 rgb_meta_scanlines = VENUS_RGB_META_SCANLINES(color, height);
 666                 layout->plane_size[2] = MSM_MEDIA_ALIGN(layout->plane_pitch[2] *
 667                         rgb_meta_scanlines, DPU_UBWC_PLANE_SIZE_ALIGNMENT);
 668         }
 669
 670 done:
 671         for (i = 0; i < DPU_MAX_PLANES; i++)
 672                 layout->total_size += layout->plane_size[i];
 673
 674         return 0;
 675 }
 676
 677 static int _dpu_format_get_plane_sizes_linear(
 678                 const struct dpu_format *fmt,
 679                 const uint32_t width,
 680                 const uint32_t height,
 681                 struct dpu_hw_fmt_layout *layout,
 682                 const uint32_t *pitches)
 683 {
 684         int i;
 685
 686         memset(layout, 0, sizeof(struct dpu_hw_fmt_layout));
 687         layout->format = fmt;
 688         layout->width = width;
 689         layout->height = height;
 690         layout->num_planes = fmt->num_planes;
 691
 692         /* Due to memset above, only need to set planes of interest */
 693         if (fmt->fetch_planes == DPU_PLANE_INTERLEAVED) {
 694                 layout->num_planes = 1;
 695                 layout->plane_size[0] = width * height * layout->format->bpp;
 696                 layout->plane_pitch[0] = width * layout->format->bpp;
 697         } else {
 698                 uint32_t v_subsample, h_subsample;
 699                 uint32_t chroma_samp;
 700                 uint32_t bpp = 1;
 701
 702                 chroma_samp = fmt->chroma_sample;
 703                 _dpu_get_v_h_subsample_rate(chroma_samp, &v_subsample,
 704                                 &h_subsample);
 705
 706                 if (width % h_subsample || height % v_subsample) {
 707                         DRM_ERROR("mismatch in subsample vs dimensions\n");
 708                         return -EINVAL;
 709                 }
 710
 711                 if ((fmt->base.pixel_format == DRM_FORMAT_NV12) &&
 712                         (DPU_FORMAT_IS_DX(fmt)))
 713                         bpp = 2;
 714                 layout->plane_pitch[0] = width * bpp;
 715                 layout->plane_pitch[1] = layout->plane_pitch[0] / h_subsample;
 716                 layout->plane_size[0] = layout->plane_pitch[0] * height;
 717                 layout->plane_size[1] = layout->plane_pitch[1] *
 718                                 (height / v_subsample);
 719
 720                 if (fmt->fetch_planes == DPU_PLANE_PSEUDO_PLANAR) {
 721                         layout->num_planes = 2;
 722                         layout->plane_size[1] *= 2;
 723                         layout->plane_pitch[1] *= 2;
 724                 } else {
 725                         /* planar */
 726                         layout->num_planes = 3;
 727                         layout->plane_size[2] = layout->plane_size[1];
 728                         layout->plane_pitch[2] = layout->plane_pitch[1];
 729                 }
 730         }
 731
 732         /*
 733          * linear format: allow user allocated pitches if they are greater than
 734          * the requirement.
 735          * ubwc format: pitch values are computed uniformly across
 736          * all the components based on ubwc specifications.
 737          */
 738         for (i = 0; i < layout->num_planes && i < DPU_MAX_PLANES; ++i) {
 739                 if (pitches && layout->plane_pitch[i] < pitches[i])
 740                         layout->plane_pitch[i] = pitches[i];
 741         }
 742
 743         for (i = 0; i < DPU_MAX_PLANES; i++)
 744                 layout->total_size += layout->plane_size[i];
 745
 746         return 0;
 747 }
 748
 749 static int dpu_format_get_plane_sizes(
 750                 const struct dpu_format *fmt,
 751                 const uint32_t w,
 752                 const uint32_t h,
 753                 struct dpu_hw_fmt_layout *layout,
 754                 const uint32_t *pitches)
 755 {
 756         if (!layout || !fmt) {
 757                 DRM_ERROR("invalid pointer\n");
 758                 return -EINVAL;
 759         }
 760
 761         if ((w > DPU_MAX_IMG_WIDTH) || (h > DPU_MAX_IMG_HEIGHT)) {
 762                 DRM_ERROR("image dimensions outside max range\n");
 763                 return -ERANGE;
 764         }
 765
 766         if (DPU_FORMAT_IS_UBWC(fmt) || DPU_FORMAT_IS_TILE(fmt))
 767                 return _dpu_format_get_plane_sizes_ubwc(fmt, w, h, layout);
 768
 769         return _dpu_format_get_plane_sizes_linear(fmt, w, h, layout, pitches);
 770 }
 771
 772 static int _dpu_format_populate_addrs_ubwc(
 773                 struct msm_gem_address_space *aspace,
 774                 struct drm_framebuffer *fb,
 775                 struct dpu_hw_fmt_layout *layout)
 776 {
 777         uint32_t base_addr = 0;
 778         bool meta;
 779
 780         if (!fb || !layout) {
 781                 DRM_ERROR("invalid pointers\n");
 782                 return -EINVAL;
 783         }
 784
 785         if (aspace)
 786                 base_addr = msm_framebuffer_iova(fb, aspace, 0);
 787         if (!base_addr) {
 788                 DRM_ERROR("failed to retrieve base addr\n");
 789                 return -EFAULT;
 790         }
 791
 792         meta = DPU_FORMAT_IS_UBWC(layout->format);
 793
 794         /* Per-format logic for verifying active planes */
 795         if (DPU_FORMAT_IS_YUV(layout->format)) {
 796                 /************************************************/
 797                 /*      UBWC            **                      */
 798                 /*      buffer          **      DPU PLANE       */
 799                 /*      format          **                      */
 800                 /************************************************/
 801                 /* -------------------  ** -------------------- */
 802                 /* |      Y meta     |  ** |    Y bitstream   | */
 803                 /* |       data      |  ** |       plane      | */
 804                 /* -------------------  ** -------------------- */
 805                 /* |    Y bitstream  |  ** |  CbCr bitstream  | */
 806                 /* |       data      |  ** |       plane      | */
 807                 /* -------------------  ** -------------------- */
 808                 /* |   Cbcr metadata |  ** |       Y meta     | */
 809                 /* |       data      |  ** |       plane      | */
 810                 /* -------------------  ** -------------------- */
 811                 /* |  CbCr bitstream |  ** |     CbCr meta    | */
 812                 /* |       data      |  ** |       plane      | */
 813                 /* -------------------  ** -------------------- */
 814                 /************************************************/
 815
 816                 /* configure Y bitstream plane */
 817                 layout->plane_addr[0] = base_addr + layout->plane_size[2];
 818
 819                 /* configure CbCr bitstream plane */
 820                 layout->plane_addr[1] = base_addr + layout->plane_size[0]
 821                         + layout->plane_size[2] + layout->plane_size[3];
 822
 823                 if (!meta)
 824                         return 0;
 825
 826                 /* configure Y metadata plane */
 827                 layout->plane_addr[2] = base_addr;
 828
 829                 /* configure CbCr metadata plane */
 830                 layout->plane_addr[3] = base_addr + layout->plane_size[0]
 831                         + layout->plane_size[2];
 832
 833         } else {
 834                 /************************************************/
 835                 /*      UBWC            **                      */
 836                 /*      buffer          **      DPU PLANE       */
 837                 /*      format          **                      */
 838                 /************************************************/
 839                 /* -------------------  ** -------------------- */
 840                 /* |      RGB meta   |  ** |   RGB bitstream  | */
 841                 /* |       data      |  ** |       plane      | */
 842                 /* -------------------  ** -------------------- */
 843                 /* |  RGB bitstream  |  ** |       NONE       | */
 844                 /* |       data      |  ** |                  | */
 845                 /* -------------------  ** -------------------- */
 846                 /*                      ** |     RGB meta     | */
 847                 /*                      ** |       plane      | */
 848                 /*                      ** -------------------- */
 849                 /************************************************/
 850
 851                 layout->plane_addr[0] = base_addr + layout->plane_size[2];
 852                 layout->plane_addr[1] = 0;
 853
 854                 if (!meta)
 855                         return 0;
 856
 857                 layout->plane_addr[2] = base_addr;
 858                 layout->plane_addr[3] = 0;
 859         }
 860         return 0;
 861 }
 862
 863 static int _dpu_format_populate_addrs_linear(
 864                 struct msm_gem_address_space *aspace,
 865                 struct drm_framebuffer *fb,
 866                 struct dpu_hw_fmt_layout *layout)
 867 {
 868         unsigned int i;
 869
 870         /* Can now check the pitches given vs pitches expected */
 871         for (i = 0; i < layout->num_planes; ++i) {
 872                 if (layout->plane_pitch[i] > fb->pitches[i]) {
 873                         DRM_ERROR("plane %u expected pitch %u, fb %u\n",
 874                                 i, layout->plane_pitch[i], fb->pitches[i]);
 875                         return -EINVAL;
 876                 }
 877         }
 878
 879         /* Populate addresses for simple formats here */
 880         for (i = 0; i < layout->num_planes; ++i) {
 881                 if (aspace)
 882                         layout->plane_addr[i] =
 883                                 msm_framebuffer_iova(fb, aspace, i);
 884                 if (!layout->plane_addr[i]) {
 885                         DRM_ERROR("failed to retrieve base addr\n");
 886                         return -EFAULT;
 887                 }
 888         }
 889
 890         return 0;
 891 }
 892
 893 int dpu_format_populate_layout(
 894                 struct msm_gem_address_space *aspace,
 895                 struct drm_framebuffer *fb,
 896                 struct dpu_hw_fmt_layout *layout)
 897 {
 898         uint32_t plane_addr[DPU_MAX_PLANES];
 899         int i, ret;
 900
 901         if (!fb || !layout) {
 902                 DRM_ERROR("invalid arguments\n");
 903                 return -EINVAL;
 904         }
 905
 906         if ((fb->width > DPU_MAX_IMG_WIDTH) ||
 907                         (fb->height > DPU_MAX_IMG_HEIGHT)) {
 908                 DRM_ERROR("image dimensions outside max range\n");
 909                 return -ERANGE;
 910         }
 911
 912         layout->format = to_dpu_format(msm_framebuffer_format(fb));
 913
 914         /* Populate the plane sizes etc via get_format */
 915         ret = dpu_format_get_plane_sizes(layout->format, fb->width, fb->height,
 916                         layout, fb->pitches);
 917         if (ret)
 918                 return ret;
 919
 920         for (i = 0; i < DPU_MAX_PLANES; ++i)
 921                 plane_addr[i] = layout->plane_addr[i];
 922
 923         /* Populate the addresses given the fb */
 924         if (DPU_FORMAT_IS_UBWC(layout->format) ||
 925                         DPU_FORMAT_IS_TILE(layout->format))
 926                 ret = _dpu_format_populate_addrs_ubwc(aspace, fb, layout);
 927         else
 928                 ret = _dpu_format_populate_addrs_linear(aspace, fb, layout);
 929
 930         /* check if anything changed */
 931         if (!ret && !memcmp(plane_addr, layout->plane_addr, sizeof(plane_addr)))
 932                 ret = -EAGAIN;
 933
 934         return ret;
 935 }
 936
 937 int dpu_format_check_modified_format(
 938                 const struct msm_kms *kms,
 939                 const struct msm_format *msm_fmt,
 940                 const struct drm_mode_fb_cmd2 *cmd,
 941                 struct drm_gem_object **bos)
 942 {
 943         const struct drm_format_info *info;
 944         const struct dpu_format *fmt;
 945         struct dpu_hw_fmt_layout layout;
 946         uint32_t bos_total_size = 0;
 947         int ret, i;
 948
 949         if (!msm_fmt || !cmd || !bos) {
 950                 DRM_ERROR("invalid arguments\n");
 951                 return -EINVAL;
 952         }
 953
 954         fmt = to_dpu_format(msm_fmt);
 955         info = drm_format_info(fmt->base.pixel_format);
 956         if (!info)
 957                 return -EINVAL;
 958
 959         ret = dpu_format_get_plane_sizes(fmt, cmd->width, cmd->height,
 960                         &layout, cmd->pitches);
 961         if (ret)
 962                 return ret;
 963
 964         for (i = 0; i < info->num_planes; i++) {
 965                 if (!bos[i]) {
 966                         DRM_ERROR("invalid handle for plane %d\n", i);
 967                         return -EINVAL;
 968                 }
 969                 if ((i == 0) || (bos[i] != bos[0]))
 970                         bos_total_size += bos[i]->size;
 971         }
 972
 973         if (bos_total_size < layout.total_size) {
 974                 DRM_ERROR("buffers total size too small %u expected %u\n",
 975                                 bos_total_size, layout.total_size);
 976                 return -EINVAL;
 977         }
 978
 979         return 0;
 980 }
 981
 982 const struct dpu_format *dpu_get_dpu_format_ext(
 983                 const uint32_t format,
 984                 const uint64_t modifier)
 985 {
 986         uint32_t i = 0;
 987         const struct dpu_format *fmt = NULL;
 988         const struct dpu_format *map = NULL;
 989         ssize_t map_size = 0;
 990
 991         /*
 992          * Currently only support exactly zero or one modifier.
 993          * All planes use the same modifier.
 994          */
 995         DPU_DEBUG("plane format modifier 0x%llX\n", modifier);
 996
 997         switch (modifier) {
 998         case 0:
 999                 map = dpu_format_map;
1000                 map_size = ARRAY_SIZE(dpu_format_map);
1001                 break;
1002         case DRM_FORMAT_MOD_QCOM_COMPRESSED:
1003                 map = dpu_format_map_ubwc;
1004                 map_size = ARRAY_SIZE(dpu_format_map_ubwc);
1005                 DPU_DEBUG("found fmt: %4.4s  DRM_FORMAT_MOD_QCOM_COMPRESSED\n",
1006                                 (char *)&format);
1007                 break;
1008         default:
1009                 DPU_ERROR("unsupported format modifier %llX\n", modifier);
1010                 return NULL;
1011         }
1012
1013         for (i = 0; i < map_size; i++) {
1014                 if (format == map[i].base.pixel_format) {
1015                         fmt = &map[i];
1016                         break;
1017                 }
1018         }
1019
1020         if (fmt == NULL)
1021                 DPU_ERROR("unsupported fmt: %4.4s modifier 0x%llX\n",
1022                         (char *)&format, modifier);
1023         else
1024                 DPU_DEBUG("fmt %4.4s mod 0x%llX ubwc %d yuv %d\n",
1025                                 (char *)&format, modifier,
1026                                 DPU_FORMAT_IS_UBWC(fmt),
1027                                 DPU_FORMAT_IS_YUV(fmt));
1028
1029         return fmt;
1030 }
1031
1032 const struct msm_format *dpu_get_msm_format(
1033                 struct msm_kms *kms,
1034                 const uint32_t format,
1035                 const uint64_t modifiers)
1036 {
1037         const struct dpu_format *fmt = dpu_get_dpu_format_ext(format,
1038                         modifiers);
1039         if (fmt)
1040                 return &fmt->base;
1041         return NULL;
1042 }