drivers/gpu/drm/rockchip/rockchip_drm_drv.c

   1 /*
   2  * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
   3  * Author:Mark Yao <mark.yao@rock-chips.com>
   4  *
   5  * based on exynos_drm_drv.c
   6  *
   7  * This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <drm/drmP.h>
  18 #include <drm/drm_atomic.h>
  19 #include <drm/drm_crtc_helper.h>
  20 #include <drm/drm_fb_helper.h>
  21 #include <drm/drm_sync_helper.h>
  22 #include <drm/rockchip_drm.h>
  23 #include <linux/dma-mapping.h>
  24 #include <linux/dma-iommu.h>
  25 #include <linux/pm_runtime.h>
  26 #include <linux/memblock.h>
  27 #include <linux/module.h>
  28 #include <linux/of_address.h>
  29 #include <linux/of_graph.h>
  30 #include <linux/component.h>
  31 #include <linux/fence.h>
  32 #include <linux/console.h>
  33 #include <linux/iommu.h>
  34
  35 #include <drm/rockchip_drm.h>
  36
  37 #include "rockchip_drm_drv.h"
  38 #include "rockchip_drm_fb.h"
  39 #include "rockchip_drm_fbdev.h"
  40 #include "rockchip_drm_gem.h"
  41 #include "rockchip_drm_rga.h"
  42
  43 #define DRIVER_NAME     "rockchip"
  44 #define DRIVER_DESC     "RockChip Soc DRM"
  45 #define DRIVER_DATE     "20140818"
  46 #define DRIVER_MAJOR    1
  47 #define DRIVER_MINOR    0
  48
  49 static bool is_support_iommu = true;
  50
  51 static LIST_HEAD(rockchip_drm_subdrv_list);
  52 static DEFINE_MUTEX(subdrv_list_mutex);
  53
  54 struct rockchip_drm_mode_set {
  55         struct list_head head;
  56         struct drm_framebuffer *fb;
  57         struct drm_connector *connector;
  58         struct drm_crtc *crtc;
  59         struct drm_display_mode *mode;
  60         int hdisplay;
  61         int vdisplay;
  62         int vrefresh;
  63
  64         bool mode_changed;
  65         bool ymirror;
  66         int ratio;
  67 };
  68
  69 static struct drm_crtc *find_crtc_by_node(struct drm_device *drm_dev,
  70                                           struct device_node *node)
  71 {
  72         struct device_node *np_crtc;
  73         struct drm_crtc *crtc;
  74
  75         np_crtc = of_get_parent(node);
  76         if (!np_crtc || !of_device_is_available(np_crtc))
  77                 return NULL;
  78
  79         drm_for_each_crtc(crtc, drm_dev) {
  80                 if (crtc->port == np_crtc)
  81                         return crtc;
  82         }
  83
  84         return NULL;
  85 }
  86
  87 static struct drm_connector *find_connector_by_node(struct drm_device *drm_dev,
  88                                                     struct device_node *node)
  89 {
  90         struct device_node *np_connector;
  91         struct drm_connector *connector;
  92
  93         np_connector = of_graph_get_remote_port_parent(node);
  94         if (!np_connector || !of_device_is_available(np_connector))
  95                 return NULL;
  96
  97         drm_for_each_connector(connector, drm_dev) {
  98                 if (connector->port == np_connector)
  99                         return connector;
 100         }
 101
 102         return NULL;
 103 }
 104
 105 static int init_loader_memory(struct drm_device *drm_dev)
 106 {
 107         struct rockchip_drm_private *private = drm_dev->dev_private;
 108         struct rockchip_logo *logo;
 109         struct device_node *np = drm_dev->dev->of_node;
 110         struct device_node *node;
 111         unsigned long nr_pages;
 112         struct page **pages;
 113         struct sg_table *sgt;
 114         DEFINE_DMA_ATTRS(attrs);
 115         phys_addr_t start, size;
 116         struct resource res;
 117         int i, ret;
 118
 119         logo = devm_kmalloc(drm_dev->dev, sizeof(*logo), GFP_KERNEL);
 120         if (!logo)
 121                 return -ENOMEM;
 122
 123         node = of_parse_phandle(np, "memory-region", 0);
 124         if (!node)
 125                 return -ENOMEM;
 126
 127         ret = of_address_to_resource(node, 0, &res);
 128         if (ret)
 129                 return ret;
 130         start = res.start;
 131         size = resource_size(&res);
 132         if (!size)
 133                 return -ENOMEM;
 134
 135         nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
 136         pages = kmalloc_array(nr_pages, sizeof(*pages), GFP_KERNEL);
 137         if (!pages)
 138                 return -ENOMEM;
 139         i = 0;
 140         while (i < nr_pages) {
 141                 pages[i] = phys_to_page(start);
 142                 start += PAGE_SIZE;
 143                 i++;
 144         }
 145         sgt = drm_prime_pages_to_sg(pages, nr_pages);
 146         if (IS_ERR(sgt)) {
 147                 kfree(pages);
 148                 return PTR_ERR(sgt);
 149         }
 150
 151         dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
 152         dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &attrs);
 153         dma_map_sg_attrs(drm_dev->dev, sgt->sgl, sgt->nents,
 154                          DMA_TO_DEVICE, &attrs);
 155         logo->dma_addr = sg_dma_address(sgt->sgl);
 156         logo->sgt = sgt;
 157         logo->start = res.start;
 158         logo->size = size;
 159         logo->count = 0;
 160         private->logo = logo;
 161
 162         return 0;
 163 }
 164
 165 static struct drm_framebuffer *
 166 get_framebuffer_by_node(struct drm_device *drm_dev, struct device_node *node)
 167 {
 168         struct rockchip_drm_private *private = drm_dev->dev_private;
 169         struct drm_mode_fb_cmd2 mode_cmd = { 0 };
 170         u32 val;
 171         int bpp;
 172
 173         if (WARN_ON(!private->logo))
 174                 return NULL;
 175
 176         if (of_property_read_u32(node, "logo,offset", &val)) {
 177                 pr_err("%s: failed to get logo,offset\n", __func__);
 178                 return NULL;
 179         }
 180         mode_cmd.offsets[0] = val;
 181
 182         if (of_property_read_u32(node, "logo,width", &val)) {
 183                 pr_err("%s: failed to get logo,width\n", __func__);
 184                 return NULL;
 185         }
 186         mode_cmd.width = val;
 187
 188         if (of_property_read_u32(node, "logo,height", &val)) {
 189                 pr_err("%s: failed to get logo,height\n", __func__);
 190                 return NULL;
 191         }
 192         mode_cmd.height = val;
 193
 194         if (of_property_read_u32(node, "logo,bpp", &val)) {
 195                 pr_err("%s: failed to get logo,bpp\n", __func__);
 196                 return NULL;
 197         }
 198         bpp = val;
 199
 200         mode_cmd.pitches[0] = mode_cmd.width * bpp / 8;
 201
 202         switch (bpp) {
 203         case 16:
 204                 mode_cmd.pixel_format = DRM_FORMAT_BGR565;
 205                 break;
 206         case 24:
 207                 mode_cmd.pixel_format = DRM_FORMAT_BGR888;
 208                 break;
 209         case 32:
 210                 mode_cmd.pixel_format = DRM_FORMAT_XBGR8888;
 211                 break;
 212         default:
 213                 pr_err("%s: unsupport to logo bpp %d\n", __func__, bpp);
 214                 return NULL;
 215         }
 216
 217         return rockchip_fb_alloc(drm_dev, &mode_cmd, NULL, private->logo, 1);
 218 }
 219
 220 static struct rockchip_drm_mode_set *
 221 of_parse_display_resource(struct drm_device *drm_dev, struct device_node *route)
 222 {
 223         struct rockchip_drm_mode_set *set;
 224         struct device_node *connect;
 225         struct drm_framebuffer *fb;
 226         struct drm_connector *connector;
 227         struct drm_crtc *crtc;
 228         const char *string;
 229         u32 val;
 230
 231         connect = of_parse_phandle(route, "connect", 0);
 232         if (!connect)
 233                 return NULL;
 234
 235         fb = get_framebuffer_by_node(drm_dev, route);
 236         if (IS_ERR_OR_NULL(fb))
 237                 return NULL;
 238
 239         crtc = find_crtc_by_node(drm_dev, connect);
 240         connector = find_connector_by_node(drm_dev, connect);
 241         if (!crtc || !connector) {
 242                 dev_warn(drm_dev->dev,
 243                          "No available crtc or connector for display");
 244                 drm_framebuffer_unreference(fb);
 245                 return NULL;
 246         }
 247
 248         set = kzalloc(sizeof(*set), GFP_KERNEL);
 249         if (!set)
 250                 return NULL;
 251
 252         if (!of_property_read_u32(route, "video,hdisplay", &val))
 253                 set->hdisplay = val;
 254
 255         if (!of_property_read_u32(route, "video,vdisplay", &val))
 256                 set->vdisplay = val;
 257
 258         if (!of_property_read_u32(route, "video,vrefresh", &val))
 259                 set->vrefresh = val;
 260
 261         if (!of_property_read_u32(route, "logo,ymirror", &val))
 262                 set->ymirror = val;
 263
 264         set->ratio = 1;
 265         if (!of_property_read_string(route, "logo,mode", &string) &&
 266             !strcmp(string, "fullscreen"))
 267                         set->ratio = 0;
 268
 269         set->fb = fb;
 270         set->crtc = crtc;
 271         set->connector = connector;
 272
 273         return set;
 274 }
 275
 276 int setup_initial_state(struct drm_device *drm_dev,
 277                         struct drm_atomic_state *state,
 278                         struct rockchip_drm_mode_set *set)
 279 {
 280         struct drm_connector *connector = set->connector;
 281         struct drm_crtc *crtc = set->crtc;
 282         struct drm_crtc_state *crtc_state;
 283         struct drm_connector_state *conn_state;
 284         struct drm_plane_state *primary_state;
 285         struct drm_display_mode *mode = NULL;
 286         const struct drm_connector_helper_funcs *funcs;
 287         bool is_crtc_enabled = true;
 288         int hdisplay, vdisplay;
 289         int fb_width, fb_height;
 290         int found = 0, match = 0;
 291         int num_modes;
 292         int ret = 0;
 293
 294         if (!set->hdisplay || !set->vdisplay || !set->vrefresh)
 295                 is_crtc_enabled = false;
 296
 297         conn_state = drm_atomic_get_connector_state(state, connector);
 298         if (IS_ERR(conn_state))
 299                 return PTR_ERR(conn_state);
 300
 301         funcs = connector->helper_private;
 302         conn_state->best_encoder = funcs->best_encoder(connector);
 303         if (funcs->loader_protect)
 304                 funcs->loader_protect(connector, true);
 305         num_modes = connector->funcs->fill_modes(connector, 4096, 4096);
 306         if (!num_modes) {
 307                 dev_err(drm_dev->dev, "connector[%s] can't found any modes\n",
 308                         connector->name);
 309                 ret = -EINVAL;
 310                 goto error;
 311         }
 312
 313         list_for_each_entry(mode, &connector->modes, head) {
 314                 if (mode->hdisplay == set->hdisplay &&
 315                     mode->vdisplay == set->vdisplay &&
 316                     drm_mode_vrefresh(mode) == set->vrefresh) {
 317                         found = 1;
 318                         match = 1;
 319                         break;
 320                 }
 321         }
 322
 323         if (!found) {
 324                 list_for_each_entry(mode, &connector->modes, head) {
 325                         if (mode->type & DRM_MODE_TYPE_PREFERRED) {
 326                                 found = 1;
 327                                 break;
 328                         }
 329                 }
 330
 331                 if (!found) {
 332                         mode = list_first_entry_or_null(&connector->modes,
 333                                                         struct drm_display_mode,
 334                                                         head);
 335                         if (!mode) {
 336                                 pr_err("failed to find available modes\n");
 337                                 ret = -EINVAL;
 338                                 goto error;
 339                         }
 340                 }
 341         }
 342
 343         set->mode = mode;
 344         crtc_state = drm_atomic_get_crtc_state(state, crtc);
 345         if (IS_ERR(crtc_state)) {
 346                 ret = PTR_ERR(crtc_state);
 347                 goto error;
 348         }
 349
 350         drm_mode_copy(&crtc_state->adjusted_mode, mode);
 351         if (!match || !is_crtc_enabled) {
 352                 set->mode_changed = true;
 353         } else {
 354                 ret = drm_atomic_set_crtc_for_connector(conn_state, crtc);
 355                 if (ret)
 356                         goto error;
 357
 358                 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
 359                 if (ret)
 360                         goto error;
 361
 362                 crtc_state->active = true;
 363         }
 364
 365         if (!set->fb) {
 366                 ret = 0;
 367                 goto error;
 368         }
 369         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
 370         if (IS_ERR(primary_state)) {
 371                 ret = PTR_ERR(primary_state);
 372                 goto error;
 373         }
 374
 375         hdisplay = mode->hdisplay;
 376         vdisplay = mode->vdisplay;
 377         fb_width = set->fb->width;
 378         fb_height = set->fb->height;
 379
 380         primary_state->crtc = crtc;
 381         primary_state->src_x = 0;
 382         primary_state->src_y = 0;
 383         primary_state->src_w = fb_width << 16;
 384         primary_state->src_h = fb_height << 16;
 385         if (set->ratio) {
 386                 if (set->fb->width >= hdisplay) {
 387                         primary_state->crtc_x = 0;
 388                         primary_state->crtc_w = hdisplay;
 389                 } else {
 390                         primary_state->crtc_x = (hdisplay - fb_width) / 2;
 391                         primary_state->crtc_w = set->fb->width;
 392                 }
 393
 394                 if (set->fb->height >= vdisplay) {
 395                         primary_state->crtc_y = 0;
 396                         primary_state->crtc_h = vdisplay;
 397                 } else {
 398                         primary_state->crtc_y = (vdisplay - fb_height) / 2;
 399                         primary_state->crtc_h = fb_height;
 400                 }
 401         } else {
 402                 primary_state->crtc_x = 0;
 403                 primary_state->crtc_y = 0;
 404                 primary_state->crtc_w = hdisplay;
 405                 primary_state->crtc_h = vdisplay;
 406         }
 407
 408         return 0;
 409
 410 error:
 411         if (funcs->loader_protect)
 412                 funcs->loader_protect(connector, false);
 413         return ret;
 414 }
 415
 416 static int update_state(struct drm_device *drm_dev,
 417                         struct drm_atomic_state *state,
 418                         struct rockchip_drm_mode_set *set,
 419                         unsigned int *plane_mask)
 420 {
 421         struct drm_mode_config *mode_config = &drm_dev->mode_config;
 422         struct drm_crtc *crtc = set->crtc;
 423         struct drm_connector *connector = set->connector;
 424         struct drm_display_mode *mode = set->mode;
 425         struct drm_plane_state *primary_state;
 426         struct drm_crtc_state *crtc_state;
 427         struct drm_connector_state *conn_state;
 428         int ret;
 429
 430         crtc_state = drm_atomic_get_crtc_state(state, crtc);
 431         if (IS_ERR(crtc_state))
 432                 return PTR_ERR(crtc_state);
 433         conn_state = drm_atomic_get_connector_state(state, connector);
 434         if (IS_ERR(conn_state))
 435                 return PTR_ERR(conn_state);
 436
 437         if (set->mode_changed) {
 438                 ret = drm_atomic_set_crtc_for_connector(conn_state, crtc);
 439                 if (ret)
 440                         return ret;
 441
 442                 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
 443                 if (ret)
 444                         return ret;
 445
 446                 crtc_state->active = true;
 447         } else {
 448                 const struct drm_crtc_helper_funcs *funcs;
 449                 const struct drm_encoder_helper_funcs *encoder_helper_funcs;
 450                 const struct drm_connector_helper_funcs *connector_helper_funcs;
 451                 struct drm_encoder *encoder;
 452
 453                 funcs = crtc->helper_private;
 454                 connector_helper_funcs = connector->helper_private;
 455                 if (!funcs || !funcs->enable ||
 456                     !connector_helper_funcs ||
 457                     !connector_helper_funcs->best_encoder)
 458                         return -ENXIO;
 459                 encoder = connector_helper_funcs->best_encoder(connector);
 460                 encoder_helper_funcs = encoder->helper_private;
 461                 if (!encoder || !encoder_helper_funcs->atomic_check)
 462                         return -ENXIO;
 463                 ret = encoder_helper_funcs->atomic_check(encoder, crtc->state,
 464                                                          conn_state);
 465                 if (ret)
 466                         return ret;
 467                 funcs->enable(crtc);
 468         }
 469
 470         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
 471         if (IS_ERR(primary_state))
 472                 return PTR_ERR(primary_state);
 473
 474         crtc_state->plane_mask = 1 << drm_plane_index(crtc->primary);
 475         *plane_mask |= crtc_state->plane_mask;
 476
 477         drm_atomic_set_fb_for_plane(primary_state, set->fb);
 478         drm_framebuffer_unreference(set->fb);
 479         ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
 480
 481         if (set->ymirror)
 482                 /*
 483                  * TODO:
 484                  * some vop maybe not support ymirror, but force use it now.
 485                  */
 486                 drm_atomic_plane_set_property(crtc->primary, primary_state,
 487                                               mode_config->rotation_property,
 488                                               BIT(DRM_REFLECT_Y));
 489
 490         return ret;
 491 }
 492
 493 static void show_loader_logo(struct drm_device *drm_dev)
 494 {
 495         struct drm_atomic_state *state;
 496         struct device_node *np = drm_dev->dev->of_node;
 497         struct drm_mode_config *mode_config = &drm_dev->mode_config;
 498         struct device_node *root, *route;
 499         struct rockchip_drm_mode_set *set, *tmp;
 500         struct list_head mode_set_list;
 501         unsigned plane_mask = 0;
 502         int ret;
 503
 504         root = of_get_child_by_name(np, "route");
 505         if (!root) {
 506                 dev_warn(drm_dev->dev, "failed to parse display resources\n");
 507                 return;
 508         }
 509
 510         if (init_loader_memory(drm_dev)) {
 511                 dev_warn(drm_dev->dev, "failed to parse loader memory\n");
 512                 return;
 513         }
 514
 515         INIT_LIST_HEAD(&mode_set_list);
 516         drm_modeset_lock_all(drm_dev);
 517         state = drm_atomic_state_alloc(drm_dev);
 518         if (!state) {
 519                 dev_err(drm_dev->dev, "failed to alloc atomic state\n");
 520                 ret = -ENOMEM;
 521                 goto err_unlock;
 522         }
 523
 524         state->acquire_ctx = mode_config->acquire_ctx;
 525
 526         for_each_child_of_node(root, route) {
 527                 if (!of_device_is_available(route))
 528                         continue;
 529
 530                 set = of_parse_display_resource(drm_dev, route);
 531                 if (!set)
 532                         continue;
 533
 534                 if (setup_initial_state(drm_dev, state, set)) {
 535                         drm_framebuffer_unreference(set->fb);
 536                         kfree(set);
 537                         continue;
 538                 }
 539                 INIT_LIST_HEAD(&set->head);
 540                 list_add_tail(&set->head, &mode_set_list);
 541         }
 542
 543         if (list_empty(&mode_set_list)) {
 544                 dev_warn(drm_dev->dev, "can't not find any loader display\n");
 545                 ret = -ENXIO;
 546                 goto err_free_state;
 547         }
 548
 549         /*
 550          * The state save initial devices status, swap the state into
 551          * drm deivces as old state, so if new state come, can compare
 552          * with this state to judge which status need to update.
 553          */
 554         drm_atomic_helper_swap_state(drm_dev, state);
 555         drm_atomic_state_free(state);
 556         state = drm_atomic_helper_duplicate_state(drm_dev,
 557                                                   mode_config->acquire_ctx);
 558         if (IS_ERR(state)) {
 559                 dev_err(drm_dev->dev, "failed to duplicate atomic state\n");
 560                 ret = PTR_ERR_OR_ZERO(state);
 561                 goto err_unlock;
 562         }
 563         state->acquire_ctx = mode_config->acquire_ctx;
 564         list_for_each_entry(set, &mode_set_list, head)
 565                 /*
 566                  * We don't want to see any fail on update_state.
 567                  */
 568                 WARN_ON(update_state(drm_dev, state, set, &plane_mask));
 569
 570         ret = drm_atomic_commit(state);
 571         drm_atomic_clean_old_fb(drm_dev, plane_mask, ret);
 572
 573         list_for_each_entry_safe(set, tmp, &mode_set_list, head) {
 574                 struct drm_crtc *crtc = set->crtc;
 575
 576                 list_del(&set->head);
 577                 kfree(set);
 578
 579                 /* FIXME:
 580                  * primary plane state rotation is not BIT(0), but we only want
 581                  * it effect on logo display, userspace may not known to clean
 582                  * this property, would get unexpect display, so force set
 583                  * primary rotation to BIT(0).
 584                  */
 585                 if (!crtc->primary || !crtc->primary->state)
 586                         continue;
 587
 588                 drm_atomic_plane_set_property(crtc->primary,
 589                                               crtc->primary->state,
 590                                               mode_config->rotation_property,
 591                                               BIT(0));
 592         }
 593
 594         /*
 595          * Is possible get deadlock here?
 596          */
 597         WARN_ON(ret == -EDEADLK);
 598
 599         if (ret)
 600                 goto err_free_state;
 601
 602         drm_modeset_unlock_all(drm_dev);
 603         return;
 604
 605 err_free_state:
 606         drm_atomic_state_free(state);
 607 err_unlock:
 608         drm_modeset_unlock_all(drm_dev);
 609         if (ret)
 610                 dev_err(drm_dev->dev, "failed to show loader logo\n");
 611 }
 612
 613 /*
 614  * Attach a (component) device to the shared drm dma mapping from master drm
 615  * device.  This is used by the VOPs to map GEM buffers to a common DMA
 616  * mapping.
 617  */
 618 int rockchip_drm_dma_attach_device(struct drm_device *drm_dev,
 619                                    struct device *dev)
 620 {
 621         struct rockchip_drm_private *private = drm_dev->dev_private;
 622         int ret;
 623
 624         if (!is_support_iommu)
 625                 return 0;
 626
 627         ret = iommu_attach_device(private->domain, dev);
 628         if (ret) {
 629                 dev_err(dev, "Failed to attach iommu device\n");
 630                 return ret;
 631         }
 632
 633         return 0;
 634 }
 635
 636 void rockchip_drm_dma_detach_device(struct drm_device *drm_dev,
 637                                     struct device *dev)
 638 {
 639         struct rockchip_drm_private *private = drm_dev->dev_private;
 640         struct iommu_domain *domain = private->domain;
 641
 642         if (!is_support_iommu)
 643                 return;
 644
 645         iommu_detach_device(domain, dev);
 646 }
 647
 648 int rockchip_register_crtc_funcs(struct drm_crtc *crtc,
 649                                  const struct rockchip_crtc_funcs *crtc_funcs)
 650 {
 651         int pipe = drm_crtc_index(crtc);
 652         struct rockchip_drm_private *priv = crtc->dev->dev_private;
 653
 654         if (pipe > ROCKCHIP_MAX_CRTC)
 655                 return -EINVAL;
 656
 657         priv->crtc_funcs[pipe] = crtc_funcs;
 658
 659         return 0;
 660 }
 661
 662 void rockchip_unregister_crtc_funcs(struct drm_crtc *crtc)
 663 {
 664         int pipe = drm_crtc_index(crtc);
 665         struct rockchip_drm_private *priv = crtc->dev->dev_private;
 666
 667         if (pipe > ROCKCHIP_MAX_CRTC)
 668                 return;
 669
 670         priv->crtc_funcs[pipe] = NULL;
 671 }
 672
 673 static struct drm_crtc *rockchip_crtc_from_pipe(struct drm_device *drm,
 674                                                 int pipe)
 675 {
 676         struct drm_crtc *crtc;
 677         int i = 0;
 678
 679         list_for_each_entry(crtc, &drm->mode_config.crtc_list, head)
 680                 if (i++ == pipe)
 681                         return crtc;
 682
 683         return NULL;
 684 }
 685
 686 static int rockchip_drm_crtc_enable_vblank(struct drm_device *dev,
 687                                            unsigned int pipe)
 688 {
 689         struct rockchip_drm_private *priv = dev->dev_private;
 690         struct drm_crtc *crtc = rockchip_crtc_from_pipe(dev, pipe);
 691
 692         if (crtc && priv->crtc_funcs[pipe] &&
 693             priv->crtc_funcs[pipe]->enable_vblank)
 694                 return priv->crtc_funcs[pipe]->enable_vblank(crtc);
 695
 696         return 0;
 697 }
 698
 699 static void rockchip_drm_crtc_disable_vblank(struct drm_device *dev,
 700                                              unsigned int pipe)
 701 {
 702         struct rockchip_drm_private *priv = dev->dev_private;
 703         struct drm_crtc *crtc = rockchip_crtc_from_pipe(dev, pipe);
 704
 705         if (crtc && priv->crtc_funcs[pipe] &&
 706             priv->crtc_funcs[pipe]->enable_vblank)
 707                 priv->crtc_funcs[pipe]->disable_vblank(crtc);
 708 }
 709
 710 static int rockchip_drm_init_iommu(struct drm_device *drm_dev)
 711 {
 712         struct rockchip_drm_private *private = drm_dev->dev_private;
 713         struct iommu_domain_geometry *geometry;
 714         u64 start, end;
 715
 716         if (!is_support_iommu)
 717                 return 0;
 718
 719         private->domain = iommu_domain_alloc(&platform_bus_type);
 720         if (!private->domain)
 721                 return -ENOMEM;
 722
 723         geometry = &private->domain->geometry;
 724         start = geometry->aperture_start;
 725         end = geometry->aperture_end;
 726
 727         DRM_DEBUG("IOMMU context initialized (aperture: %#llx-%#llx)\n",
 728                   start, end);
 729         drm_mm_init(&private->mm, start, end - start + 1);
 730
 731         return 0;
 732 }
 733
 734 static void rockchip_iommu_cleanup(struct drm_device *drm_dev)
 735 {
 736         struct rockchip_drm_private *private = drm_dev->dev_private;
 737
 738         if (!is_support_iommu)
 739                 return;
 740
 741         drm_mm_takedown(&private->mm);
 742         iommu_domain_free(private->domain);
 743 }
 744
 745 static int rockchip_drm_load(struct drm_device *drm_dev, unsigned long flags)
 746 {
 747         struct rockchip_drm_private *private;
 748         struct device *dev = drm_dev->dev;
 749         struct drm_connector *connector;
 750         int ret;
 751
 752         private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL);
 753         if (!private)
 754                 return -ENOMEM;
 755
 756         mutex_init(&private->commit.lock);
 757         INIT_WORK(&private->commit.work, rockchip_drm_atomic_work);
 758
 759         drm_dev->dev_private = private;
 760
 761 #ifdef CONFIG_DRM_DMA_SYNC
 762         private->cpu_fence_context = fence_context_alloc(1);
 763         atomic_set(&private->cpu_fence_seqno, 0);
 764 #endif
 765
 766         drm_mode_config_init(drm_dev);
 767
 768         rockchip_drm_mode_config_init(drm_dev);
 769
 770         ret = rockchip_drm_init_iommu(drm_dev);
 771         if (ret)
 772                 goto err_config_cleanup;
 773
 774         /* Try to bind all sub drivers. */
 775         ret = component_bind_all(dev, drm_dev);
 776         if (ret)
 777                 goto err_iommu_cleanup;
 778
 779         /*
 780          * All components are now added, we can publish the connector sysfs
 781          * entries to userspace.  This will generate hotplug events and so
 782          * userspace will expect to be able to access DRM at this point.
 783          */
 784         list_for_each_entry(connector, &drm_dev->mode_config.connector_list,
 785                         head) {
 786                 ret = drm_connector_register(connector);
 787                 if (ret) {
 788                         dev_err(drm_dev->dev,
 789                                 "[CONNECTOR:%d:%s] drm_connector_register failed: %d\n",
 790                                 connector->base.id,
 791                                 connector->name, ret);
 792                         goto err_unbind;
 793                 }
 794         }
 795
 796         /* init kms poll for handling hpd */
 797         drm_kms_helper_poll_init(drm_dev);
 798
 799         /*
 800          * enable drm irq mode.
 801          * - with irq_enabled = true, we can use the vblank feature.
 802          */
 803         drm_dev->irq_enabled = true;
 804
 805         ret = drm_vblank_init(drm_dev, ROCKCHIP_MAX_CRTC);
 806         if (ret)
 807                 goto err_kms_helper_poll_fini;
 808
 809         /*
 810          * with vblank_disable_allowed = true, vblank interrupt will be disabled
 811          * by drm timer once a current process gives up ownership of
 812          * vblank event.(after drm_vblank_put function is called)
 813          */
 814         drm_dev->vblank_disable_allowed = true;
 815
 816         drm_mode_config_reset(drm_dev);
 817
 818         show_loader_logo(drm_dev);
 819
 820         ret = rockchip_drm_fbdev_init(drm_dev);
 821         if (ret)
 822                 goto err_vblank_cleanup;
 823
 824         drm_dev->mode_config.allow_fb_modifiers = true;
 825
 826         return 0;
 827 err_vblank_cleanup:
 828         drm_vblank_cleanup(drm_dev);
 829 err_kms_helper_poll_fini:
 830         drm_kms_helper_poll_fini(drm_dev);
 831 err_unbind:
 832         component_unbind_all(dev, drm_dev);
 833 err_iommu_cleanup:
 834         rockchip_iommu_cleanup(drm_dev);
 835 err_config_cleanup:
 836         drm_mode_config_cleanup(drm_dev);
 837         drm_dev->dev_private = NULL;
 838         return ret;
 839 }
 840
 841 static int rockchip_drm_unload(struct drm_device *drm_dev)
 842 {
 843         struct device *dev = drm_dev->dev;
 844
 845         rockchip_drm_fbdev_fini(drm_dev);
 846         drm_vblank_cleanup(drm_dev);
 847         drm_kms_helper_poll_fini(drm_dev);
 848         component_unbind_all(dev, drm_dev);
 849         rockchip_iommu_cleanup(drm_dev);
 850         drm_mode_config_cleanup(drm_dev);
 851         drm_dev->dev_private = NULL;
 852
 853         return 0;
 854 }
 855
 856 static void rockchip_drm_crtc_cancel_pending_vblank(struct drm_crtc *crtc,
 857                                                     struct drm_file *file_priv)
 858 {
 859         struct rockchip_drm_private *priv = crtc->dev->dev_private;
 860         int pipe = drm_crtc_index(crtc);
 861
 862         if (pipe < ROCKCHIP_MAX_CRTC &&
 863             priv->crtc_funcs[pipe] &&
 864             priv->crtc_funcs[pipe]->cancel_pending_vblank)
 865                 priv->crtc_funcs[pipe]->cancel_pending_vblank(crtc, file_priv);
 866 }
 867
 868 int rockchip_drm_register_subdrv(struct drm_rockchip_subdrv *subdrv)
 869 {
 870         if (!subdrv)
 871                 return -EINVAL;
 872
 873         mutex_lock(&subdrv_list_mutex);
 874         list_add_tail(&subdrv->list, &rockchip_drm_subdrv_list);
 875         mutex_unlock(&subdrv_list_mutex);
 876
 877         return 0;
 878 }
 879 EXPORT_SYMBOL_GPL(rockchip_drm_register_subdrv);
 880
 881 int rockchip_drm_unregister_subdrv(struct drm_rockchip_subdrv *subdrv)
 882 {
 883         if (!subdrv)
 884                 return -EINVAL;
 885
 886         mutex_lock(&subdrv_list_mutex);
 887         list_del(&subdrv->list);
 888         mutex_unlock(&subdrv_list_mutex);
 889
 890         return 0;
 891 }
 892 EXPORT_SYMBOL_GPL(rockchip_drm_unregister_subdrv);
 893
 894 static int rockchip_drm_open(struct drm_device *dev, struct drm_file *file)
 895 {
 896         struct rockchip_drm_file_private *file_priv;
 897         struct drm_rockchip_subdrv *subdrv;
 898         int ret = 0;
 899
 900         file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
 901         if (!file_priv)
 902                 return -ENOMEM;
 903         INIT_LIST_HEAD(&file_priv->gem_cpu_acquire_list);
 904
 905         file->driver_priv = file_priv;
 906
 907         mutex_lock(&subdrv_list_mutex);
 908         list_for_each_entry(subdrv, &rockchip_drm_subdrv_list, list) {
 909                 ret = subdrv->open(dev, subdrv->dev, file);
 910                 if (ret) {
 911                         mutex_unlock(&subdrv_list_mutex);
 912                         goto err_free_file_priv;
 913                 }
 914         }
 915         mutex_unlock(&subdrv_list_mutex);
 916
 917         return 0;
 918
 919 err_free_file_priv:
 920         kfree(file_priv);
 921         file_priv = NULL;
 922
 923         return ret;
 924 }
 925
 926 static void rockchip_drm_preclose(struct drm_device *dev,
 927                                   struct drm_file *file_priv)
 928 {
 929         struct rockchip_drm_file_private *file_private = file_priv->driver_priv;
 930         struct rockchip_gem_object_node *cur, *d;
 931         struct drm_rockchip_subdrv *subdrv;
 932         struct drm_crtc *crtc;
 933
 934         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
 935                 rockchip_drm_crtc_cancel_pending_vblank(crtc, file_priv);
 936
 937         mutex_lock(&dev->struct_mutex);
 938         list_for_each_entry_safe(cur, d,
 939                         &file_private->gem_cpu_acquire_list, list) {
 940 #ifdef CONFIG_DRM_DMA_SYNC
 941                 BUG_ON(!cur->rockchip_gem_obj->acquire_fence);
 942                 drm_fence_signal_and_put(&cur->rockchip_gem_obj->acquire_fence);
 943 #endif
 944                 drm_gem_object_unreference(&cur->rockchip_gem_obj->base);
 945                 kfree(cur);
 946         }
 947         /* since we are deleting the whole list, just initialize the header
 948          * instead of calling list_del for every element
 949          */
 950         INIT_LIST_HEAD(&file_private->gem_cpu_acquire_list);
 951         mutex_unlock(&dev->struct_mutex);
 952
 953         mutex_lock(&subdrv_list_mutex);
 954         list_for_each_entry(subdrv, &rockchip_drm_subdrv_list, list)
 955                 subdrv->close(dev, subdrv->dev, file_priv);
 956         mutex_unlock(&subdrv_list_mutex);
 957 }
 958
 959 static void rockchip_drm_postclose(struct drm_device *dev, struct drm_file *file)
 960 {
 961         kfree(file->driver_priv);
 962         file->driver_priv = NULL;
 963 }
 964
 965 void rockchip_drm_lastclose(struct drm_device *dev)
 966 {
 967         struct rockchip_drm_private *priv = dev->dev_private;
 968
 969         drm_fb_helper_restore_fbdev_mode_unlocked(priv->fbdev_helper);
 970 }
 971
 972 static const struct drm_ioctl_desc rockchip_ioctls[] = {
 973         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_CREATE, rockchip_gem_create_ioctl,
 974                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
 975         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_MAP_OFFSET,
 976                           rockchip_gem_map_offset_ioctl,
 977                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
 978         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_CPU_ACQUIRE,
 979                           rockchip_gem_cpu_acquire_ioctl,
 980                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
 981         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_CPU_RELEASE,
 982                           rockchip_gem_cpu_release_ioctl,
 983                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
 984         DRM_IOCTL_DEF_DRV(ROCKCHIP_RGA_GET_VER, rockchip_rga_get_ver_ioctl,
 985                           DRM_AUTH | DRM_RENDER_ALLOW),
 986         DRM_IOCTL_DEF_DRV(ROCKCHIP_RGA_SET_CMDLIST,
 987                           rockchip_rga_set_cmdlist_ioctl,
 988                           DRM_AUTH | DRM_RENDER_ALLOW),
 989         DRM_IOCTL_DEF_DRV(ROCKCHIP_RGA_EXEC, rockchip_rga_exec_ioctl,
 990                           DRM_AUTH | DRM_RENDER_ALLOW),
 991 };
 992
 993 static const struct file_operations rockchip_drm_driver_fops = {
 994         .owner = THIS_MODULE,
 995         .open = drm_open,
 996         .mmap = rockchip_gem_mmap,
 997         .poll = drm_poll,
 998         .read = drm_read,
 999         .unlocked_ioctl = drm_ioctl,
1000 #ifdef CONFIG_COMPAT
1001         .compat_ioctl = drm_compat_ioctl,
1002 #endif
1003         .release = drm_release,
1004 };
1005
1006 const struct vm_operations_struct rockchip_drm_vm_ops = {
1007         .open = drm_gem_vm_open,
1008         .close = drm_gem_vm_close,
1009 };
1010
1011 static struct drm_driver rockchip_drm_driver = {
1012         .driver_features        = DRIVER_MODESET | DRIVER_GEM |
1013                                   DRIVER_PRIME | DRIVER_ATOMIC |
1014                                   DRIVER_RENDER,
1015         .load                   = rockchip_drm_load,
1016         .unload                 = rockchip_drm_unload,
1017         .preclose               = rockchip_drm_preclose,
1018         .lastclose              = rockchip_drm_lastclose,
1019         .get_vblank_counter     = drm_vblank_no_hw_counter,
1020         .open                   = rockchip_drm_open,
1021         .postclose              = rockchip_drm_postclose,
1022         .enable_vblank          = rockchip_drm_crtc_enable_vblank,
1023         .disable_vblank         = rockchip_drm_crtc_disable_vblank,
1024         .gem_vm_ops             = &rockchip_drm_vm_ops,
1025         .gem_free_object        = rockchip_gem_free_object,
1026         .dumb_create            = rockchip_gem_dumb_create,
1027         .dumb_map_offset        = rockchip_gem_dumb_map_offset,
1028         .dumb_destroy           = drm_gem_dumb_destroy,
1029         .prime_handle_to_fd     = drm_gem_prime_handle_to_fd,
1030         .prime_fd_to_handle     = drm_gem_prime_fd_to_handle,
1031         .gem_prime_import       = drm_gem_prime_import,
1032         .gem_prime_export       = drm_gem_prime_export,
1033         .gem_prime_get_sg_table = rockchip_gem_prime_get_sg_table,
1034         .gem_prime_import_sg_table      = rockchip_gem_prime_import_sg_table,
1035         .gem_prime_vmap         = rockchip_gem_prime_vmap,
1036         .gem_prime_vunmap       = rockchip_gem_prime_vunmap,
1037         .gem_prime_mmap         = rockchip_gem_mmap_buf,
1038         .ioctls                 = rockchip_ioctls,
1039         .num_ioctls             = ARRAY_SIZE(rockchip_ioctls),
1040         .fops                   = &rockchip_drm_driver_fops,
1041         .name   = DRIVER_NAME,
1042         .desc   = DRIVER_DESC,
1043         .date   = DRIVER_DATE,
1044         .major  = DRIVER_MAJOR,
1045         .minor  = DRIVER_MINOR,
1046 };
1047
1048 #ifdef CONFIG_PM_SLEEP
1049 void rockchip_drm_fb_suspend(struct drm_device *drm)
1050 {
1051         struct rockchip_drm_private *priv = drm->dev_private;
1052
1053         console_lock();
1054         drm_fb_helper_set_suspend(priv->fbdev_helper, 1);
1055         console_unlock();
1056 }
1057
1058 void rockchip_drm_fb_resume(struct drm_device *drm)
1059 {
1060         struct rockchip_drm_private *priv = drm->dev_private;
1061
1062         console_lock();
1063         drm_fb_helper_set_suspend(priv->fbdev_helper, 0);
1064         console_unlock();
1065 }
1066
1067 static int rockchip_drm_sys_suspend(struct device *dev)
1068 {
1069         struct drm_device *drm = dev_get_drvdata(dev);
1070         struct rockchip_drm_private *priv = drm->dev_private;
1071
1072         drm_kms_helper_poll_disable(drm);
1073         rockchip_drm_fb_suspend(drm);
1074
1075         priv->state = drm_atomic_helper_suspend(drm);
1076         if (IS_ERR(priv->state)) {
1077                 rockchip_drm_fb_resume(drm);
1078                 drm_kms_helper_poll_enable(drm);
1079                 return PTR_ERR(priv->state);
1080         }
1081
1082         return 0;
1083 }
1084
1085 static int rockchip_drm_sys_resume(struct device *dev)
1086 {
1087         struct drm_device *drm = dev_get_drvdata(dev);
1088         struct rockchip_drm_private *priv = drm->dev_private;
1089
1090         drm_atomic_helper_resume(drm, priv->state);
1091         rockchip_drm_fb_resume(drm);
1092         drm_kms_helper_poll_enable(drm);
1093
1094         return 0;
1095 }
1096 #endif
1097
1098 static const struct dev_pm_ops rockchip_drm_pm_ops = {
1099         SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend,
1100                                 rockchip_drm_sys_resume)
1101 };
1102
1103 static int compare_of(struct device *dev, void *data)
1104 {
1105         struct device_node *np = data;
1106
1107         return dev->of_node == np;
1108 }
1109
1110 static void rockchip_add_endpoints(struct device *dev,
1111                                    struct component_match **match,
1112                                    struct device_node *port)
1113 {
1114         struct device_node *ep, *remote;
1115
1116         for_each_child_of_node(port, ep) {
1117                 remote = of_graph_get_remote_port_parent(ep);
1118                 if (!remote || !of_device_is_available(remote)) {
1119                         of_node_put(remote);
1120                         continue;
1121                 } else if (!of_device_is_available(remote->parent)) {
1122                         dev_warn(dev, "parent device of %s is not available\n",
1123                                  remote->full_name);
1124                         of_node_put(remote);
1125                         continue;
1126                 }
1127
1128                 component_match_add(dev, match, compare_of, remote);
1129                 of_node_put(remote);
1130         }
1131 }
1132
1133 static int rockchip_drm_bind(struct device *dev)
1134 {
1135         struct drm_device *drm;
1136         int ret;
1137
1138         drm = drm_dev_alloc(&rockchip_drm_driver, dev);
1139         if (!drm)
1140                 return -ENOMEM;
1141
1142         ret = drm_dev_set_unique(drm, "%s", dev_name(dev));
1143         if (ret)
1144                 goto err_free;
1145
1146         ret = drm_dev_register(drm, 0);
1147         if (ret)
1148                 goto err_free;
1149
1150         dev_set_drvdata(dev, drm);
1151
1152         return 0;
1153
1154 err_free:
1155         drm_dev_unref(drm);
1156         return ret;
1157 }
1158
1159 static void rockchip_drm_unbind(struct device *dev)
1160 {
1161         struct drm_device *drm = dev_get_drvdata(dev);
1162
1163         drm_dev_unregister(drm);
1164         drm_dev_unref(drm);
1165         dev_set_drvdata(dev, NULL);
1166 }
1167
1168 static const struct component_master_ops rockchip_drm_ops = {
1169         .bind = rockchip_drm_bind,
1170         .unbind = rockchip_drm_unbind,
1171 };
1172
1173 static int rockchip_drm_platform_probe(struct platform_device *pdev)
1174 {
1175         struct device *dev = &pdev->dev;
1176         struct component_match *match = NULL;
1177         struct device_node *np = dev->of_node;
1178         struct device_node *port;
1179         int i;
1180
1181         if (!np)
1182                 return -ENODEV;
1183         /*
1184          * Bind the crtc ports first, so that
1185          * drm_of_find_possible_crtcs called from encoder .bind callbacks
1186          * works as expected.
1187          */
1188         for (i = 0;; i++) {
1189                 struct device_node *iommu;
1190
1191                 port = of_parse_phandle(np, "ports", i);
1192                 if (!port)
1193                         break;
1194
1195                 if (!of_device_is_available(port->parent)) {
1196                         of_node_put(port);
1197                         continue;
1198                 }
1199
1200                 iommu = of_parse_phandle(port->parent, "iommus", 0);
1201                 if (!iommu || !of_device_is_available(iommu->parent)) {
1202                         dev_dbg(dev, "no iommu attached for %s, using non-iommu buffers\n",
1203                                 port->parent->full_name);
1204                         /*
1205                          * if there is a crtc not support iommu, force set all
1206                          * crtc use non-iommu buffer.
1207                          */
1208                         is_support_iommu = false;
1209                 }
1210
1211                 component_match_add(dev, &match, compare_of, port->parent);
1212                 of_node_put(port);
1213         }
1214
1215         if (i == 0) {
1216                 dev_err(dev, "missing 'ports' property\n");
1217                 return -ENODEV;
1218         }
1219
1220         if (!match) {
1221                 dev_err(dev, "No available vop found for display-subsystem.\n");
1222                 return -ENODEV;
1223         }
1224         /*
1225          * For each bound crtc, bind the encoders attached to its
1226          * remote endpoint.
1227          */
1228         for (i = 0;; i++) {
1229                 port = of_parse_phandle(np, "ports", i);
1230                 if (!port)
1231                         break;
1232
1233                 if (!of_device_is_available(port->parent)) {
1234                         of_node_put(port);
1235                         continue;
1236                 }
1237
1238                 rockchip_add_endpoints(dev, &match, port);
1239                 of_node_put(port);
1240         }
1241
1242         return component_master_add_with_match(dev, &rockchip_drm_ops, match);
1243 }
1244
1245 static int rockchip_drm_platform_remove(struct platform_device *pdev)
1246 {
1247         component_master_del(&pdev->dev, &rockchip_drm_ops);
1248
1249         return 0;
1250 }
1251
1252 static const struct of_device_id rockchip_drm_dt_ids[] = {
1253         { .compatible = "rockchip,display-subsystem", },
1254         { /* sentinel */ },
1255 };
1256 MODULE_DEVICE_TABLE(of, rockchip_drm_dt_ids);
1257
1258 static struct platform_driver rockchip_drm_platform_driver = {
1259         .probe = rockchip_drm_platform_probe,
1260         .remove = rockchip_drm_platform_remove,
1261         .driver = {
1262                 .name = "rockchip-drm",
1263                 .of_match_table = rockchip_drm_dt_ids,
1264                 .pm = &rockchip_drm_pm_ops,
1265         },
1266 };
1267
1268 module_platform_driver(rockchip_drm_platform_driver);
1269
1270 MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>");
1271 MODULE_DESCRIPTION("ROCKCHIP DRM Driver");
1272 MODULE_LICENSE("GPL v2");