drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c

   1 /*
   2  * Copyright (c) 2014, The Linux Foundation. All rights reserved.
   3  * Copyright (C) 2013 Red Hat
   4  * Author: Rob Clark <robdclark@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <linux/of_irq.h>
  20
  21 #include "msm_drv.h"
  22 #include "msm_gem.h"
  23 #include "msm_mmu.h"
  24 #include "mdp5_kms.h"
  25
  26 static const char *iommu_ports[] = {
  27                 "mdp_0",
  28 };
  29
  30 static int mdp5_hw_init(struct msm_kms *kms)
  31 {
  32         struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
  33         struct platform_device *pdev = mdp5_kms->pdev;
  34         unsigned long flags;
  35
  36         pm_runtime_get_sync(&pdev->dev);
  37         mdp5_enable(mdp5_kms);
  38
  39         /* Magic unknown register writes:
  40          *
  41          *    W VBIF:0x004 00000001      (mdss_mdp.c:839)
  42          *    W MDP5:0x2e0 0xe9          (mdss_mdp.c:839)
  43          *    W MDP5:0x2e4 0x55          (mdss_mdp.c:839)
  44          *    W MDP5:0x3ac 0xc0000ccc    (mdss_mdp.c:839)
  45          *    W MDP5:0x3b4 0xc0000ccc    (mdss_mdp.c:839)
  46          *    W MDP5:0x3bc 0xcccccc      (mdss_mdp.c:839)
  47          *    W MDP5:0x4a8 0xcccc0c0     (mdss_mdp.c:839)
  48          *    W MDP5:0x4b0 0xccccc0c0    (mdss_mdp.c:839)
  49          *    W MDP5:0x4b8 0xccccc000    (mdss_mdp.c:839)
  50          *
  51          * Downstream fbdev driver gets these register offsets/values
  52          * from DT.. not really sure what these registers are or if
  53          * different values for different boards/SoC's, etc.  I guess
  54          * they are the golden registers.
  55          *
  56          * Not setting these does not seem to cause any problem.  But
  57          * we may be getting lucky with the bootloader initializing
  58          * them for us.  OTOH, if we can always count on the bootloader
  59          * setting the golden registers, then perhaps we don't need to
  60          * care.
  61          */
  62
  63         spin_lock_irqsave(&mdp5_kms->resource_lock, flags);
  64         mdp5_write(mdp5_kms, REG_MDP5_DISP_INTF_SEL, 0);
  65         spin_unlock_irqrestore(&mdp5_kms->resource_lock, flags);
  66
  67         mdp5_ctlm_hw_reset(mdp5_kms->ctlm);
  68
  69         mdp5_disable(mdp5_kms);
  70         pm_runtime_put_sync(&pdev->dev);
  71
  72         return 0;
  73 }
  74
  75 struct mdp5_state *mdp5_get_state(struct drm_atomic_state *s)
  76 {
  77         struct msm_drm_private *priv = s->dev->dev_private;
  78         struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms));
  79         struct msm_kms_state *state = to_kms_state(s);
  80         struct mdp5_state *new_state;
  81         int ret;
  82
  83         if (state->state)
  84                 return state->state;
  85
  86         ret = drm_modeset_lock(&mdp5_kms->state_lock, s->acquire_ctx);
  87         if (ret)
  88                 return ERR_PTR(ret);
  89
  90         new_state = kmalloc(sizeof(*mdp5_kms->state), GFP_KERNEL);
  91         if (!new_state)
  92                 return ERR_PTR(-ENOMEM);
  93
  94         /* Copy state: */
  95         new_state->hwpipe = mdp5_kms->state->hwpipe;
  96         if (mdp5_kms->smp)
  97                 new_state->smp = mdp5_kms->state->smp;
  98
  99         state->state = new_state;
 100
 101         return new_state;
 102 }
 103
 104 static void mdp5_swap_state(struct msm_kms *kms, struct drm_atomic_state *state)
 105 {
 106         struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
 107         swap(to_kms_state(state)->state, mdp5_kms->state);
 108 }
 109
 110 static void mdp5_prepare_commit(struct msm_kms *kms, struct drm_atomic_state *state)
 111 {
 112         struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
 113
 114         mdp5_enable(mdp5_kms);
 115
 116         if (mdp5_kms->smp)
 117                 mdp5_smp_prepare_commit(mdp5_kms->smp, &mdp5_kms->state->smp);
 118 }
 119
 120 static void mdp5_complete_commit(struct msm_kms *kms, struct drm_atomic_state *state)
 121 {
 122         int i;
 123         struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
 124         struct drm_plane *plane;
 125         struct drm_plane_state *plane_state;
 126
 127         for_each_plane_in_state(state, plane, plane_state, i)
 128                 mdp5_plane_complete_commit(plane, plane_state);
 129
 130         if (mdp5_kms->smp)
 131                 mdp5_smp_complete_commit(mdp5_kms->smp, &mdp5_kms->state->smp);
 132
 133         mdp5_disable(mdp5_kms);
 134 }
 135
 136 static void mdp5_wait_for_crtc_commit_done(struct msm_kms *kms,
 137                                                 struct drm_crtc *crtc)
 138 {
 139         mdp5_crtc_wait_for_commit_done(crtc);
 140 }
 141
 142 static long mdp5_round_pixclk(struct msm_kms *kms, unsigned long rate,
 143                 struct drm_encoder *encoder)
 144 {
 145         return rate;
 146 }
 147
 148 static int mdp5_set_split_display(struct msm_kms *kms,
 149                 struct drm_encoder *encoder,
 150                 struct drm_encoder *slave_encoder,
 151                 bool is_cmd_mode)
 152 {
 153         if (is_cmd_mode)
 154                 return mdp5_cmd_encoder_set_split_display(encoder,
 155                                                         slave_encoder);
 156         else
 157                 return mdp5_encoder_set_split_display(encoder, slave_encoder);
 158 }
 159
 160 static void mdp5_kms_destroy(struct msm_kms *kms)
 161 {
 162         struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
 163         struct msm_gem_address_space *aspace = mdp5_kms->aspace;
 164         int i;
 165
 166         for (i = 0; i < mdp5_kms->num_hwpipes; i++)
 167                 mdp5_pipe_destroy(mdp5_kms->hwpipes[i]);
 168
 169         if (aspace) {
 170                 aspace->mmu->funcs->detach(aspace->mmu,
 171                                 iommu_ports, ARRAY_SIZE(iommu_ports));
 172                 msm_gem_address_space_destroy(aspace);
 173         }
 174 }
 175
 176 #ifdef CONFIG_DEBUG_FS
 177 static int smp_show(struct seq_file *m, void *arg)
 178 {
 179         struct drm_info_node *node = (struct drm_info_node *) m->private;
 180         struct drm_device *dev = node->minor->dev;
 181         struct msm_drm_private *priv = dev->dev_private;
 182         struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms));
 183         struct drm_printer p = drm_seq_file_printer(m);
 184
 185         if (!mdp5_kms->smp) {
 186                 drm_printf(&p, "no SMP pool\n");
 187                 return 0;
 188         }
 189
 190         mdp5_smp_dump(mdp5_kms->smp, &p);
 191
 192         return 0;
 193 }
 194
 195 static struct drm_info_list mdp5_debugfs_list[] = {
 196                 {"smp", smp_show },
 197 };
 198
 199 static int mdp5_kms_debugfs_init(struct msm_kms *kms, struct drm_minor *minor)
 200 {
 201         struct drm_device *dev = minor->dev;
 202         int ret;
 203
 204         ret = drm_debugfs_create_files(mdp5_debugfs_list,
 205                         ARRAY_SIZE(mdp5_debugfs_list),
 206                         minor->debugfs_root, minor);
 207
 208         if (ret) {
 209                 dev_err(dev->dev, "could not install mdp5_debugfs_list\n");
 210                 return ret;
 211         }
 212
 213         return 0;
 214 }
 215
 216 static void mdp5_kms_debugfs_cleanup(struct msm_kms *kms, struct drm_minor *minor)
 217 {
 218         drm_debugfs_remove_files(mdp5_debugfs_list,
 219                         ARRAY_SIZE(mdp5_debugfs_list), minor);
 220 }
 221 #endif
 222
 223 static const struct mdp_kms_funcs kms_funcs = {
 224         .base = {
 225                 .hw_init         = mdp5_hw_init,
 226                 .irq_preinstall  = mdp5_irq_preinstall,
 227                 .irq_postinstall = mdp5_irq_postinstall,
 228                 .irq_uninstall   = mdp5_irq_uninstall,
 229                 .irq             = mdp5_irq,
 230                 .enable_vblank   = mdp5_enable_vblank,
 231                 .disable_vblank  = mdp5_disable_vblank,
 232                 .swap_state      = mdp5_swap_state,
 233                 .prepare_commit  = mdp5_prepare_commit,
 234                 .complete_commit = mdp5_complete_commit,
 235                 .wait_for_crtc_commit_done = mdp5_wait_for_crtc_commit_done,
 236                 .get_format      = mdp_get_format,
 237                 .round_pixclk    = mdp5_round_pixclk,
 238                 .set_split_display = mdp5_set_split_display,
 239                 .destroy         = mdp5_kms_destroy,
 240 #ifdef CONFIG_DEBUG_FS
 241                 .debugfs_init    = mdp5_kms_debugfs_init,
 242                 .debugfs_cleanup = mdp5_kms_debugfs_cleanup,
 243 #endif
 244         },
 245         .set_irqmask         = mdp5_set_irqmask,
 246 };
 247
 248 int mdp5_disable(struct mdp5_kms *mdp5_kms)
 249 {
 250         DBG("");
 251
 252         clk_disable_unprepare(mdp5_kms->ahb_clk);
 253         clk_disable_unprepare(mdp5_kms->axi_clk);
 254         clk_disable_unprepare(mdp5_kms->core_clk);
 255         if (mdp5_kms->lut_clk)
 256                 clk_disable_unprepare(mdp5_kms->lut_clk);
 257
 258         return 0;
 259 }
 260
 261 int mdp5_enable(struct mdp5_kms *mdp5_kms)
 262 {
 263         DBG("");
 264
 265         clk_prepare_enable(mdp5_kms->ahb_clk);
 266         clk_prepare_enable(mdp5_kms->axi_clk);
 267         clk_prepare_enable(mdp5_kms->core_clk);
 268         if (mdp5_kms->lut_clk)
 269                 clk_prepare_enable(mdp5_kms->lut_clk);
 270
 271         return 0;
 272 }
 273
 274 static struct drm_encoder *construct_encoder(struct mdp5_kms *mdp5_kms,
 275                 enum mdp5_intf_type intf_type, int intf_num,
 276                 enum mdp5_intf_mode intf_mode, struct mdp5_ctl *ctl)
 277 {
 278         struct drm_device *dev = mdp5_kms->dev;
 279         struct msm_drm_private *priv = dev->dev_private;
 280         struct drm_encoder *encoder;
 281         struct mdp5_interface intf = {
 282                         .num    = intf_num,
 283                         .type   = intf_type,
 284                         .mode   = intf_mode,
 285         };
 286
 287         if ((intf_type == INTF_DSI) &&
 288                 (intf_mode == MDP5_INTF_DSI_MODE_COMMAND))
 289                 encoder = mdp5_cmd_encoder_init(dev, &intf, ctl);
 290         else
 291                 encoder = mdp5_encoder_init(dev, &intf, ctl);
 292
 293         if (IS_ERR(encoder)) {
 294                 dev_err(dev->dev, "failed to construct encoder\n");
 295                 return encoder;
 296         }
 297
 298         encoder->possible_crtcs = (1 << priv->num_crtcs) - 1;
 299         priv->encoders[priv->num_encoders++] = encoder;
 300
 301         return encoder;
 302 }
 303
 304 static int get_dsi_id_from_intf(const struct mdp5_cfg_hw *hw_cfg, int intf_num)
 305 {
 306         const enum mdp5_intf_type *intfs = hw_cfg->intf.connect;
 307         const int intf_cnt = ARRAY_SIZE(hw_cfg->intf.connect);
 308         int id = 0, i;
 309
 310         for (i = 0; i < intf_cnt; i++) {
 311                 if (intfs[i] == INTF_DSI) {
 312                         if (intf_num == i)
 313                                 return id;
 314
 315                         id++;
 316                 }
 317         }
 318
 319         return -EINVAL;
 320 }
 321
 322 static int modeset_init_intf(struct mdp5_kms *mdp5_kms, int intf_num)
 323 {
 324         struct drm_device *dev = mdp5_kms->dev;
 325         struct msm_drm_private *priv = dev->dev_private;
 326         const struct mdp5_cfg_hw *hw_cfg =
 327                                         mdp5_cfg_get_hw_config(mdp5_kms->cfg);
 328         enum mdp5_intf_type intf_type = hw_cfg->intf.connect[intf_num];
 329         struct mdp5_ctl_manager *ctlm = mdp5_kms->ctlm;
 330         struct mdp5_ctl *ctl;
 331         struct drm_encoder *encoder;
 332         int ret = 0;
 333
 334         switch (intf_type) {
 335         case INTF_DISABLED:
 336                 break;
 337         case INTF_eDP:
 338                 if (!priv->edp)
 339                         break;
 340
 341                 ctl = mdp5_ctlm_request(ctlm, intf_num);
 342                 if (!ctl) {
 343                         ret = -EINVAL;
 344                         break;
 345                 }
 346
 347                 encoder = construct_encoder(mdp5_kms, INTF_eDP, intf_num,
 348                                         MDP5_INTF_MODE_NONE, ctl);
 349                 if (IS_ERR(encoder)) {
 350                         ret = PTR_ERR(encoder);
 351                         break;
 352                 }
 353
 354                 ret = msm_edp_modeset_init(priv->edp, dev, encoder);
 355                 break;
 356         case INTF_HDMI:
 357                 if (!priv->hdmi)
 358                         break;
 359
 360                 ctl = mdp5_ctlm_request(ctlm, intf_num);
 361                 if (!ctl) {
 362                         ret = -EINVAL;
 363                         break;
 364                 }
 365
 366                 encoder = construct_encoder(mdp5_kms, INTF_HDMI, intf_num,
 367                                         MDP5_INTF_MODE_NONE, ctl);
 368                 if (IS_ERR(encoder)) {
 369                         ret = PTR_ERR(encoder);
 370                         break;
 371                 }
 372
 373                 ret = msm_hdmi_modeset_init(priv->hdmi, dev, encoder);
 374                 break;
 375         case INTF_DSI:
 376         {
 377                 int dsi_id = get_dsi_id_from_intf(hw_cfg, intf_num);
 378                 struct drm_encoder *dsi_encs[MSM_DSI_ENCODER_NUM];
 379                 enum mdp5_intf_mode mode;
 380                 int i;
 381
 382                 if ((dsi_id >= ARRAY_SIZE(priv->dsi)) || (dsi_id < 0)) {
 383                         dev_err(dev->dev, "failed to find dsi from intf %d\n",
 384                                 intf_num);
 385                         ret = -EINVAL;
 386                         break;
 387                 }
 388
 389                 if (!priv->dsi[dsi_id])
 390                         break;
 391
 392                 ctl = mdp5_ctlm_request(ctlm, intf_num);
 393                 if (!ctl) {
 394                         ret = -EINVAL;
 395                         break;
 396                 }
 397
 398                 for (i = 0; i < MSM_DSI_ENCODER_NUM; i++) {
 399                         mode = (i == MSM_DSI_CMD_ENCODER_ID) ?
 400                                 MDP5_INTF_DSI_MODE_COMMAND :
 401                                 MDP5_INTF_DSI_MODE_VIDEO;
 402                         dsi_encs[i] = construct_encoder(mdp5_kms, INTF_DSI,
 403                                                         intf_num, mode, ctl);
 404                         if (IS_ERR(dsi_encs[i])) {
 405                                 ret = PTR_ERR(dsi_encs[i]);
 406                                 break;
 407                         }
 408                 }
 409
 410                 ret = msm_dsi_modeset_init(priv->dsi[dsi_id], dev, dsi_encs);
 411                 break;
 412         }
 413         default:
 414                 dev_err(dev->dev, "unknown intf: %d\n", intf_type);
 415                 ret = -EINVAL;
 416                 break;
 417         }
 418
 419         return ret;
 420 }
 421
 422 static int modeset_init(struct mdp5_kms *mdp5_kms)
 423 {
 424         struct drm_device *dev = mdp5_kms->dev;
 425         struct msm_drm_private *priv = dev->dev_private;
 426         const struct mdp5_cfg_hw *hw_cfg;
 427         int i, ret;
 428
 429         hw_cfg = mdp5_cfg_get_hw_config(mdp5_kms->cfg);
 430
 431         /* Construct planes equaling the number of hw pipes, and CRTCs
 432          * for the N layer-mixers (LM).  The first N planes become primary
 433          * planes for the CRTCs, with the remainder as overlay planes:
 434          */
 435         for (i = 0; i < mdp5_kms->num_hwpipes; i++) {
 436                 bool primary = i < mdp5_cfg->lm.count;
 437                 struct drm_plane *plane;
 438                 struct drm_crtc *crtc;
 439
 440                 plane = mdp5_plane_init(dev, primary);
 441                 if (IS_ERR(plane)) {
 442                         ret = PTR_ERR(plane);
 443                         dev_err(dev->dev, "failed to construct plane %d (%d)\n", i, ret);
 444                         goto fail;
 445                 }
 446                 priv->planes[priv->num_planes++] = plane;
 447
 448                 if (!primary)
 449                         continue;
 450
 451                 crtc  = mdp5_crtc_init(dev, plane, i);
 452                 if (IS_ERR(crtc)) {
 453                         ret = PTR_ERR(crtc);
 454                         dev_err(dev->dev, "failed to construct crtc %d (%d)\n", i, ret);
 455                         goto fail;
 456                 }
 457                 priv->crtcs[priv->num_crtcs++] = crtc;
 458         }
 459
 460         /* Construct encoders and modeset initialize connector devices
 461          * for each external display interface.
 462          */
 463         for (i = 0; i < ARRAY_SIZE(hw_cfg->intf.connect); i++) {
 464                 ret = modeset_init_intf(mdp5_kms, i);
 465                 if (ret)
 466                         goto fail;
 467         }
 468
 469         return 0;
 470
 471 fail:
 472         return ret;
 473 }
 474
 475 static void read_mdp_hw_revision(struct mdp5_kms *mdp5_kms,
 476                                  u32 *major, u32 *minor)
 477 {
 478         u32 version;
 479
 480         mdp5_enable(mdp5_kms);
 481         version = mdp5_read(mdp5_kms, REG_MDP5_HW_VERSION);
 482         mdp5_disable(mdp5_kms);
 483
 484         *major = FIELD(version, MDP5_HW_VERSION_MAJOR);
 485         *minor = FIELD(version, MDP5_HW_VERSION_MINOR);
 486
 487         DBG("MDP5 version v%d.%d", *major, *minor);
 488 }
 489
 490 static int get_clk(struct platform_device *pdev, struct clk **clkp,
 491                 const char *name, bool mandatory)
 492 {
 493         struct device *dev = &pdev->dev;
 494         struct clk *clk = devm_clk_get(dev, name);
 495         if (IS_ERR(clk) && mandatory) {
 496                 dev_err(dev, "failed to get %s (%ld)\n", name, PTR_ERR(clk));
 497                 return PTR_ERR(clk);
 498         }
 499         if (IS_ERR(clk))
 500                 DBG("skipping %s", name);
 501         else
 502                 *clkp = clk;
 503
 504         return 0;
 505 }
 506
 507 static struct drm_encoder *get_encoder_from_crtc(struct drm_crtc *crtc)
 508 {
 509         struct drm_device *dev = crtc->dev;
 510         struct drm_encoder *encoder;
 511
 512         drm_for_each_encoder(encoder, dev)
 513                 if (encoder->crtc == crtc)
 514                         return encoder;
 515
 516         return NULL;
 517 }
 518
 519 static int mdp5_get_scanoutpos(struct drm_device *dev, unsigned int pipe,
 520                                unsigned int flags, int *vpos, int *hpos,
 521                                ktime_t *stime, ktime_t *etime,
 522                                const struct drm_display_mode *mode)
 523 {
 524         struct msm_drm_private *priv = dev->dev_private;
 525         struct drm_crtc *crtc;
 526         struct drm_encoder *encoder;
 527         int line, vsw, vbp, vactive_start, vactive_end, vfp_end;
 528         int ret = 0;
 529
 530         crtc = priv->crtcs[pipe];
 531         if (!crtc) {
 532                 DRM_ERROR("Invalid crtc %d\n", pipe);
 533                 return 0;
 534         }
 535
 536         encoder = get_encoder_from_crtc(crtc);
 537         if (!encoder) {
 538                 DRM_ERROR("no encoder found for crtc %d\n", pipe);
 539                 return 0;
 540         }
 541
 542         ret |= DRM_SCANOUTPOS_VALID | DRM_SCANOUTPOS_ACCURATE;
 543
 544         vsw = mode->crtc_vsync_end - mode->crtc_vsync_start;
 545         vbp = mode->crtc_vtotal - mode->crtc_vsync_end;
 546
 547         /*
 548          * the line counter is 1 at the start of the VSYNC pulse and VTOTAL at
 549          * the end of VFP. Translate the porch values relative to the line
 550          * counter positions.
 551          */
 552
 553         vactive_start = vsw + vbp + 1;
 554
 555         vactive_end = vactive_start + mode->crtc_vdisplay;
 556
 557         /* last scan line before VSYNC */
 558         vfp_end = mode->crtc_vtotal;
 559
 560         if (stime)
 561                 *stime = ktime_get();
 562
 563         line = mdp5_encoder_get_linecount(encoder);
 564
 565         if (line < vactive_start) {
 566                 line -= vactive_start;
 567                 ret |= DRM_SCANOUTPOS_IN_VBLANK;
 568         } else if (line > vactive_end) {
 569                 line = line - vfp_end - vactive_start;
 570                 ret |= DRM_SCANOUTPOS_IN_VBLANK;
 571         } else {
 572                 line -= vactive_start;
 573         }
 574
 575         *vpos = line;
 576         *hpos = 0;
 577
 578         if (etime)
 579                 *etime = ktime_get();
 580
 581         return ret;
 582 }
 583
 584 static int mdp5_get_vblank_timestamp(struct drm_device *dev, unsigned int pipe,
 585                                      int *max_error,
 586                                      struct timeval *vblank_time,
 587                                      unsigned flags)
 588 {
 589         struct msm_drm_private *priv = dev->dev_private;
 590         struct drm_crtc *crtc;
 591
 592         if (pipe < 0 || pipe >= priv->num_crtcs) {
 593                 DRM_ERROR("Invalid crtc %d\n", pipe);
 594                 return -EINVAL;
 595         }
 596
 597         crtc = priv->crtcs[pipe];
 598         if (!crtc) {
 599                 DRM_ERROR("Invalid crtc %d\n", pipe);
 600                 return -EINVAL;
 601         }
 602
 603         return drm_calc_vbltimestamp_from_scanoutpos(dev, pipe, max_error,
 604                                                      vblank_time, flags,
 605                                                      &crtc->mode);
 606 }
 607
 608 static u32 mdp5_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
 609 {
 610         struct msm_drm_private *priv = dev->dev_private;
 611         struct drm_crtc *crtc;
 612         struct drm_encoder *encoder;
 613
 614         if (pipe < 0 || pipe >= priv->num_crtcs)
 615                 return 0;
 616
 617         crtc = priv->crtcs[pipe];
 618         if (!crtc)
 619                 return 0;
 620
 621         encoder = get_encoder_from_crtc(crtc);
 622         if (!encoder)
 623                 return 0;
 624
 625         return mdp5_encoder_get_framecount(encoder);
 626 }
 627
 628 struct msm_kms *mdp5_kms_init(struct drm_device *dev)
 629 {
 630         struct msm_drm_private *priv = dev->dev_private;
 631         struct platform_device *pdev;
 632         struct mdp5_kms *mdp5_kms;
 633         struct mdp5_cfg *config;
 634         struct msm_kms *kms;
 635         struct msm_gem_address_space *aspace;
 636         int irq, i, ret;
 637
 638         /* priv->kms would have been populated by the MDP5 driver */
 639         kms = priv->kms;
 640         if (!kms)
 641                 return NULL;
 642
 643         mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
 644
 645         mdp_kms_init(&mdp5_kms->base, &kms_funcs);
 646
 647         pdev = mdp5_kms->pdev;
 648
 649         irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
 650         if (irq < 0) {
 651                 ret = irq;
 652                 dev_err(&pdev->dev, "failed to get irq: %d\n", ret);
 653                 goto fail;
 654         }
 655
 656         kms->irq = irq;
 657
 658         config = mdp5_cfg_get_config(mdp5_kms->cfg);
 659
 660         /* make sure things are off before attaching iommu (bootloader could
 661          * have left things on, in which case we'll start getting faults if
 662          * we don't disable):
 663          */
 664         mdp5_enable(mdp5_kms);
 665         for (i = 0; i < MDP5_INTF_NUM_MAX; i++) {
 666                 if (mdp5_cfg_intf_is_virtual(config->hw->intf.connect[i]) ||
 667                     !config->hw->intf.base[i])
 668                         continue;
 669                 mdp5_write(mdp5_kms, REG_MDP5_INTF_TIMING_ENGINE_EN(i), 0);
 670
 671                 mdp5_write(mdp5_kms, REG_MDP5_INTF_FRAME_LINE_COUNT_EN(i), 0x3);
 672         }
 673         mdp5_disable(mdp5_kms);
 674         mdelay(16);
 675
 676         if (config->platform.iommu) {
 677                 aspace = msm_gem_address_space_create(&pdev->dev,
 678                                 config->platform.iommu, "mdp5");
 679                 if (IS_ERR(aspace)) {
 680                         ret = PTR_ERR(aspace);
 681                         goto fail;
 682                 }
 683
 684                 mdp5_kms->aspace = aspace;
 685
 686                 ret = aspace->mmu->funcs->attach(aspace->mmu, iommu_ports,
 687                                 ARRAY_SIZE(iommu_ports));
 688                 if (ret) {
 689                         dev_err(&pdev->dev, "failed to attach iommu: %d\n",
 690                                 ret);
 691                         goto fail;
 692                 }
 693         } else {
 694                 dev_info(&pdev->dev,
 695                          "no iommu, fallback to phys contig buffers for scanout\n");
 696                 aspace = NULL;;
 697         }
 698
 699         mdp5_kms->id = msm_register_address_space(dev, aspace);
 700         if (mdp5_kms->id < 0) {
 701                 ret = mdp5_kms->id;
 702                 dev_err(&pdev->dev, "failed to register mdp5 iommu: %d\n", ret);
 703                 goto fail;
 704         }
 705
 706         ret = modeset_init(mdp5_kms);
 707         if (ret) {
 708                 dev_err(&pdev->dev, "modeset_init failed: %d\n", ret);
 709                 goto fail;
 710         }
 711
 712         dev->mode_config.min_width = 0;
 713         dev->mode_config.min_height = 0;
 714         dev->mode_config.max_width = 0xffff;
 715         dev->mode_config.max_height = 0xffff;
 716
 717         dev->driver->get_vblank_timestamp = mdp5_get_vblank_timestamp;
 718         dev->driver->get_scanout_position = mdp5_get_scanoutpos;
 719         dev->driver->get_vblank_counter = mdp5_get_vblank_counter;
 720         dev->max_vblank_count = 0xffffffff;
 721         dev->vblank_disable_immediate = true;
 722
 723         return kms;
 724 fail:
 725         if (kms)
 726                 mdp5_kms_destroy(kms);
 727         return ERR_PTR(ret);
 728 }
 729
 730 static void mdp5_destroy(struct platform_device *pdev)
 731 {
 732         struct mdp5_kms *mdp5_kms = platform_get_drvdata(pdev);
 733
 734         if (mdp5_kms->ctlm)
 735                 mdp5_ctlm_destroy(mdp5_kms->ctlm);
 736         if (mdp5_kms->smp)
 737                 mdp5_smp_destroy(mdp5_kms->smp);
 738         if (mdp5_kms->cfg)
 739                 mdp5_cfg_destroy(mdp5_kms->cfg);
 740
 741         if (mdp5_kms->rpm_enabled)
 742                 pm_runtime_disable(&pdev->dev);
 743
 744         kfree(mdp5_kms->state);
 745 }
 746
 747 static int construct_pipes(struct mdp5_kms *mdp5_kms, int cnt,
 748                 const enum mdp5_pipe *pipes, const uint32_t *offsets,
 749                 uint32_t caps)
 750 {
 751         struct drm_device *dev = mdp5_kms->dev;
 752         int i, ret;
 753
 754         for (i = 0; i < cnt; i++) {
 755                 struct mdp5_hw_pipe *hwpipe;
 756
 757                 hwpipe = mdp5_pipe_init(pipes[i], offsets[i], caps);
 758                 if (IS_ERR(hwpipe)) {
 759                         ret = PTR_ERR(hwpipe);
 760                         dev_err(dev->dev, "failed to construct pipe for %s (%d)\n",
 761                                         pipe2name(pipes[i]), ret);
 762                         return ret;
 763                 }
 764                 hwpipe->idx = mdp5_kms->num_hwpipes;
 765                 mdp5_kms->hwpipes[mdp5_kms->num_hwpipes++] = hwpipe;
 766         }
 767
 768         return 0;
 769 }
 770
 771 static int hwpipe_init(struct mdp5_kms *mdp5_kms)
 772 {
 773         static const enum mdp5_pipe rgb_planes[] = {
 774                         SSPP_RGB0, SSPP_RGB1, SSPP_RGB2, SSPP_RGB3,
 775         };
 776         static const enum mdp5_pipe vig_planes[] = {
 777                         SSPP_VIG0, SSPP_VIG1, SSPP_VIG2, SSPP_VIG3,
 778         };
 779         static const enum mdp5_pipe dma_planes[] = {
 780                         SSPP_DMA0, SSPP_DMA1,
 781         };
 782         const struct mdp5_cfg_hw *hw_cfg;
 783         int ret;
 784
 785         hw_cfg = mdp5_cfg_get_hw_config(mdp5_kms->cfg);
 786
 787         /* Construct RGB pipes: */
 788         ret = construct_pipes(mdp5_kms, hw_cfg->pipe_rgb.count, rgb_planes,
 789                         hw_cfg->pipe_rgb.base, hw_cfg->pipe_rgb.caps);
 790         if (ret)
 791                 return ret;
 792
 793         /* Construct video (VIG) pipes: */
 794         ret = construct_pipes(mdp5_kms, hw_cfg->pipe_vig.count, vig_planes,
 795                         hw_cfg->pipe_vig.base, hw_cfg->pipe_vig.caps);
 796         if (ret)
 797                 return ret;
 798
 799         /* Construct DMA pipes: */
 800         ret = construct_pipes(mdp5_kms, hw_cfg->pipe_dma.count, dma_planes,
 801                         hw_cfg->pipe_dma.base, hw_cfg->pipe_dma.caps);
 802         if (ret)
 803                 return ret;
 804
 805         return 0;
 806 }
 807
 808 static int mdp5_init(struct platform_device *pdev, struct drm_device *dev)
 809 {
 810         struct msm_drm_private *priv = dev->dev_private;
 811         struct mdp5_kms *mdp5_kms;
 812         struct mdp5_cfg *config;
 813         u32 major, minor;
 814         int ret;
 815
 816         mdp5_kms = devm_kzalloc(&pdev->dev, sizeof(*mdp5_kms), GFP_KERNEL);
 817         if (!mdp5_kms) {
 818                 ret = -ENOMEM;
 819                 goto fail;
 820         }
 821
 822         platform_set_drvdata(pdev, mdp5_kms);
 823
 824         spin_lock_init(&mdp5_kms->resource_lock);
 825
 826         mdp5_kms->dev = dev;
 827         mdp5_kms->pdev = pdev;
 828
 829         drm_modeset_lock_init(&mdp5_kms->state_lock);
 830         mdp5_kms->state = kzalloc(sizeof(*mdp5_kms->state), GFP_KERNEL);
 831         if (!mdp5_kms->state) {
 832                 ret = -ENOMEM;
 833                 goto fail;
 834         }
 835
 836         mdp5_kms->mmio = msm_ioremap(pdev, "mdp_phys", "MDP5");
 837         if (IS_ERR(mdp5_kms->mmio)) {
 838                 ret = PTR_ERR(mdp5_kms->mmio);
 839                 goto fail;
 840         }
 841
 842         /* mandatory clocks: */
 843         ret = get_clk(pdev, &mdp5_kms->axi_clk, "bus_clk", true);
 844         if (ret)
 845                 goto fail;
 846         ret = get_clk(pdev, &mdp5_kms->ahb_clk, "iface_clk", true);
 847         if (ret)
 848                 goto fail;
 849         ret = get_clk(pdev, &mdp5_kms->core_clk, "core_clk", true);
 850         if (ret)
 851                 goto fail;
 852         ret = get_clk(pdev, &mdp5_kms->vsync_clk, "vsync_clk", true);
 853         if (ret)
 854                 goto fail;
 855
 856         /* optional clocks: */
 857         get_clk(pdev, &mdp5_kms->lut_clk, "lut_clk", false);
 858
 859         /* we need to set a default rate before enabling.  Set a safe
 860          * rate first, then figure out hw revision, and then set a
 861          * more optimal rate:
 862          */
 863         clk_set_rate(mdp5_kms->core_clk, 200000000);
 864
 865         pm_runtime_enable(&pdev->dev);
 866         mdp5_kms->rpm_enabled = true;
 867
 868         read_mdp_hw_revision(mdp5_kms, &major, &minor);
 869
 870         mdp5_kms->cfg = mdp5_cfg_init(mdp5_kms, major, minor);
 871         if (IS_ERR(mdp5_kms->cfg)) {
 872                 ret = PTR_ERR(mdp5_kms->cfg);
 873                 mdp5_kms->cfg = NULL;
 874                 goto fail;
 875         }
 876
 877         config = mdp5_cfg_get_config(mdp5_kms->cfg);
 878         mdp5_kms->caps = config->hw->mdp.caps;
 879
 880         /* TODO: compute core clock rate at runtime */
 881         clk_set_rate(mdp5_kms->core_clk, config->hw->max_clk);
 882
 883         /*
 884          * Some chipsets have a Shared Memory Pool (SMP), while others
 885          * have dedicated latency buffering per source pipe instead;
 886          * this section initializes the SMP:
 887          */
 888         if (mdp5_kms->caps & MDP_CAP_SMP) {
 889                 mdp5_kms->smp = mdp5_smp_init(mdp5_kms, &config->hw->smp);
 890                 if (IS_ERR(mdp5_kms->smp)) {
 891                         ret = PTR_ERR(mdp5_kms->smp);
 892                         mdp5_kms->smp = NULL;
 893                         goto fail;
 894                 }
 895         }
 896
 897         mdp5_kms->ctlm = mdp5_ctlm_init(dev, mdp5_kms->mmio, mdp5_kms->cfg);
 898         if (IS_ERR(mdp5_kms->ctlm)) {
 899                 ret = PTR_ERR(mdp5_kms->ctlm);
 900                 mdp5_kms->ctlm = NULL;
 901                 goto fail;
 902         }
 903
 904         ret = hwpipe_init(mdp5_kms);
 905         if (ret)
 906                 goto fail;
 907
 908         /* set uninit-ed kms */
 909         priv->kms = &mdp5_kms->base.base;
 910
 911         return 0;
 912 fail:
 913         mdp5_destroy(pdev);
 914         return ret;
 915 }
 916
 917 static int mdp5_bind(struct device *dev, struct device *master, void *data)
 918 {
 919         struct drm_device *ddev = dev_get_drvdata(master);
 920         struct platform_device *pdev = to_platform_device(dev);
 921
 922         DBG("");
 923
 924         return mdp5_init(pdev, ddev);
 925 }
 926
 927 static void mdp5_unbind(struct device *dev, struct device *master,
 928                         void *data)
 929 {
 930         struct platform_device *pdev = to_platform_device(dev);
 931
 932         mdp5_destroy(pdev);
 933 }
 934
 935 static const struct component_ops mdp5_ops = {
 936         .bind   = mdp5_bind,
 937         .unbind = mdp5_unbind,
 938 };
 939
 940 static int mdp5_dev_probe(struct platform_device *pdev)
 941 {
 942         DBG("");
 943         return component_add(&pdev->dev, &mdp5_ops);
 944 }
 945
 946 static int mdp5_dev_remove(struct platform_device *pdev)
 947 {
 948         DBG("");
 949         component_del(&pdev->dev, &mdp5_ops);
 950         return 0;
 951 }
 952
 953 static const struct of_device_id mdp5_dt_match[] = {
 954         { .compatible = "qcom,mdp5", },
 955         /* to support downstream DT files */
 956         { .compatible = "qcom,mdss_mdp", },
 957         {}
 958 };
 959 MODULE_DEVICE_TABLE(of, mdp5_dt_match);
 960
 961 static struct platform_driver mdp5_driver = {
 962         .probe = mdp5_dev_probe,
 963         .remove = mdp5_dev_remove,
 964         .driver = {
 965                 .name = "msm_mdp",
 966                 .of_match_table = mdp5_dt_match,
 967         },
 968 };
 969
 970 void __init msm_mdp_register(void)
 971 {
 972         DBG("");
 973         platform_driver_register(&mdp5_driver);
 974 }
 975
 976 void __exit msm_mdp_unregister(void)
 977 {
 978         DBG("");
 979         platform_driver_unregister(&mdp5_driver);
 980 }