drivers/gpu/drm/vc4/vc4_firmware_kms.c

   1 /*
   2  * Copyright (C) 2016 Broadcom
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  */
   8
   9 /**
  10  * DOC: VC4 firmware KMS module.
  11  *
  12  * As a hack to get us from the current closed source driver world
  13  * toward a totally open stack, implement KMS on top of the Raspberry
  14  * Pi's firmware display stack.
  15  */
  16
  17 #include "drm/drm_atomic_helper.h"
  18 #include "drm/drm_gem_framebuffer_helper.h"
  19 #include "drm/drm_plane_helper.h"
  20 #include "drm/drm_crtc_helper.h"
  21 #include "drm/drm_fourcc.h"
  22 #include "drm/drm_probe_helper.h"
  23 #include "drm/drm_drv.h"
  24 #include "drm/drm_vblank.h"
  25 #include "linux/clk.h"
  26 #include "linux/debugfs.h"
  27 #include "drm/drm_fb_cma_helper.h"
  28 #include "linux/component.h"
  29 #include "linux/of_device.h"
  30 #include "vc4_drv.h"
  31 #include "vc4_regs.h"
  32 #include "vc_image_types.h"
  33 #include <soc/bcm2835/raspberrypi-firmware.h>
  34
  35 struct get_display_cfg {
  36         u32  max_pixel_clock[2];  //Max pixel clock for each display
  37 };
  38
  39 struct vc4_fkms {
  40         struct get_display_cfg cfg;
  41 };
  42
  43 #define PLANES_PER_CRTC         3
  44
  45 struct set_plane {
  46         u8 display;
  47         u8 plane_id;
  48         u8 vc_image_type;
  49         s8 layer;
  50
  51         u16 width;
  52         u16 height;
  53
  54         u16 pitch;
  55         u16 vpitch;
  56
  57         u32 src_x;      /* 16p16 */
  58         u32 src_y;      /* 16p16 */
  59
  60         u32 src_w;      /* 16p16 */
  61         u32 src_h;      /* 16p16 */
  62
  63         s16 dst_x;
  64         s16 dst_y;
  65
  66         u16 dst_w;
  67         u16 dst_h;
  68
  69         u8 alpha;
  70         u8 num_planes;
  71         u8 is_vu;
  72         u8 padding;
  73
  74         u32 planes[4];  /* DMA address of each plane */
  75
  76         u32 transform;
  77 };
  78
  79 /* Values for the transform field */
  80 #define TRANSFORM_NO_ROTATE     0
  81 #define TRANSFORM_ROTATE_180    BIT(1)
  82 #define TRANSFORM_FLIP_HRIZ     BIT(16)
  83 #define TRANSFORM_FLIP_VERT     BIT(17)
  84
  85 #define SUPPORTED_ROTATIONS     (DRM_MODE_ROTATE_0 | \
  86                                  DRM_MODE_ROTATE_180 | \
  87                                  DRM_MODE_REFLECT_X | \
  88                                  DRM_MODE_REFLECT_Y)
  89
  90 struct mailbox_set_plane {
  91         struct rpi_firmware_property_tag_header tag;
  92         struct set_plane plane;
  93 };
  94
  95 struct mailbox_blank_display {
  96         struct rpi_firmware_property_tag_header tag1;
  97         u32 display;
  98         struct rpi_firmware_property_tag_header tag2;
  99         u32 blank;
 100 };
 101
 102 struct mailbox_get_edid {
 103         struct rpi_firmware_property_tag_header tag1;
 104         u32 block;
 105         u32 display_number;
 106         u8 edid[128];
 107 };
 108
 109 struct set_timings {
 110         u8 display;
 111         u8 padding;
 112         u16 video_id_code;
 113
 114         u32 clock;              /* in kHz */
 115
 116         u16 hdisplay;
 117         u16 hsync_start;
 118
 119         u16 hsync_end;
 120         u16 htotal;
 121
 122         u16 hskew;
 123         u16 vdisplay;
 124
 125         u16 vsync_start;
 126         u16 vsync_end;
 127
 128         u16 vtotal;
 129         u16 vscan;
 130
 131         u16 vrefresh;
 132         u16 padding2;
 133
 134         u32 flags;
 135 #define  TIMINGS_FLAGS_H_SYNC_POS       BIT(0)
 136 #define  TIMINGS_FLAGS_H_SYNC_NEG       0
 137 #define  TIMINGS_FLAGS_V_SYNC_POS       BIT(1)
 138 #define  TIMINGS_FLAGS_V_SYNC_NEG       0
 139 #define  TIMINGS_FLAGS_INTERLACE        BIT(2)
 140
 141 #define TIMINGS_FLAGS_ASPECT_MASK       GENMASK(7, 4)
 142 #define TIMINGS_FLAGS_ASPECT_NONE       (0 << 4)
 143 #define TIMINGS_FLAGS_ASPECT_4_3        (1 << 4)
 144 #define TIMINGS_FLAGS_ASPECT_16_9       (2 << 4)
 145 #define TIMINGS_FLAGS_ASPECT_64_27      (3 << 4)
 146 #define TIMINGS_FLAGS_ASPECT_256_135    (4 << 4)
 147
 148 /* Limited range RGB flag. Not set corresponds to full range. */
 149 #define TIMINGS_FLAGS_RGB_LIMITED       BIT(8)
 150 /* DVI monitor, therefore disable infoframes. Not set corresponds to HDMI. */
 151 #define TIMINGS_FLAGS_DVI               BIT(9)
 152 };
 153
 154 struct mailbox_set_mode {
 155         struct rpi_firmware_property_tag_header tag1;
 156         struct set_timings timings;
 157 };
 158
 159 static const struct vc_image_format {
 160         u32 drm;        /* DRM_FORMAT_* */
 161         u32 vc_image;   /* VC_IMAGE_* */
 162         u32 is_vu;
 163 } vc_image_formats[] = {
 164         {
 165                 .drm = DRM_FORMAT_XRGB8888,
 166                 .vc_image = VC_IMAGE_XRGB8888,
 167         },
 168         {
 169                 .drm = DRM_FORMAT_ARGB8888,
 170                 .vc_image = VC_IMAGE_ARGB8888,
 171         },
 172 /*
 173  *      FIXME: Need to resolve which DRM format goes to which vc_image format
 174  *      for the remaining RGBA and RGBX formats.
 175  *      {
 176  *              .drm = DRM_FORMAT_ABGR8888,
 177  *              .vc_image = VC_IMAGE_RGBA8888,
 178  *      },
 179  *      {
 180  *              .drm = DRM_FORMAT_XBGR8888,
 181  *              .vc_image = VC_IMAGE_RGBA8888,
 182  *      },
 183  */
 184         {
 185                 .drm = DRM_FORMAT_RGB565,
 186                 .vc_image = VC_IMAGE_RGB565,
 187         },
 188         {
 189                 .drm = DRM_FORMAT_RGB888,
 190                 .vc_image = VC_IMAGE_BGR888,
 191         },
 192         {
 193                 .drm = DRM_FORMAT_BGR888,
 194                 .vc_image = VC_IMAGE_RGB888,
 195         },
 196         {
 197                 .drm = DRM_FORMAT_YUV422,
 198                 .vc_image = VC_IMAGE_YUV422PLANAR,
 199         },
 200         {
 201                 .drm = DRM_FORMAT_YUV420,
 202                 .vc_image = VC_IMAGE_YUV420,
 203         },
 204         {
 205                 .drm = DRM_FORMAT_YVU420,
 206                 .vc_image = VC_IMAGE_YUV420,
 207                 .is_vu = 1,
 208         },
 209         {
 210                 .drm = DRM_FORMAT_NV12,
 211                 .vc_image = VC_IMAGE_YUV420SP,
 212         },
 213         {
 214                 .drm = DRM_FORMAT_NV21,
 215                 .vc_image = VC_IMAGE_YUV420SP,
 216                 .is_vu = 1,
 217         },
 218 };
 219
 220 static const struct vc_image_format *vc4_get_vc_image_fmt(u32 drm_format)
 221 {
 222         unsigned int i;
 223
 224         for (i = 0; i < ARRAY_SIZE(vc_image_formats); i++) {
 225                 if (vc_image_formats[i].drm == drm_format)
 226                         return &vc_image_formats[i];
 227         }
 228
 229         return NULL;
 230 }
 231
 232 /* The firmware delivers a vblank interrupt to us through the SMI
 233  * hardware, which has only this one register.
 234  */
 235 #define SMICS 0x0
 236 #define SMICS_INTERRUPTS (BIT(9) | BIT(10) | BIT(11))
 237
 238 #define vc4_crtc vc4_kms_crtc
 239 #define to_vc4_crtc to_vc4_kms_crtc
 240 struct vc4_crtc {
 241         struct drm_crtc base;
 242         struct drm_encoder *encoder;
 243         struct drm_connector *connector;
 244         void __iomem *regs;
 245
 246         struct drm_pending_vblank_event *event;
 247         bool vblank_enabled;
 248         u32 display_number;
 249         u32 display_type;
 250 };
 251
 252 static inline struct vc4_crtc *to_vc4_crtc(struct drm_crtc *crtc)
 253 {
 254         return container_of(crtc, struct vc4_crtc, base);
 255 }
 256
 257 struct vc4_fkms_encoder {
 258         struct drm_encoder base;
 259         bool hdmi_monitor;
 260 };
 261
 262 static inline struct vc4_fkms_encoder *
 263 to_vc4_fkms_encoder(struct drm_encoder *encoder)
 264 {
 265         return container_of(encoder, struct vc4_fkms_encoder, base);
 266 }
 267
 268 /* VC4 FKMS connector KMS struct */
 269 struct vc4_fkms_connector {
 270         struct drm_connector base;
 271
 272         /* Since the connector is attached to just the one encoder,
 273          * this is the reference to it so we can do the best_encoder()
 274          * hook.
 275          */
 276         struct drm_encoder *encoder;
 277         struct vc4_dev *vc4_dev;
 278         u32 display_number;
 279         u32 display_type;
 280 };
 281
 282 static inline struct vc4_fkms_connector *
 283 to_vc4_fkms_connector(struct drm_connector *connector)
 284 {
 285         return container_of(connector, struct vc4_fkms_connector, base);
 286 }
 287
 288 static u32 vc4_get_display_type(u32 display_number)
 289 {
 290         const u32 display_types[] = {
 291                 /* The firmware display (DispmanX) IDs map to specific types in
 292                  * a fixed manner.
 293                  */
 294                 DRM_MODE_ENCODER_DSI,   /* MAIN_LCD - DSI or DPI */
 295                 DRM_MODE_ENCODER_DSI,   /* AUX_LCD */
 296                 DRM_MODE_ENCODER_TMDS,  /* HDMI0 */
 297                 DRM_MODE_ENCODER_TVDAC, /* VEC */
 298                 DRM_MODE_ENCODER_NONE,  /* FORCE_LCD */
 299                 DRM_MODE_ENCODER_NONE,  /* FORCE_TV */
 300                 DRM_MODE_ENCODER_NONE,  /* FORCE_OTHER */
 301                 DRM_MODE_ENCODER_TMDS,  /* HDMI1 */
 302                 DRM_MODE_ENCODER_NONE,  /* FORCE_TV2 */
 303         };
 304         return display_number > ARRAY_SIZE(display_types) - 1 ?
 305                         DRM_MODE_ENCODER_NONE : display_types[display_number];
 306 }
 307
 308 /* Firmware's structure for making an FB mbox call. */
 309 struct fbinfo_s {
 310         u32 xres, yres, xres_virtual, yres_virtual;
 311         u32 pitch, bpp;
 312         u32 xoffset, yoffset;
 313         u32 base;
 314         u32 screen_size;
 315         u16 cmap[256];
 316 };
 317
 318 struct vc4_fkms_plane {
 319         struct drm_plane base;
 320         struct fbinfo_s *fbinfo;
 321         dma_addr_t fbinfo_bus_addr;
 322         u32 pitch;
 323         struct mailbox_set_plane mb;
 324 };
 325
 326 static inline struct vc4_fkms_plane *to_vc4_fkms_plane(struct drm_plane *plane)
 327 {
 328         return (struct vc4_fkms_plane *)plane;
 329 }
 330
 331 static int vc4_plane_set_blank(struct drm_plane *plane, bool blank)
 332 {
 333         struct vc4_dev *vc4 = to_vc4_dev(plane->dev);
 334         struct vc4_fkms_plane *vc4_plane = to_vc4_fkms_plane(plane);
 335         struct mailbox_set_plane blank_mb = {
 336                 .tag = { RPI_FIRMWARE_SET_PLANE, sizeof(struct set_plane), 0 },
 337                 .plane = {
 338                         .display = vc4_plane->mb.plane.display,
 339                         .plane_id = vc4_plane->mb.plane.plane_id,
 340                 }
 341         };
 342         static const char * const plane_types[] = {
 343                                                         "overlay",
 344                                                         "primary",
 345                                                         "cursor"
 346                                                   };
 347         int ret;
 348
 349         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] %s plane %s",
 350                          plane->base.id, plane->name, plane_types[plane->type],
 351                          blank ? "blank" : "unblank");
 352
 353         if (blank)
 354                 ret = rpi_firmware_property_list(vc4->firmware, &blank_mb,
 355                                                  sizeof(blank_mb));
 356         else
 357                 ret = rpi_firmware_property_list(vc4->firmware, &vc4_plane->mb,
 358                                                  sizeof(vc4_plane->mb));
 359
 360         WARN_ONCE(ret, "%s: firmware call failed. Please update your firmware",
 361                   __func__);
 362         return ret;
 363 }
 364
 365 static void vc4_plane_atomic_update(struct drm_plane *plane,
 366                                     struct drm_plane_state *old_state)
 367 {
 368         struct drm_plane_state *state = plane->state;
 369         struct drm_framebuffer *fb = state->fb;
 370         struct drm_gem_cma_object *bo = drm_fb_cma_get_gem_obj(fb, 0);
 371         const struct drm_format_info *drm_fmt = fb->format;
 372         const struct vc_image_format *vc_fmt =
 373                                         vc4_get_vc_image_fmt(drm_fmt->format);
 374         struct vc4_fkms_plane *vc4_plane = to_vc4_fkms_plane(plane);
 375         struct mailbox_set_plane *mb = &vc4_plane->mb;
 376         int num_planes = fb->format->num_planes;
 377         struct drm_display_mode *mode = &state->crtc->mode;
 378         unsigned int rotation = SUPPORTED_ROTATIONS;
 379
 380         mb->plane.vc_image_type = vc_fmt->vc_image;
 381         mb->plane.width = fb->width;
 382         mb->plane.height = fb->height;
 383         mb->plane.pitch = fb->pitches[0];
 384         mb->plane.src_w = state->src_w;
 385         mb->plane.src_h = state->src_h;
 386         mb->plane.src_x = state->src_x;
 387         mb->plane.src_y = state->src_y;
 388         mb->plane.dst_w = state->crtc_w;
 389         mb->plane.dst_h = state->crtc_h;
 390         mb->plane.dst_x = state->crtc_x;
 391         mb->plane.dst_y = state->crtc_y;
 392         mb->plane.alpha = state->alpha >> 8;
 393         mb->plane.layer = state->normalized_zpos ?
 394                                         state->normalized_zpos : -127;
 395         mb->plane.num_planes = num_planes;
 396         mb->plane.is_vu = vc_fmt->is_vu;
 397         mb->plane.planes[0] = bo->paddr + fb->offsets[0];
 398
 399         rotation = drm_rotation_simplify(state->rotation, rotation);
 400
 401         switch (rotation) {
 402         default:
 403         case DRM_MODE_ROTATE_0:
 404                 mb->plane.transform = TRANSFORM_NO_ROTATE;
 405                 break;
 406         case DRM_MODE_ROTATE_180:
 407                 mb->plane.transform = TRANSFORM_ROTATE_180;
 408                 break;
 409         case DRM_MODE_REFLECT_X:
 410                 mb->plane.transform = TRANSFORM_FLIP_HRIZ;
 411                 break;
 412         case DRM_MODE_REFLECT_Y:
 413                 mb->plane.transform = TRANSFORM_FLIP_VERT;
 414                 break;
 415         }
 416
 417         /* FIXME: If the dest rect goes off screen then clip the src rect so we
 418          * don't have off-screen pixels.
 419          */
 420         if (plane->type == DRM_PLANE_TYPE_CURSOR) {
 421                 /* There is no scaling on the cursor plane, therefore the calcs
 422                  * to alter the source crop as the cursor goes off the screen
 423                  * are simple.
 424                  */
 425                 if (mb->plane.dst_x + mb->plane.dst_w > mode->hdisplay) {
 426                         mb->plane.dst_w = mode->hdisplay - mb->plane.dst_x;
 427                         mb->plane.src_w = (mode->hdisplay - mb->plane.dst_x)
 428                                                                         << 16;
 429                 }
 430                 if (mb->plane.dst_y + mb->plane.dst_h > mode->vdisplay) {
 431                         mb->plane.dst_h = mode->vdisplay - mb->plane.dst_y;
 432                         mb->plane.src_h = (mode->vdisplay - mb->plane.dst_y)
 433                                                                         << 16;
 434                 }
 435         }
 436
 437         if (num_planes > 1) {
 438                 /* Assume this must be YUV */
 439                 /* Makes assumptions on the stride for the chroma planes as we
 440                  * can't easily plumb in non-standard pitches.
 441                  */
 442                 mb->plane.planes[1] = bo->paddr + fb->offsets[1];
 443                 if (num_planes > 2)
 444                         mb->plane.planes[2] = bo->paddr + fb->offsets[2];
 445                 else
 446                         mb->plane.planes[2] = 0;
 447
 448                 /* Special case the YUV420 with U and V as line interleaved
 449                  * planes as we have special handling for that case.
 450                  */
 451                 if (num_planes == 3 &&
 452                     (fb->offsets[2] - fb->offsets[1]) == fb->pitches[1])
 453                         mb->plane.vc_image_type = VC_IMAGE_YUV420_S;
 454         } else {
 455                 mb->plane.planes[1] = 0;
 456                 mb->plane.planes[2] = 0;
 457         }
 458         mb->plane.planes[3] = 0;
 459
 460         switch (fb->modifier) {
 461         case DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED:
 462                 switch (mb->plane.vc_image_type) {
 463                 case VC_IMAGE_RGBX32:
 464                         mb->plane.vc_image_type = VC_IMAGE_TF_RGBX32;
 465                         break;
 466                 case VC_IMAGE_RGBA32:
 467                         mb->plane.vc_image_type = VC_IMAGE_TF_RGBA32;
 468                         break;
 469                 case VC_IMAGE_RGB565:
 470                         mb->plane.vc_image_type = VC_IMAGE_TF_RGB565;
 471                         break;
 472                 }
 473                 break;
 474         case DRM_FORMAT_MOD_BROADCOM_SAND128:
 475                 mb->plane.vc_image_type = VC_IMAGE_YUV_UV;
 476                 mb->plane.pitch = fourcc_mod_broadcom_param(fb->modifier);
 477                 break;
 478         }
 479
 480         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] plane update %dx%d@%d +dst(%d,%d, %d,%d) +src(%d,%d, %d,%d) 0x%08x/%08x/%08x/%d, alpha %u zpos %u\n",
 481                          plane->base.id, plane->name,
 482                          mb->plane.width,
 483                          mb->plane.height,
 484                          mb->plane.vc_image_type,
 485                          state->crtc_x,
 486                          state->crtc_y,
 487                          state->crtc_w,
 488                          state->crtc_h,
 489                          mb->plane.src_x,
 490                          mb->plane.src_y,
 491                          mb->plane.src_w,
 492                          mb->plane.src_h,
 493                          mb->plane.planes[0],
 494                          mb->plane.planes[1],
 495                          mb->plane.planes[2],
 496                          fb->pitches[0],
 497                          state->alpha,
 498                          state->normalized_zpos);
 499
 500         /*
 501          * Do NOT set now, as we haven't checked if the crtc is active or not.
 502          * Set from vc4_plane_set_blank instead.
 503          *
 504          * If the CRTC is on (or going to be on) and we're enabled,
 505          * then unblank.  Otherwise, stay blank until CRTC enable.
 506          */
 507         if (state->crtc->state->active)
 508                 vc4_plane_set_blank(plane, false);
 509 }
 510
 511 static void vc4_plane_atomic_disable(struct drm_plane *plane,
 512                                      struct drm_plane_state *old_state)
 513 {
 514         //struct vc4_dev *vc4 = to_vc4_dev(plane->dev);
 515         struct drm_plane_state *state = plane->state;
 516         struct vc4_fkms_plane *vc4_plane = to_vc4_fkms_plane(plane);
 517
 518         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] plane disable %dx%d@%d +%d,%d\n",
 519                          plane->base.id, plane->name,
 520                          state->crtc_w,
 521                          state->crtc_h,
 522                          vc4_plane->mb.plane.vc_image_type,
 523                          state->crtc_x,
 524                          state->crtc_y);
 525         vc4_plane_set_blank(plane, true);
 526 }
 527
 528 static int vc4_plane_atomic_check(struct drm_plane *plane,
 529                                   struct drm_plane_state *state)
 530 {
 531         return 0;
 532 }
 533
 534 static void vc4_plane_destroy(struct drm_plane *plane)
 535 {
 536         drm_plane_cleanup(plane);
 537 }
 538
 539 static bool vc4_fkms_format_mod_supported(struct drm_plane *plane,
 540                                           uint32_t format,
 541                                           uint64_t modifier)
 542 {
 543         /* Support T_TILING for RGB formats only. */
 544         switch (format) {
 545         case DRM_FORMAT_XRGB8888:
 546         case DRM_FORMAT_ARGB8888:
 547         case DRM_FORMAT_RGB565:
 548                 switch (modifier) {
 549                 case DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED:
 550                 case DRM_FORMAT_MOD_LINEAR:
 551                 case DRM_FORMAT_MOD_BROADCOM_UIF:
 552                         return true;
 553                 default:
 554                         return false;
 555                 }
 556         case DRM_FORMAT_NV12:
 557                 switch (fourcc_mod_broadcom_mod(modifier)) {
 558                 case DRM_FORMAT_MOD_LINEAR:
 559                 case DRM_FORMAT_MOD_BROADCOM_SAND128:
 560                         return true;
 561                 default:
 562                         return false;
 563                 }
 564         case DRM_FORMAT_NV21:
 565         case DRM_FORMAT_RGB888:
 566         case DRM_FORMAT_BGR888:
 567         case DRM_FORMAT_YUV422:
 568         case DRM_FORMAT_YUV420:
 569         case DRM_FORMAT_YVU420:
 570         default:
 571                 return (modifier == DRM_FORMAT_MOD_LINEAR);
 572         }
 573 }
 574
 575 static const struct drm_plane_funcs vc4_plane_funcs = {
 576         .update_plane = drm_atomic_helper_update_plane,
 577         .disable_plane = drm_atomic_helper_disable_plane,
 578         .destroy = vc4_plane_destroy,
 579         .set_property = NULL,
 580         .reset = drm_atomic_helper_plane_reset,
 581         .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
 582         .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
 583         .format_mod_supported = vc4_fkms_format_mod_supported,
 584 };
 585
 586 static const struct drm_plane_helper_funcs vc4_plane_helper_funcs = {
 587         .prepare_fb = drm_gem_fb_prepare_fb,
 588         .cleanup_fb = NULL,
 589         .atomic_check = vc4_plane_atomic_check,
 590         .atomic_update = vc4_plane_atomic_update,
 591         .atomic_disable = vc4_plane_atomic_disable,
 592 };
 593
 594 static struct drm_plane *vc4_fkms_plane_init(struct drm_device *dev,
 595                                              enum drm_plane_type type,
 596                                              u8 display_num,
 597                                              u8 plane_id)
 598 {
 599         struct drm_plane *plane = NULL;
 600         struct vc4_fkms_plane *vc4_plane;
 601         u32 formats[ARRAY_SIZE(vc_image_formats)];
 602         unsigned int default_zpos = 0;
 603         u32 num_formats = 0;
 604         int ret = 0;
 605         static const uint64_t modifiers[] = {
 606                 DRM_FORMAT_MOD_LINEAR,
 607                 /* VC4_T_TILED should come after linear, because we
 608                  * would prefer to scan out linear (less bus traffic).
 609                  */
 610                 DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED,
 611                 DRM_FORMAT_MOD_BROADCOM_SAND128,
 612                 DRM_FORMAT_MOD_INVALID,
 613         };
 614         int i;
 615
 616         vc4_plane = devm_kzalloc(dev->dev, sizeof(*vc4_plane),
 617                                  GFP_KERNEL);
 618         if (!vc4_plane) {
 619                 ret = -ENOMEM;
 620                 goto fail;
 621         }
 622
 623         for (i = 0; i < ARRAY_SIZE(vc_image_formats); i++)
 624                 formats[num_formats++] = vc_image_formats[i].drm;
 625
 626         plane = &vc4_plane->base;
 627         ret = drm_universal_plane_init(dev, plane, 0xff,
 628                                        &vc4_plane_funcs,
 629                                        formats, num_formats, modifiers,
 630                                        type, NULL);
 631
 632         /* FIXME: Do we need to be checking return values from all these calls?
 633          */
 634         drm_plane_helper_add(plane, &vc4_plane_helper_funcs);
 635
 636         drm_plane_create_alpha_property(plane);
 637         drm_plane_create_rotation_property(plane, DRM_MODE_ROTATE_0,
 638                                            SUPPORTED_ROTATIONS);
 639
 640         /*
 641          * Default frame buffer setup is with FB on -127, and raspistill etc
 642          * tend to drop overlays on layer 2. Cursor plane was on layer +127.
 643          *
 644          * For F-KMS the mailbox call allows for a s8.
 645          * Remap zpos 0 to -127 for the background layer, but leave all the
 646          * other layers as requested by KMS.
 647          */
 648         switch (type) {
 649         case DRM_PLANE_TYPE_PRIMARY:
 650                 default_zpos = 0;
 651                 break;
 652         case DRM_PLANE_TYPE_OVERLAY:
 653                 default_zpos = 1;
 654                 break;
 655         case DRM_PLANE_TYPE_CURSOR:
 656                 default_zpos = 2;
 657                 break;
 658         }
 659         drm_plane_create_zpos_property(plane, default_zpos, 0, 127);
 660
 661         /* Prepare the static elements of the mailbox structure */
 662         vc4_plane->mb.tag.tag = RPI_FIRMWARE_SET_PLANE;
 663         vc4_plane->mb.tag.buf_size = sizeof(struct set_plane);
 664         vc4_plane->mb.tag.req_resp_size = 0;
 665         vc4_plane->mb.plane.display = display_num;
 666         vc4_plane->mb.plane.plane_id = plane_id;
 667         vc4_plane->mb.plane.layer = default_zpos ? default_zpos : -127;
 668
 669         return plane;
 670 fail:
 671         if (plane)
 672                 vc4_plane_destroy(plane);
 673
 674         return ERR_PTR(ret);
 675 }
 676
 677 static void vc4_crtc_mode_set_nofb(struct drm_crtc *crtc)
 678 {
 679         struct drm_device *dev = crtc->dev;
 680         struct vc4_dev *vc4 = to_vc4_dev(dev);
 681         struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
 682         struct drm_display_mode *mode = &crtc->state->adjusted_mode;
 683         struct vc4_fkms_encoder *vc4_encoder =
 684                                         to_vc4_fkms_encoder(vc4_crtc->encoder);
 685         struct mailbox_set_mode mb = {
 686                 .tag1 = { RPI_FIRMWARE_SET_TIMING,
 687                           sizeof(struct set_timings), 0},
 688         };
 689         union hdmi_infoframe frame;
 690         int ret;
 691
 692         ret = drm_hdmi_avi_infoframe_from_display_mode(&frame.avi, vc4_crtc->connector, mode);
 693         if (ret < 0) {
 694                 DRM_ERROR("couldn't fill AVI infoframe\n");
 695                 return;
 696         }
 697
 698         DRM_DEBUG_KMS("Setting mode for display num %u mode name %s, clk %d, h(disp %d, start %d, end %d, total %d, skew %d) v(disp %d, start %d, end %d, total %d, scan %d), vrefresh %d, par %u, flags 0x%04x\n",
 699                       vc4_crtc->display_number, mode->name, mode->clock,
 700                       mode->hdisplay, mode->hsync_start, mode->hsync_end,
 701                       mode->htotal, mode->hskew, mode->vdisplay,
 702                       mode->vsync_start, mode->vsync_end, mode->vtotal,
 703                       mode->vscan, mode->vrefresh, mode->picture_aspect_ratio,
 704                       mode->flags);
 705         mb.timings.display = vc4_crtc->display_number;
 706
 707         mb.timings.video_id_code = frame.avi.video_code;
 708
 709         mb.timings.clock = mode->clock;
 710         mb.timings.hdisplay = mode->hdisplay;
 711         mb.timings.hsync_start = mode->hsync_start;
 712         mb.timings.hsync_end = mode->hsync_end;
 713         mb.timings.htotal = mode->htotal;
 714         mb.timings.hskew = mode->hskew;
 715         mb.timings.vdisplay = mode->vdisplay;
 716         mb.timings.vsync_start = mode->vsync_start;
 717         mb.timings.vsync_end = mode->vsync_end;
 718         mb.timings.vtotal = mode->vtotal;
 719         mb.timings.vscan = mode->vscan;
 720         mb.timings.vrefresh = 0;
 721         mb.timings.flags = 0;
 722         if (mode->flags & DRM_MODE_FLAG_PHSYNC)
 723                 mb.timings.flags |= TIMINGS_FLAGS_H_SYNC_POS;
 724         if (mode->flags & DRM_MODE_FLAG_PVSYNC)
 725                 mb.timings.flags |= TIMINGS_FLAGS_V_SYNC_POS;
 726
 727         switch (frame.avi.picture_aspect) {
 728         default:
 729         case HDMI_PICTURE_ASPECT_NONE:
 730                 mb.timings.flags |= TIMINGS_FLAGS_ASPECT_NONE;
 731                 break;
 732         case HDMI_PICTURE_ASPECT_4_3:
 733                 mb.timings.flags |= TIMINGS_FLAGS_ASPECT_4_3;
 734                 break;
 735         case HDMI_PICTURE_ASPECT_16_9:
 736                 mb.timings.flags |= TIMINGS_FLAGS_ASPECT_16_9;
 737                 break;
 738         case HDMI_PICTURE_ASPECT_64_27:
 739                 mb.timings.flags |= TIMINGS_FLAGS_ASPECT_64_27;
 740                 break;
 741         case HDMI_PICTURE_ASPECT_256_135:
 742                 mb.timings.flags |= TIMINGS_FLAGS_ASPECT_256_135;
 743                 break;
 744         }
 745
 746         if (!vc4_encoder->hdmi_monitor)
 747                 mb.timings.flags |= TIMINGS_FLAGS_DVI;
 748         else if (drm_default_rgb_quant_range(mode) ==
 749                                         HDMI_QUANTIZATION_RANGE_LIMITED)
 750                 mb.timings.flags |= TIMINGS_FLAGS_RGB_LIMITED;
 751
 752         /*
 753         FIXME: To implement
 754         switch(mode->flag & DRM_MODE_FLAG_3D_MASK) {
 755         case DRM_MODE_FLAG_3D_NONE:
 756         case DRM_MODE_FLAG_3D_FRAME_PACKING:
 757         case DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE:
 758         case DRM_MODE_FLAG_3D_LINE_ALTERNATIVE:
 759         case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL:
 760         case DRM_MODE_FLAG_3D_L_DEPTH:
 761         case DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH:
 762         case DRM_MODE_FLAG_3D_TOP_AND_BOTTOM:
 763         case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF:
 764         }
 765         */
 766
 767         ret = rpi_firmware_property_list(vc4->firmware, &mb, sizeof(mb));
 768 }
 769
 770 static void vc4_crtc_disable(struct drm_crtc *crtc, struct drm_crtc_state *old_state)
 771 {
 772         struct drm_plane *plane;
 773
 774         DRM_DEBUG_KMS("[CRTC:%d] vblanks off.\n",
 775                       crtc->base.id);
 776         drm_crtc_vblank_off(crtc);
 777
 778         /* Always turn the planes off on CRTC disable. In DRM, planes
 779          * are enabled/disabled through the update/disable hooks
 780          * above, and the CRTC enable/disable independently controls
 781          * whether anything scans out at all, but the firmware doesn't
 782          * give us a CRTC-level control for that.
 783          */
 784
 785         drm_atomic_crtc_for_each_plane(plane, crtc)
 786                 vc4_plane_atomic_disable(plane, plane->state);
 787 }
 788
 789 static void vc4_crtc_enable(struct drm_crtc *crtc, struct drm_crtc_state *old_state)
 790 {
 791         struct drm_plane *plane;
 792
 793         DRM_DEBUG_KMS("[CRTC:%d] vblanks on.\n",
 794                       crtc->base.id);
 795         drm_crtc_vblank_on(crtc);
 796
 797         /* Unblank the planes (if they're supposed to be displayed). */
 798         drm_atomic_crtc_for_each_plane(plane, crtc)
 799                 if (plane->state->fb)
 800                         vc4_plane_set_blank(plane, plane->state->visible);
 801 }
 802
 803 static enum drm_mode_status
 804 vc4_crtc_mode_valid(struct drm_crtc *crtc, const struct drm_display_mode *mode)
 805 {
 806         struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
 807         struct drm_device *dev = crtc->dev;
 808         struct vc4_dev *vc4 = to_vc4_dev(dev);
 809         struct vc4_fkms *fkms = vc4->fkms;
 810
 811         /* Do not allow doublescan modes from user space */
 812         if (mode->flags & DRM_MODE_FLAG_DBLSCAN) {
 813                 DRM_DEBUG_KMS("[CRTC:%d] Doublescan mode rejected.\n",
 814                               crtc->base.id);
 815                 return MODE_NO_DBLESCAN;
 816         }
 817
 818         /* Limit the pixel clock based on the HDMI clock limits from the
 819          * firmware
 820          */
 821         switch (vc4_crtc->display_number) {
 822         case 2: /* HDMI0 */
 823                 if (fkms->cfg.max_pixel_clock[0] &&
 824                     mode->clock > fkms->cfg.max_pixel_clock[0])
 825                         return MODE_CLOCK_HIGH;
 826                 break;
 827         case 7: /* HDMI1 */
 828                 if (fkms->cfg.max_pixel_clock[1] &&
 829                     mode->clock > fkms->cfg.max_pixel_clock[1])
 830                         return MODE_CLOCK_HIGH;
 831                 break;
 832         }
 833
 834         /* Limit the pixel clock until we can get dynamic HDMI 2.0 scrambling
 835          * working.
 836          */
 837         if (mode->clock > 340000)
 838                 return MODE_CLOCK_HIGH;
 839
 840         return MODE_OK;
 841 }
 842
 843 static int vc4_crtc_atomic_check(struct drm_crtc *crtc,
 844                                  struct drm_crtc_state *state)
 845 {
 846         DRM_DEBUG_KMS("[CRTC:%d] crtc_atomic_check.\n",
 847                       crtc->base.id);
 848         return 0;
 849 }
 850
 851 static void vc4_crtc_atomic_flush(struct drm_crtc *crtc,
 852                                   struct drm_crtc_state *old_state)
 853 {
 854         struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
 855         struct drm_device *dev = crtc->dev;
 856
 857         DRM_DEBUG_KMS("[CRTC:%d] crtc_atomic_flush.\n",
 858                       crtc->base.id);
 859         if (crtc->state->event) {
 860                 unsigned long flags;
 861
 862                 crtc->state->event->pipe = drm_crtc_index(crtc);
 863
 864                 WARN_ON(drm_crtc_vblank_get(crtc) != 0);
 865
 866                 spin_lock_irqsave(&dev->event_lock, flags);
 867                 vc4_crtc->event = crtc->state->event;
 868                 crtc->state->event = NULL;
 869                 spin_unlock_irqrestore(&dev->event_lock, flags);
 870         }
 871 }
 872
 873 static void vc4_crtc_handle_page_flip(struct vc4_crtc *vc4_crtc)
 874 {
 875         struct drm_crtc *crtc = &vc4_crtc->base;
 876         struct drm_device *dev = crtc->dev;
 877         unsigned long flags;
 878
 879         spin_lock_irqsave(&dev->event_lock, flags);
 880         if (vc4_crtc->event) {
 881                 drm_crtc_send_vblank_event(crtc, vc4_crtc->event);
 882                 vc4_crtc->event = NULL;
 883                 drm_crtc_vblank_put(crtc);
 884         }
 885         spin_unlock_irqrestore(&dev->event_lock, flags);
 886 }
 887
 888 static irqreturn_t vc4_crtc_irq_handler(int irq, void *data)
 889 {
 890         struct vc4_crtc **crtc_list = data;
 891         int i;
 892         u32 stat = readl(crtc_list[0]->regs + SMICS);
 893         irqreturn_t ret = IRQ_NONE;
 894
 895         if (stat & SMICS_INTERRUPTS) {
 896                 writel(0, crtc_list[0]->regs + SMICS);
 897
 898                 for (i = 0; crtc_list[i]; i++) {
 899                         if (crtc_list[i]->vblank_enabled)
 900                                 drm_crtc_handle_vblank(&crtc_list[i]->base);
 901                         vc4_crtc_handle_page_flip(crtc_list[i]);
 902                         ret = IRQ_HANDLED;
 903                 }
 904         }
 905
 906         return ret;
 907 }
 908
 909 static int vc4_page_flip(struct drm_crtc *crtc,
 910                          struct drm_framebuffer *fb,
 911                          struct drm_pending_vblank_event *event,
 912                          uint32_t flags, struct drm_modeset_acquire_ctx *ctx)
 913 {
 914         if (flags & DRM_MODE_PAGE_FLIP_ASYNC) {
 915                 DRM_ERROR("Async flips aren't allowed\n");
 916                 return -EINVAL;
 917         }
 918
 919         return drm_atomic_helper_page_flip(crtc, fb, event, flags, ctx);
 920 }
 921
 922 static int vc4_fkms_enable_vblank(struct drm_crtc *crtc)
 923 {
 924         struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
 925
 926         DRM_DEBUG_KMS("[CRTC:%d] enable_vblank.\n",
 927                       crtc->base.id);
 928         vc4_crtc->vblank_enabled = true;
 929
 930         return 0;
 931 }
 932
 933 static void vc4_fkms_disable_vblank(struct drm_crtc *crtc)
 934 {
 935         struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
 936
 937         DRM_DEBUG_KMS("[CRTC:%d] disable_vblank.\n",
 938                       crtc->base.id);
 939         vc4_crtc->vblank_enabled = false;
 940 }
 941
 942 static const struct drm_crtc_funcs vc4_crtc_funcs = {
 943         .set_config = drm_atomic_helper_set_config,
 944         .destroy = drm_crtc_cleanup,
 945         .page_flip = vc4_page_flip,
 946         .set_property = NULL,
 947         .cursor_set = NULL, /* handled by drm_mode_cursor_universal */
 948         .cursor_move = NULL, /* handled by drm_mode_cursor_universal */
 949         .reset = drm_atomic_helper_crtc_reset,
 950         .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
 951         .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
 952         .enable_vblank = vc4_fkms_enable_vblank,
 953         .disable_vblank = vc4_fkms_disable_vblank,
 954 };
 955
 956 static const struct drm_crtc_helper_funcs vc4_crtc_helper_funcs = {
 957         .mode_set_nofb = vc4_crtc_mode_set_nofb,
 958         .mode_valid = vc4_crtc_mode_valid,
 959         .atomic_check = vc4_crtc_atomic_check,
 960         .atomic_flush = vc4_crtc_atomic_flush,
 961         .atomic_enable = vc4_crtc_enable,
 962         .atomic_disable = vc4_crtc_disable,
 963 };
 964
 965 static const struct of_device_id vc4_firmware_kms_dt_match[] = {
 966         { .compatible = "raspberrypi,rpi-firmware-kms" },
 967         {}
 968 };
 969
 970 static enum drm_connector_status
 971 vc4_fkms_connector_detect(struct drm_connector *connector, bool force)
 972 {
 973         DRM_DEBUG_KMS("connector detect.\n");
 974         return connector_status_connected;
 975 }
 976
 977 static int vc4_fkms_get_edid_block(void *data, u8 *buf, unsigned int block,
 978                                    size_t len)
 979 {
 980         struct vc4_fkms_connector *fkms_connector =
 981                                         (struct vc4_fkms_connector *)data;
 982         struct vc4_dev *vc4 = fkms_connector->vc4_dev;
 983         struct mailbox_get_edid mb = {
 984                 .tag1 = { RPI_FIRMWARE_GET_EDID_BLOCK_DISPLAY,
 985                           128 + 8, 0 },
 986                 .block = block,
 987                 .display_number = fkms_connector->display_number,
 988         };
 989         int ret = 0;
 990
 991         ret = rpi_firmware_property_list(vc4->firmware, &mb, sizeof(mb));
 992
 993         if (!ret)
 994                 memcpy(buf, mb.edid, len);
 995
 996         return ret;
 997 }
 998
 999 static int vc4_fkms_connector_get_modes(struct drm_connector *connector)
