drivers/gpu/drm/arm/malidp_hw.c

   1 /*
   2  * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
   3  * Author: Liviu Dudau <Liviu.Dudau@arm.com>
   4  *
   5  * This program is free software and is provided to you under the terms of the
   6  * GNU General Public License version 2 as published by the Free Software
   7  * Foundation, and any use by you of this program is subject to the terms
   8  * of such GNU licence.
   9  *
  10  * ARM Mali DP500/DP550/DP650 hardware manipulation routines. This is where
  11  * the difference between various versions of the hardware is being dealt with
  12  * in an attempt to provide to the rest of the driver code a unified view
  13  */
  14
  15 #include <linux/types.h>
  16 #include <linux/io.h>
  17 #include <drm/drmP.h>
  18 #include <video/videomode.h>
  19 #include <video/display_timing.h>
  20
  21 #include "malidp_drv.h"
  22 #include "malidp_hw.h"
  23
  24 static const struct malidp_format_id malidp500_de_formats[] = {
  25         /*    fourcc,   layers supporting the format,     internal id  */
  26         { DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  0 },
  27         { DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  1 },
  28         { DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  2 },
  29         { DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  3 },
  30         { DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  4 },
  31         { DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  5 },
  32         { DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  6 },
  33         { DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  7 },
  34         { DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  8 },
  35         { DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  9 },
  36         { DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 10 },
  37         { DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 11 },
  38         { DRM_FORMAT_UYVY, DE_VIDEO1, 12 },
  39         { DRM_FORMAT_YUYV, DE_VIDEO1, 13 },
  40         { DRM_FORMAT_NV12, DE_VIDEO1, 14 },
  41         { DRM_FORMAT_YUV420, DE_VIDEO1, 15 },
  42 };
  43
  44 #define MALIDP_ID(__group, __format) \
  45         ((((__group) & 0x7) << 3) | ((__format) & 0x7))
  46
  47 #define MALIDP_COMMON_FORMATS \
  48         /*    fourcc,   layers supporting the format,      internal id   */ \
  49         { DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 0) }, \
  50         { DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 1) }, \
  51         { DRM_FORMAT_RGBA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 2) }, \
  52         { DRM_FORMAT_BGRA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 3) }, \
  53         { DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 0) }, \
  54         { DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 1) }, \
  55         { DRM_FORMAT_RGBA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 2) }, \
  56         { DRM_FORMAT_BGRA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 3) }, \
  57         { DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 0) }, \
  58         { DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 1) }, \
  59         { DRM_FORMAT_RGBX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 2) }, \
  60         { DRM_FORMAT_BGRX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 3) }, \
  61         { DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 0) }, \
  62         { DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 1) }, \
  63         { DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 0) }, \
  64         { DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 1) }, \
  65         { DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 2) }, \
  66         { DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 3) }, \
  67         { DRM_FORMAT_YUYV, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 2) },    \
  68         { DRM_FORMAT_UYVY, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 3) },    \
  69         { DRM_FORMAT_NV12, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 6) },    \
  70         { DRM_FORMAT_YUV420, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 7) }
  71
  72 static const struct malidp_format_id malidp550_de_formats[] = {
  73         MALIDP_COMMON_FORMATS,
  74 };
  75
  76 static const struct malidp_layer malidp500_layers[] = {
  77         { DE_VIDEO1, MALIDP500_DE_LV_BASE, MALIDP500_DE_LV_PTR_BASE, MALIDP_DE_LV_STRIDE0 },
  78         { DE_GRAPHICS1, MALIDP500_DE_LG1_BASE, MALIDP500_DE_LG1_PTR_BASE, MALIDP_DE_LG_STRIDE },
  79         { DE_GRAPHICS2, MALIDP500_DE_LG2_BASE, MALIDP500_DE_LG2_PTR_BASE, MALIDP_DE_LG_STRIDE },
  80 };
  81
  82 static const struct malidp_layer malidp550_layers[] = {
  83         { DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE, MALIDP_DE_LV_STRIDE0 },
  84         { DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE, MALIDP_DE_LG_STRIDE },
  85         { DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE, MALIDP_DE_LV_STRIDE0 },
  86         { DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE, 0 },
  87 };
  88
  89 #define MALIDP_DE_DEFAULT_PREFETCH_START        5
  90
  91 static int malidp500_query_hw(struct malidp_hw_device *hwdev)
  92 {
  93         u32 conf = malidp_hw_read(hwdev, MALIDP500_CONFIG_ID);
  94         /* bit 4 of the CONFIG_ID register holds the line size multiplier */
  95         u8 ln_size_mult = conf & 0x10 ? 2 : 1;
  96
  97         hwdev->min_line_size = 2;
  98         hwdev->max_line_size = SZ_2K * ln_size_mult;
  99         hwdev->rotation_memory[0] = SZ_1K * 64 * ln_size_mult;
 100         hwdev->rotation_memory[1] = 0; /* no second rotation memory bank */
 101
 102         return 0;
 103 }
 104
 105 static void malidp500_enter_config_mode(struct malidp_hw_device *hwdev)
 106 {
 107         u32 status, count = 100;
 108
 109         malidp_hw_setbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
 110         while (count) {
 111                 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
 112                 if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
 113                         break;
 114                 /*
 115                  * entering config mode can take as long as the rendering
 116                  * of a full frame, hence the long sleep here
 117                  */
 118                 usleep_range(1000, 10000);
 119                 count--;
 120         }
 121         WARN(count == 0, "timeout while entering config mode");
 122 }
 123
 124 static void malidp500_leave_config_mode(struct malidp_hw_device *hwdev)
 125 {
 126         u32 status, count = 100;
 127
 128         malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
 129         malidp_hw_clearbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
 130         while (count) {
 131                 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
 132                 if ((status & MALIDP500_DC_CONFIG_REQ) == 0)
 133                         break;
 134                 usleep_range(100, 1000);
 135                 count--;
 136         }
 137         WARN(count == 0, "timeout while leaving config mode");
 138 }
 139
 140 static bool malidp500_in_config_mode(struct malidp_hw_device *hwdev)
 141 {
 142         u32 status;
 143
 144         status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
 145         if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
 146                 return true;
 147
 148         return false;
 149 }
 150
 151 static void malidp500_set_config_valid(struct malidp_hw_device *hwdev)
 152 {
 153         malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
 154 }
 155
 156 static void malidp500_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
 157 {
 158         u32 val = 0;
 159
 160         malidp_hw_clearbits(hwdev, MALIDP500_DC_CLEAR_MASK, MALIDP500_DC_CONTROL);
 161         if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
 162                 val |= MALIDP500_HSYNCPOL;
 163         if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
 164                 val |= MALIDP500_VSYNCPOL;
 165         val |= MALIDP_DE_DEFAULT_PREFETCH_START;
 166         malidp_hw_setbits(hwdev, val, MALIDP500_DC_CONTROL);
 167
 168         /*
 169          * Mali-DP500 encodes the background color like this:
 170          *    - red   @ MALIDP500_BGND_COLOR[12:0]
 171          *    - green @ MALIDP500_BGND_COLOR[27:16]
 172          *    - blue  @ (MALIDP500_BGND_COLOR + 4)[12:0]
 173          */
 174         val = ((MALIDP_BGND_COLOR_G & 0xfff) << 16) |
 175               (MALIDP_BGND_COLOR_R & 0xfff);
 176         malidp_hw_write(hwdev, val, MALIDP500_BGND_COLOR);
 177         malidp_hw_write(hwdev, MALIDP_BGND_COLOR_B, MALIDP500_BGND_COLOR + 4);
 178
 179         val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
 180                 MALIDP_DE_H_BACKPORCH(mode->hback_porch);
 181         malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
 182
 183         val = MALIDP500_DE_V_FRONTPORCH(mode->vfront_porch) |
 184                 MALIDP_DE_V_BACKPORCH(mode->vback_porch);
 185         malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
 186
 187         val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
 188                 MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
 189         malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
 190
 191         val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
 192         malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
 193
 194         if (mode->flags & DISPLAY_FLAGS_INTERLACED)
 195                 malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
 196         else
 197                 malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
 198 }
 199
 200 static int malidp500_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
 201 {
 202         /* RGB888 or BGR888 can't be rotated */
 203         if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
 204                 return -EINVAL;
 205
 206         /*
 207          * Each layer needs enough rotation memory to fit 8 lines
 208          * worth of pixel data. Required size is then:
 209          *    size = rotated_width * (bpp / 8) * 8;
 210          */
 211         return w * drm_format_plane_cpp(fmt, 0) * 8;
 212 }
 213
 214 static int malidp550_query_hw(struct malidp_hw_device *hwdev)
 215 {
 216         u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
 217         u8 ln_size = (conf >> 4) & 0x3, rsize;
 218
 219         hwdev->min_line_size = 2;
 220
 221         switch (ln_size) {
 222         case 0:
 223                 hwdev->max_line_size = SZ_2K;
 224                 /* two banks of 64KB for rotation memory */
 225                 rsize = 64;
 226                 break;
 227         case 1:
 228                 hwdev->max_line_size = SZ_4K;
 229                 /* two banks of 128KB for rotation memory */
 230                 rsize = 128;
 231                 break;
 232         case 2:
 233                 hwdev->max_line_size = 1280;
 234                 /* two banks of 40KB for rotation memory */
 235                 rsize = 40;
 236                 break;
 237         case 3:
 238                 /* reserved value */
 239                 hwdev->max_line_size = 0;
 240                 return -EINVAL;
 241         }
 242
 243         hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
 244         return 0;
 245 }
 246
 247 static void malidp550_enter_config_mode(struct malidp_hw_device *hwdev)
 248 {
 249         u32 status, count = 100;
 250
 251         malidp_hw_setbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
 252         while (count) {
 253                 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
 254                 if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
 255                         break;
 256                 /*
 257                  * entering config mode can take as long as the rendering
 258                  * of a full frame, hence the long sleep here
 259                  */
 260                 usleep_range(1000, 10000);
 261                 count--;
 262         }
 263         WARN(count == 0, "timeout while entering config mode");
 264 }
 265
 266 static void malidp550_leave_config_mode(struct malidp_hw_device *hwdev)
 267 {
 268         u32 status, count = 100;
 269
 270         malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
 271         malidp_hw_clearbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
 272         while (count) {
 273                 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
 274                 if ((status & MALIDP550_DC_CONFIG_REQ) == 0)
 275                         break;
 276                 usleep_range(100, 1000);
 277                 count--;
 278         }
 279         WARN(count == 0, "timeout while leaving config mode");
 280 }
 281
 282 static bool malidp550_in_config_mode(struct malidp_hw_device *hwdev)
 283 {
 284         u32 status;
 285
 286         status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
 287         if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
 288                 return true;
 289
 290         return false;
 291 }
 292
 293 static void malidp550_set_config_valid(struct malidp_hw_device *hwdev)
 294 {
 295         malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
 296 }
 297
 298 static void malidp550_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
 299 {
 300         u32 val = MALIDP_DE_DEFAULT_PREFETCH_START;
 301
 302         malidp_hw_write(hwdev, val, MALIDP550_DE_CONTROL);
 303         /*
 304          * Mali-DP550 and Mali-DP650 encode the background color like this:
 305          *   - red   @ MALIDP550_DE_BGND_COLOR[23:16]
 306          *   - green @ MALIDP550_DE_BGND_COLOR[15:8]
 307          *   - blue  @ MALIDP550_DE_BGND_COLOR[7:0]
 308          *
 309          * We need to truncate the least significant 4 bits from the default
 310          * MALIDP_BGND_COLOR_x values
 311          */
 312         val = (((MALIDP_BGND_COLOR_R >> 4) & 0xff) << 16) |
 313               (((MALIDP_BGND_COLOR_G >> 4) & 0xff) << 8) |
 314               ((MALIDP_BGND_COLOR_B >> 4) & 0xff);
 315         malidp_hw_write(hwdev, val, MALIDP550_DE_BGND_COLOR);
 316
 317         val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
 318                 MALIDP_DE_H_BACKPORCH(mode->hback_porch);
 319         malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
 320
 321         val = MALIDP550_DE_V_FRONTPORCH(mode->vfront_porch) |
 322                 MALIDP_DE_V_BACKPORCH(mode->vback_porch);
 323         malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
 324
 325         val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
 326                 MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
 327         if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
 328                 val |= MALIDP550_HSYNCPOL;
 329         if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
 330                 val |= MALIDP550_VSYNCPOL;
 331         malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
 332
 333         val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
 334         malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
 335
 336         if (mode->flags & DISPLAY_FLAGS_INTERLACED)
 337                 malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
 338         else
 339                 malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
 340 }
 341
 342 static int malidp550_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
 343 {
 344         u32 bytes_per_col;
 345
 346         /* raw RGB888 or BGR888 can't be rotated */
 347         if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
 348                 return -EINVAL;
 349
 350         switch (fmt) {
 351         /* 8 lines at 4 bytes per pixel */
 352         case DRM_FORMAT_ARGB2101010:
 353         case DRM_FORMAT_ABGR2101010:
 354         case DRM_FORMAT_RGBA1010102:
 355         case DRM_FORMAT_BGRA1010102:
 356         case DRM_FORMAT_ARGB8888:
 357         case DRM_FORMAT_ABGR8888:
 358         case DRM_FORMAT_RGBA8888:
 359         case DRM_FORMAT_BGRA8888:
 360         case DRM_FORMAT_XRGB8888:
 361         case DRM_FORMAT_XBGR8888:
 362         case DRM_FORMAT_RGBX8888:
 363         case DRM_FORMAT_BGRX8888:
 364         case DRM_FORMAT_RGB888:
 365         case DRM_FORMAT_BGR888:
 366         /* 16 lines at 2 bytes per pixel */
 367         case DRM_FORMAT_RGBA5551:
 368         case DRM_FORMAT_ABGR1555:
 369         case DRM_FORMAT_RGB565:
 370         case DRM_FORMAT_BGR565:
 371         case DRM_FORMAT_UYVY:
 372         case DRM_FORMAT_YUYV:
 373                 bytes_per_col = 32;
 374                 break;
 375         /* 16 lines at 1.5 bytes per pixel */
 376         case DRM_FORMAT_NV12:
 377         case DRM_FORMAT_YUV420:
 378                 bytes_per_col = 24;
 379                 break;
 380         default:
 381                 return -EINVAL;
 382         }
 383
 384         return w * bytes_per_col;
 385 }
 386
 387 static int malidp650_query_hw(struct malidp_hw_device *hwdev)
 388 {
 389         u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
 390         u8 ln_size = (conf >> 4) & 0x3, rsize;
 391
 392         hwdev->min_line_size = 4;
 393
 394         switch (ln_size) {
 395         case 0:
 396         case 2:
 397                 /* reserved values */
 398                 hwdev->max_line_size = 0;
 399                 return -EINVAL;
 400         case 1:
 401                 hwdev->max_line_size = SZ_4K;
 402                 /* two banks of 128KB for rotation memory */
 403                 rsize = 128;
 404                 break;
 405         case 3:
 406                 hwdev->max_line_size = 2560;
 407                 /* two banks of 80KB for rotation memory */
 408                 rsize = 80;
 409         }
 410
 411         hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
 412         return 0;
 413 }
 414
 415 const struct malidp_hw_device malidp_device[MALIDP_MAX_DEVICES] = {
 416         [MALIDP_500] = {
 417                 .map = {
 418                         .se_base = MALIDP500_SE_BASE,
 419                         .dc_base = MALIDP500_DC_BASE,
 420                         .out_depth_base = MALIDP500_OUTPUT_DEPTH,
 421                         .features = 0,  /* no CLEARIRQ register */
 422                         .n_layers = ARRAY_SIZE(malidp500_layers),
 423                         .layers = malidp500_layers,
 424                         .de_irq_map = {
 425                                 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
 426                                             MALIDP500_DE_IRQ_AXI_ERR |
 427                                             MALIDP500_DE_IRQ_VSYNC |
 428                                             MALIDP500_DE_IRQ_GLOBAL,
 429                                 .vsync_irq = MALIDP500_DE_IRQ_VSYNC,
 430                         },
 431                         .se_irq_map = {
 432                                 .irq_mask = MALIDP500_SE_IRQ_CONF_MODE,
 433                                 .vsync_irq = 0,
 434                         },
 435                         .dc_irq_map = {
 436                                 .irq_mask = MALIDP500_DE_IRQ_CONF_VALID,
 437                                 .vsync_irq = MALIDP500_DE_IRQ_CONF_VALID,
 438                         },
 439                         .pixel_formats = malidp500_de_formats,
 440                         .n_pixel_formats = ARRAY_SIZE(malidp500_de_formats),
 441                         .bus_align_bytes = 8,
 442                 },
 443                 .query_hw = malidp500_query_hw,
 444                 .enter_config_mode = malidp500_enter_config_mode,
 445                 .leave_config_mode = malidp500_leave_config_mode,
 446                 .in_config_mode = malidp500_in_config_mode,
 447                 .set_config_valid = malidp500_set_config_valid,
 448                 .modeset = malidp500_modeset,
 449                 .rotmem_required = malidp500_rotmem_required,
 450                 .features = MALIDP_DEVICE_LV_HAS_3_STRIDES,
 451         },
 452         [MALIDP_550] = {
 453                 .map = {
 454                         .se_base = MALIDP550_SE_BASE,
 455                         .dc_base = MALIDP550_DC_BASE,
 456                         .out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
 457                         .features = MALIDP_REGMAP_HAS_CLEARIRQ,
 458                         .n_layers = ARRAY_SIZE(malidp550_layers),
 459                         .layers = malidp550_layers,
 460                         .de_irq_map = {
 461                                 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
 462                                             MALIDP550_DE_IRQ_VSYNC,
 463                                 .vsync_irq = MALIDP550_DE_IRQ_VSYNC,
 464                         },
 465                         .se_irq_map = {
 466                                 .irq_mask = MALIDP550_SE_IRQ_EOW |
 467                                             MALIDP550_SE_IRQ_AXI_ERR,
 468                         },
 469                         .dc_irq_map = {
 470                                 .irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
 471                                 .vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
 472                         },
 473                         .pixel_formats = malidp550_de_formats,
 474                         .n_pixel_formats = ARRAY_SIZE(malidp550_de_formats),
 475                         .bus_align_bytes = 8,
 476                 },
 477                 .query_hw = malidp550_query_hw,
 478                 .enter_config_mode = malidp550_enter_config_mode,
 479                 .leave_config_mode = malidp550_leave_config_mode,
 480                 .in_config_mode = malidp550_in_config_mode,
 481                 .set_config_valid = malidp550_set_config_valid,
 482                 .modeset = malidp550_modeset,
 483                 .rotmem_required = malidp550_rotmem_required,
 484                 .features = 0,
 485         },
 486         [MALIDP_650] = {
 487                 .map = {
 488                         .se_base = MALIDP550_SE_BASE,
 489                         .dc_base = MALIDP550_DC_BASE,
 490                         .out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
 491                         .features = MALIDP_REGMAP_HAS_CLEARIRQ,
 492                         .n_layers = ARRAY_SIZE(malidp550_layers),
 493                         .layers = malidp550_layers,
 494                         .de_irq_map = {
 495                                 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
 496                                             MALIDP650_DE_IRQ_DRIFT |
 497                                             MALIDP550_DE_IRQ_VSYNC,
 498                                 .vsync_irq = MALIDP550_DE_IRQ_VSYNC,
 499                         },
 500                         .se_irq_map = {
 501                                 .irq_mask = MALIDP550_SE_IRQ_EOW |
 502                                             MALIDP550_SE_IRQ_AXI_ERR,
 503                         },
 504                         .dc_irq_map = {
 505                                 .irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
 506                                 .vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
 507                         },
 508                         .pixel_formats = malidp550_de_formats,
 509                         .n_pixel_formats = ARRAY_SIZE(malidp550_de_formats),
 510                         .bus_align_bytes = 16,
 511                 },
 512                 .query_hw = malidp650_query_hw,
 513                 .enter_config_mode = malidp550_enter_config_mode,
 514                 .leave_config_mode = malidp550_leave_config_mode,
 515                 .in_config_mode = malidp550_in_config_mode,
 516                 .set_config_valid = malidp550_set_config_valid,
 517                 .modeset = malidp550_modeset,
 518                 .rotmem_required = malidp550_rotmem_required,
 519                 .features = 0,
 520         },
 521 };
 522
 523 u8 malidp_hw_get_format_id(const struct malidp_hw_regmap *map,
 524                            u8 layer_id, u32 format)
 525 {
 526         unsigned int i;
 527
 528         for (i = 0; i < map->n_pixel_formats; i++) {
 529                 if (((map->pixel_formats[i].layer & layer_id) == layer_id) &&
 530                     (map->pixel_formats[i].format == format))
 531                         return map->pixel_formats[i].id;
 532         }
 533
 534         return MALIDP_INVALID_FORMAT_ID;
 535 }
 536
 537 static void malidp_hw_clear_irq(struct malidp_hw_device *hwdev, u8 block, u32 irq)
 538 {
 539         u32 base = malidp_get_block_base(hwdev, block);
 540
 541         if (hwdev->map.features & MALIDP_REGMAP_HAS_CLEARIRQ)
 542                 malidp_hw_write(hwdev, irq, base + MALIDP_REG_CLEARIRQ);
 543         else
 544                 malidp_hw_write(hwdev, irq, base + MALIDP_REG_STATUS);
 545 }
 546
 547 static irqreturn_t malidp_de_irq(int irq, void *arg)
 548 {
 549         struct drm_device *drm = arg;
 550         struct malidp_drm *malidp = drm->dev_private;
 551         struct malidp_hw_device *hwdev;
 552         const struct malidp_irq_map *de;
 553         u32 status, mask, dc_status;
 554         irqreturn_t ret = IRQ_NONE;
 555
 556         if (!drm->dev_private)
 557                 return IRQ_HANDLED;
 558
 559         hwdev = malidp->dev;
 560         de = &hwdev->map.de_irq_map;
 561
 562         /* first handle the config valid IRQ */
 563         dc_status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
 564         if (dc_status & hwdev->map.dc_irq_map.vsync_irq) {
 565                 /* we have a page flip event */
 566                 atomic_set(&malidp->config_valid, 1);
 567                 malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, dc_status);
 568                 ret = IRQ_WAKE_THREAD;
 569         }
 570
 571         status = malidp_hw_read(hwdev, MALIDP_REG_STATUS);
 572         if (!(status & de->irq_mask))
 573                 return ret;
 574
 575         mask = malidp_hw_read(hwdev, MALIDP_REG_MASKIRQ);
 576         status &= mask;
 577         if (status & de->vsync_irq)
 578                 drm_crtc_handle_vblank(&malidp->crtc);
 579
 580         malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, status);
 581
 582         return (ret == IRQ_NONE) ? IRQ_HANDLED : ret;
 583 }
 584
 585 static irqreturn_t malidp_de_irq_thread_handler(int irq, void *arg)
 586 {
 587         struct drm_device *drm = arg;
 588         struct malidp_drm *malidp = drm->dev_private;
 589
 590         wake_up(&malidp->wq);
 591
 592         return IRQ_HANDLED;
 593 }
 594
 595 int malidp_de_irq_init(struct drm_device *drm, int irq)
 596 {
 597         struct malidp_drm *malidp = drm->dev_private;
 598         struct malidp_hw_device *hwdev = malidp->dev;
 599         int ret;
 600
 601         /* ensure interrupts are disabled */
 602         malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
 603         malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
 604         malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
 605         malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
 606
 607         ret = devm_request_threaded_irq(drm->dev, irq, malidp_de_irq,
 608                                         malidp_de_irq_thread_handler,
 609                                         IRQF_SHARED, "malidp-de", drm);
 610         if (ret < 0) {
 611                 DRM_ERROR("failed to install DE IRQ handler\n");
 612                 return ret;
 613         }
 614
 615         /* first enable the DC block IRQs */
 616         malidp_hw_enable_irq(hwdev, MALIDP_DC_BLOCK,
 617                              hwdev->map.dc_irq_map.irq_mask);
 618
 619         /* now enable the DE block IRQs */
 620         malidp_hw_enable_irq(hwdev, MALIDP_DE_BLOCK,
 621                              hwdev->map.de_irq_map.irq_mask);
 622
 623         return 0;
 624 }
 625
 626 void malidp_de_irq_fini(struct drm_device *drm)
 627 {
 628         struct malidp_drm *malidp = drm->dev_private;
 629         struct malidp_hw_device *hwdev = malidp->dev;
 630
 631         malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK,
 632                               hwdev->map.de_irq_map.irq_mask);
 633         malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK,
 634                               hwdev->map.dc_irq_map.irq_mask);
 635 }
 636
 637 static irqreturn_t malidp_se_irq(int irq, void *arg)
 638 {
 639         struct drm_device *drm = arg;
 640         struct malidp_drm *malidp = drm->dev_private;
 641         struct malidp_hw_device *hwdev = malidp->dev;
 642         u32 status, mask;
 643
 644         status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
 645         if (!(status & hwdev->map.se_irq_map.irq_mask))
 646                 return IRQ_NONE;
 647
 648         mask = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_MASKIRQ);
 649         status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
 650         status &= mask;
 651         /* ToDo: status decoding and firing up of VSYNC and page flip events */
 652
 653         malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, status);
 654
 655         return IRQ_HANDLED;
 656 }
 657
 658 static irqreturn_t malidp_se_irq_thread_handler(int irq, void *arg)
 659 {
 660         return IRQ_HANDLED;
 661 }
 662
 663 int malidp_se_irq_init(struct drm_device *drm, int irq)
 664 {
 665         struct malidp_drm *malidp = drm->dev_private;
 666         struct malidp_hw_device *hwdev = malidp->dev;
 667         int ret;
 668
 669         /* ensure interrupts are disabled */
 670         malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
 671         malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
 672
 673         ret = devm_request_threaded_irq(drm->dev, irq, malidp_se_irq,
 674                                         malidp_se_irq_thread_handler,
 675                                         IRQF_SHARED, "malidp-se", drm);
 676         if (ret < 0) {
 677                 DRM_ERROR("failed to install SE IRQ handler\n");
 678                 return ret;
 679         }
 680
 681         malidp_hw_enable_irq(hwdev, MALIDP_SE_BLOCK,
 682                              hwdev->map.se_irq_map.irq_mask);
 683
 684         return 0;
 685 }
 686
 687 void malidp_se_irq_fini(struct drm_device *drm)
 688 {
 689         struct malidp_drm *malidp = drm->dev_private;
 690         struct malidp_hw_device *hwdev = malidp->dev;
 691
 692         malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK,
 693                               hwdev->map.se_irq_map.irq_mask);
 694 }