1000 {
1001         struct vc4_fkms_connector *fkms_connector =
1002                                         to_vc4_fkms_connector(connector);
1003         struct drm_encoder *encoder = fkms_connector->encoder;
1004         struct vc4_fkms_encoder *vc4_encoder = to_vc4_fkms_encoder(encoder);
1005         int ret = 0;
1006         struct edid *edid;
1007
1008         edid = drm_do_get_edid(connector, vc4_fkms_get_edid_block,
1009                                fkms_connector);
1010
1011         /* FIXME: Can we do CEC?
1012          * cec_s_phys_addr_from_edid(vc4->hdmi->cec_adap, edid);
1013          * if (!edid)
1014          *      return -ENODEV;
1015          */
1016
1017         vc4_encoder->hdmi_monitor = drm_detect_hdmi_monitor(edid);
1018
1019         drm_connector_update_edid_property(connector, edid);
1020         ret = drm_add_edid_modes(connector, edid);
1021         kfree(edid);
1022
1023         return ret;
1024 }
1025
1026 /* This is the DSI panel resolution. Use this as a default should the firmware
1027  * not respond to our request for the timings.
1028  */
1029 static const struct drm_display_mode lcd_mode = {
1030         DRM_MODE("800x480", DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
1031                  25979400 / 1000,
1032                  800, 800 + 1, 800 + 1 + 2, 800 + 1 + 2 + 46, 0,
1033                  480, 480 + 7, 480 + 7 + 2, 480 + 7 + 2 + 21, 0,
1034                  0)
1035 };
1036
1037 static int vc4_fkms_lcd_connector_get_modes(struct drm_connector *connector)
1038 {
1039         struct vc4_fkms_connector *fkms_connector =
1040                                         to_vc4_fkms_connector(connector);
1041         struct vc4_dev *vc4 = fkms_connector->vc4_dev;
1042         struct drm_display_mode *mode;
1043         struct mailbox_set_mode mb = {
1044                 .tag1 = { RPI_FIRMWARE_GET_DISPLAY_TIMING,
1045                           sizeof(struct set_timings), 0},
1046                 .timings = { .display = fkms_connector->display_number },
1047         };
1048         struct drm_display_mode fw_mode;
1049         int ret = 0;
1050
1051         ret = rpi_firmware_property_list(vc4->firmware, &mb, sizeof(mb));
1052         if (!ret) {
1053                 /* Equivalent to DRM_MODE macro. */
1054                 memset(&fw_mode, 0, sizeof(fw_mode));
1055                 strncpy(fw_mode.name, "LCD_MODE", sizeof(fw_mode.name));
1056                 fw_mode.status = 0;
1057                 fw_mode.type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
1058                 fw_mode.clock = mb.timings.clock;
1059                 fw_mode.hdisplay = mb.timings.hdisplay;
1060                 fw_mode.hsync_start = mb.timings.hsync_start;
1061                 fw_mode.hsync_end = mb.timings.hsync_end;
1062                 fw_mode.htotal = mb.timings.htotal;
1063                 fw_mode.hskew = 0;
1064                 fw_mode.vdisplay = mb.timings.vdisplay;
1065                 fw_mode.vsync_start = mb.timings.vsync_start;
1066                 fw_mode.vsync_end = mb.timings.vsync_end;
1067                 fw_mode.vtotal = mb.timings.vtotal;
1068                 fw_mode.vscan = mb.timings.vscan;
1069                 if (mb.timings.flags & TIMINGS_FLAGS_H_SYNC_POS)
1070                         fw_mode.flags |= DRM_MODE_FLAG_PHSYNC;
1071                 else
1072                         fw_mode.flags |= DRM_MODE_FLAG_NHSYNC;
1073                 if (mb.timings.flags & TIMINGS_FLAGS_V_SYNC_POS)
1074                         fw_mode.flags |= DRM_MODE_FLAG_PVSYNC;
1075                 else
1076                         fw_mode.flags |= DRM_MODE_FLAG_NVSYNC;
1077                 if (mb.timings.flags & TIMINGS_FLAGS_V_SYNC_POS)
1078                         fw_mode.flags |= DRM_MODE_FLAG_PVSYNC;
1079                 else
1080                         fw_mode.flags |= DRM_MODE_FLAG_NVSYNC;
1081                 if (mb.timings.flags & TIMINGS_FLAGS_INTERLACE)
1082                         fw_mode.flags |= DRM_MODE_FLAG_INTERLACE;
1083
1084                 mode = drm_mode_duplicate(connector->dev,
1085                                           &fw_mode);
1086         } else {
1087                 mode = drm_mode_duplicate(connector->dev,
1088                                           &lcd_mode);
1089         }
1090
1091         if (!mode) {
1092                 DRM_ERROR("Failed to create a new display mode\n");
1093                 return -ENOMEM;
1094         }
1095
1096         drm_mode_probed_add(connector, mode);
1097
1098         /* We have one mode */
1099         return 1;
1100 }
1101
1102 static struct drm_encoder *
1103 vc4_fkms_connector_best_encoder(struct drm_connector *connector)
1104 {
1105         struct vc4_fkms_connector *fkms_connector =
1106                 to_vc4_fkms_connector(connector);
1107         DRM_DEBUG_KMS("best_connector.\n");
1108         return fkms_connector->encoder;
1109 }
1110
1111 static void vc4_fkms_connector_destroy(struct drm_connector *connector)
1112 {
1113         DRM_DEBUG_KMS("[CONNECTOR:%d] destroy.\n",
1114                       connector->base.id);
1115         drm_connector_unregister(connector);
1116         drm_connector_cleanup(connector);
1117 }
1118
1119 static const struct drm_connector_funcs vc4_fkms_connector_funcs = {
1120         .detect = vc4_fkms_connector_detect,
1121         .fill_modes = drm_helper_probe_single_connector_modes,
1122         .destroy = vc4_fkms_connector_destroy,
1123         .reset = drm_atomic_helper_connector_reset,
1124         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1125         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1126 };
1127
1128 static const struct drm_connector_helper_funcs vc4_fkms_connector_helper_funcs = {
1129         .get_modes = vc4_fkms_connector_get_modes,
1130         .best_encoder = vc4_fkms_connector_best_encoder,
1131 };
1132
1133 static const struct drm_connector_helper_funcs vc4_fkms_lcd_conn_helper_funcs = {
1134         .get_modes = vc4_fkms_lcd_connector_get_modes,
1135         .best_encoder = vc4_fkms_connector_best_encoder,
1136 };
1137
1138 static struct drm_connector *
1139 vc4_fkms_connector_init(struct drm_device *dev, struct drm_encoder *encoder,
1140                         u32 display_num)
1141 {
1142         struct drm_connector *connector = NULL;
1143         struct vc4_fkms_connector *fkms_connector;
1144         struct vc4_dev *vc4_dev = to_vc4_dev(dev);
1145         int ret = 0;
1146
1147         DRM_DEBUG_KMS("connector_init, display_num %u\n", display_num);
1148
1149         fkms_connector = devm_kzalloc(dev->dev, sizeof(*fkms_connector),
1150                                       GFP_KERNEL);
1151         if (!fkms_connector) {
1152                 ret = -ENOMEM;
1153                 goto fail;
1154         }
1155         connector = &fkms_connector->base;
1156
1157         fkms_connector->encoder = encoder;
1158         fkms_connector->display_number = display_num;
1159         fkms_connector->display_type = vc4_get_display_type(display_num);
1160         fkms_connector->vc4_dev = vc4_dev;
1161
1162         if (fkms_connector->display_type == DRM_MODE_ENCODER_DSI) {
1163                 drm_connector_init(dev, connector, &vc4_fkms_connector_funcs,
1164                                    DRM_MODE_CONNECTOR_DSI);
1165                 drm_connector_helper_add(connector,
1166                                          &vc4_fkms_lcd_conn_helper_funcs);
1167                 connector->interlace_allowed = 0;
1168         } else if (fkms_connector->display_type == DRM_MODE_ENCODER_TVDAC) {
1169                 drm_connector_init(dev, connector, &vc4_fkms_connector_funcs,
1170                                    DRM_MODE_CONNECTOR_Composite);
1171                 drm_connector_helper_add(connector,
1172                                          &vc4_fkms_lcd_conn_helper_funcs);
1173                 connector->interlace_allowed = 1;
1174         } else {
1175                 drm_connector_init(dev, connector, &vc4_fkms_connector_funcs,
1176                                    DRM_MODE_CONNECTOR_HDMIA);
1177                 drm_connector_helper_add(connector,
1178                                          &vc4_fkms_connector_helper_funcs);
1179                 connector->interlace_allowed = 0;
1180         }
1181
1182         connector->polled = (DRM_CONNECTOR_POLL_CONNECT |
1183                              DRM_CONNECTOR_POLL_DISCONNECT);
1184
1185         connector->doublescan_allowed = 0;
1186
1187         drm_connector_attach_encoder(connector, encoder);
1188
1189         return connector;
1190
1191  fail:
1192         if (connector)
1193                 vc4_fkms_connector_destroy(connector);
1194
1195         return ERR_PTR(ret);
1196 }
1197
1198 static void vc4_fkms_encoder_destroy(struct drm_encoder *encoder)
1199 {
1200         DRM_DEBUG_KMS("Encoder_destroy\n");
1201         drm_encoder_cleanup(encoder);
1202 }
1203
1204 static const struct drm_encoder_funcs vc4_fkms_encoder_funcs = {
1205         .destroy = vc4_fkms_encoder_destroy,
1206 };
1207
1208 static void vc4_fkms_encoder_enable(struct drm_encoder *encoder)
1209 {
1210         DRM_DEBUG_KMS("Encoder_enable\n");
1211 }
1212
1213 static void vc4_fkms_encoder_disable(struct drm_encoder *encoder)
1214 {
1215         DRM_DEBUG_KMS("Encoder_disable\n");
1216 }
1217
1218 static const struct drm_encoder_helper_funcs vc4_fkms_encoder_helper_funcs = {
1219         .enable = vc4_fkms_encoder_enable,
1220         .disable = vc4_fkms_encoder_disable,
1221 };
1222
1223 static int vc4_fkms_create_screen(struct device *dev, struct drm_device *drm,
1224                                   int display_idx, int display_ref,
1225                                   struct vc4_crtc **ret_crtc)
1226 {
1227         struct vc4_dev *vc4 = to_vc4_dev(drm);
1228         struct vc4_crtc *vc4_crtc;
1229         struct vc4_fkms_encoder *vc4_encoder;
1230         struct drm_crtc *crtc;
1231         struct drm_plane *primary_plane, *overlay_plane, *cursor_plane;
1232         struct drm_plane *destroy_plane, *temp;
1233         struct mailbox_blank_display blank = {
1234                 .tag1 = {RPI_FIRMWARE_FRAMEBUFFER_SET_DISPLAY_NUM, 4, 0, },
1235                 .display = display_idx,
1236                 .tag2 = { RPI_FIRMWARE_FRAMEBUFFER_BLANK, 4, 0, },
1237                 .blank = 1,
1238         };
1239         int ret;
1240
1241         vc4_crtc = devm_kzalloc(dev, sizeof(*vc4_crtc), GFP_KERNEL);
1242         if (!vc4_crtc)
1243                 return -ENOMEM;
1244         crtc = &vc4_crtc->base;
1245
1246         vc4_crtc->display_number = display_ref;
1247         vc4_crtc->display_type = vc4_get_display_type(display_ref);
1248
1249         /* Blank the firmware provided framebuffer */
1250         rpi_firmware_property_list(vc4->firmware, &blank, sizeof(blank));
1251
1252         primary_plane = vc4_fkms_plane_init(drm, DRM_PLANE_TYPE_PRIMARY,
1253                                             display_ref,
1254                                             0 + (display_idx * PLANES_PER_CRTC)
1255                                            );
1256         if (IS_ERR(primary_plane)) {
1257                 dev_err(dev, "failed to construct primary plane\n");
1258                 ret = PTR_ERR(primary_plane);
1259                 goto err;
1260         }
1261
1262         overlay_plane = vc4_fkms_plane_init(drm, DRM_PLANE_TYPE_OVERLAY,
1263                                             display_ref,
1264                                             1 + (display_idx * PLANES_PER_CRTC)
1265                                            );
1266         if (IS_ERR(overlay_plane)) {
1267                 dev_err(dev, "failed to construct overlay plane\n");
1268                 ret = PTR_ERR(overlay_plane);
1269                 goto err;
1270         }
1271
1272         cursor_plane = vc4_fkms_plane_init(drm, DRM_PLANE_TYPE_CURSOR,
1273                                            display_ref,
1274                                            2 + (display_idx * PLANES_PER_CRTC)
1275                                           );
1276         if (IS_ERR(cursor_plane)) {
1277                 dev_err(dev, "failed to construct cursor plane\n");
1278                 ret = PTR_ERR(cursor_plane);
1279                 goto err;
1280         }
1281
1282         drm_crtc_init_with_planes(drm, crtc, primary_plane, cursor_plane,
1283                                   &vc4_crtc_funcs, NULL);
1284         drm_crtc_helper_add(crtc, &vc4_crtc_helper_funcs);
1285
1286         vc4_encoder = devm_kzalloc(dev, sizeof(*vc4_encoder), GFP_KERNEL);
1287         if (!vc4_encoder)
1288                 return -ENOMEM;
1289         vc4_crtc->encoder = &vc4_encoder->base;
1290         vc4_encoder->base.possible_crtcs |= drm_crtc_mask(crtc) ;
1291
1292         drm_encoder_init(drm, &vc4_encoder->base, &vc4_fkms_encoder_funcs,
1293                          vc4_crtc->display_type, NULL);
1294         drm_encoder_helper_add(&vc4_encoder->base,
1295                                &vc4_fkms_encoder_helper_funcs);
1296
1297         vc4_crtc->connector = vc4_fkms_connector_init(drm, &vc4_encoder->base,
1298                                                       display_ref);
1299         if (IS_ERR(vc4_crtc->connector)) {
1300                 ret = PTR_ERR(vc4_crtc->connector);
1301                 goto err_destroy_encoder;
1302         }
1303
1304         *ret_crtc = vc4_crtc;
1305
1306         return 0;
1307
1308 err_destroy_encoder:
1309         vc4_fkms_encoder_destroy(vc4_crtc->encoder);
1310         list_for_each_entry_safe(destroy_plane, temp,
1311                                  &drm->mode_config.plane_list, head) {
1312                 if (destroy_plane->possible_crtcs == 1 << drm_crtc_index(crtc))
1313                     destroy_plane->funcs->destroy(destroy_plane);
1314         }
1315 err:
1316         return ret;
1317 }
1318
1319 static int vc4_fkms_bind(struct device *dev, struct device *master, void *data)
1320 {
1321         struct platform_device *pdev = to_platform_device(dev);
1322         struct drm_device *drm = dev_get_drvdata(master);
1323         struct vc4_dev *vc4 = to_vc4_dev(drm);
1324         struct device_node *firmware_node;
1325         struct vc4_crtc **crtc_list;
1326         u32 num_displays, display_num;
1327         struct vc4_fkms *fkms;
1328         int ret;
1329         u32 display_id;
1330
1331         vc4->firmware_kms = true;
1332
1333         fkms = devm_kzalloc(dev, sizeof(*fkms), GFP_KERNEL);
1334         if (!fkms)
1335                 return -ENOMEM;
1336
1337         /* firmware kms doesn't have precise a scanoutpos implementation, so
1338          * we can't do the precise vblank timestamp mode.
1339          */
1340         drm->driver->get_scanout_position = NULL;
1341         drm->driver->get_vblank_timestamp = NULL;
1342
1343         firmware_node = of_parse_phandle(dev->of_node, "brcm,firmware", 0);
1344         vc4->firmware = rpi_firmware_get(firmware_node);
1345         if (!vc4->firmware) {
1346                 DRM_DEBUG("Failed to get Raspberry Pi firmware reference.\n");
1347                 return -EPROBE_DEFER;
1348         }
1349         of_node_put(firmware_node);
1350
1351         ret = rpi_firmware_property(vc4->firmware,
1352                                     RPI_FIRMWARE_FRAMEBUFFER_GET_NUM_DISPLAYS,
1353                                     &num_displays, sizeof(u32));
1354
1355         /* If we fail to get the number of displays, then
1356          * assume old firmware that doesn't have the mailbox call, so just
1357          * set one display
1358          */
1359         if (ret) {
1360                 num_displays = 1;
1361                 DRM_WARN("Unable to determine number of displays - assuming 1\n");
1362                 ret = 0;
1363         }
1364
1365         ret = rpi_firmware_property(vc4->firmware,
1366                                     RPI_FIRMWARE_GET_DISPLAY_CFG,
1367                                     &fkms->cfg, sizeof(fkms->cfg));
1368
1369         if (ret)
1370                 return -EINVAL;
1371         /* The firmware works in Hz. This will be compared against kHz, so div
1372          * 1000 now rather than multiple times later.
1373          */
1374         fkms->cfg.max_pixel_clock[0] /= 1000;
1375         fkms->cfg.max_pixel_clock[1] /= 1000;
1376
1377         /* Allocate a list, with space for a NULL on the end */
1378         crtc_list = devm_kzalloc(dev, sizeof(crtc_list) * (num_displays + 1),
1379                                  GFP_KERNEL);
1380         if (!crtc_list)
1381                 return -ENOMEM;
1382
1383         for (display_num = 0; display_num < num_displays; display_num++) {
1384                 display_id = display_num;
1385                 ret = rpi_firmware_property(vc4->firmware,
1386                                             RPI_FIRMWARE_FRAMEBUFFER_GET_DISPLAY_ID,
1387                                             &display_id, sizeof(display_id));
1388                 /* FIXME: Determine the correct error handling here.
1389                  * Should we fail to create the one "screen" but keep the
1390                  * others, or fail the whole thing?
1391                  */
1392                 if (ret)
1393                         DRM_ERROR("Failed to get display id %u\n", display_num);
1394
1395                 ret = vc4_fkms_create_screen(dev, drm, display_num, display_id,
1396                                              &crtc_list[display_num]);
1397                 if (ret)
1398                         DRM_ERROR("Oh dear, failed to create display %u\n",
1399                                   display_num);
1400         }
1401
1402         if (num_displays > 0) {
1403                 /* Map the SMI interrupt reg */
1404                 crtc_list[0]->regs = vc4_ioremap_regs(pdev, 0);
1405                 if (IS_ERR(crtc_list[0]->regs))
1406                         DRM_ERROR("Oh dear, failed to map registers\n");
1407
1408                 writel(0, crtc_list[0]->regs + SMICS);
1409                 ret = devm_request_irq(dev, platform_get_irq(pdev, 0),
1410                                        vc4_crtc_irq_handler, 0,
1411                                        "vc4 firmware kms", crtc_list);
1412                 if (ret)
1413                         DRM_ERROR("Oh dear, failed to register IRQ\n");
1414         } else {
1415                 DRM_WARN("No displays found. Consider forcing hotplug if HDMI is attached\n");
1416         }
1417
1418         vc4->fkms = fkms;
1419
1420         platform_set_drvdata(pdev, crtc_list);
1421
1422         return 0;
1423 }
1424
1425 static void vc4_fkms_unbind(struct device *dev, struct device *master,
1426                             void *data)
1427 {
1428         struct platform_device *pdev = to_platform_device(dev);
1429         struct vc4_crtc **crtc_list = dev_get_drvdata(dev);
1430         int i;
1431
1432         for (i = 0; crtc_list[i]; i++) {
1433                 vc4_fkms_connector_destroy(crtc_list[i]->connector);
1434                 vc4_fkms_encoder_destroy(crtc_list[i]->encoder);
1435                 drm_crtc_cleanup(&crtc_list[i]->base);
1436         }
1437
1438         platform_set_drvdata(pdev, NULL);
1439 }
1440
1441 static const struct component_ops vc4_fkms_ops = {
1442         .bind   = vc4_fkms_bind,
1443         .unbind = vc4_fkms_unbind,
1444 };
1445
1446 static int vc4_fkms_probe(struct platform_device *pdev)
1447 {
1448         return component_add(&pdev->dev, &vc4_fkms_ops);
1449 }
1450
1451 static int vc4_fkms_remove(struct platform_device *pdev)
1452 {
1453         component_del(&pdev->dev, &vc4_fkms_ops);
1454         return 0;
1455 }
1456
1457 struct platform_driver vc4_firmware_kms_driver = {
1458         .probe = vc4_fkms_probe,
1459         .remove = vc4_fkms_remove,
1460         .driver = {
1461                 .name = "vc4_firmware_kms",
1462                 .of_match_table = vc4_firmware_kms_dt_match,
1463         },
1464 };