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/clk.h>
  31 #include <linux/clk-provider.h>
  32 #include <linux/component.h>
  33 #include <linux/fence.h>
  34 #include <linux/console.h>
  35 #include <linux/iommu.h>
  36
  37 #include <drm/rockchip_drm.h>
  38
  39 #include "rockchip_drm_drv.h"
  40 #include "rockchip_drm_fb.h"
  41 #include "rockchip_drm_fbdev.h"
  42 #include "rockchip_drm_gem.h"
  43 #include "rockchip_drm_rga.h"
  44
  45 #define DRIVER_NAME     "rockchip"
  46 #define DRIVER_DESC     "RockChip Soc DRM"
  47 #define DRIVER_DATE     "20140818"
  48 #define DRIVER_MAJOR    1
  49 #define DRIVER_MINOR    0
  50
  51 static bool is_support_iommu = true;
  52
  53 static LIST_HEAD(rockchip_drm_subdrv_list);
  54 static DEFINE_MUTEX(subdrv_list_mutex);
  55 static struct drm_driver rockchip_drm_driver;
  56
  57 struct rockchip_drm_mode_set {
  58         struct list_head head;
  59         struct drm_framebuffer *fb;
  60         struct drm_connector *connector;
  61         struct drm_crtc *crtc;
  62         struct drm_display_mode *mode;
  63         int hdisplay;
  64         int vdisplay;
  65         int vrefresh;
  66
  67         bool mode_changed;
  68         bool ymirror;
  69         int ratio;
  70 };
  71
  72 #ifndef MODULE
  73 static struct drm_crtc *find_crtc_by_node(struct drm_device *drm_dev,
  74                                           struct device_node *node)
  75 {
  76         struct device_node *np_crtc;
  77         struct drm_crtc *crtc;
  78
  79         np_crtc = of_get_parent(node);
  80         if (!np_crtc || !of_device_is_available(np_crtc))
  81                 return NULL;
  82
  83         drm_for_each_crtc(crtc, drm_dev) {
  84                 if (crtc->port == np_crtc)
  85                         return crtc;
  86         }
  87
  88         return NULL;
  89 }
  90
  91 static struct drm_connector *find_connector_by_node(struct drm_device *drm_dev,
  92                                                     struct device_node *node)
  93 {
  94         struct device_node *np_connector;
  95         struct drm_connector *connector;
  96
  97         np_connector = of_graph_get_remote_port_parent(node);
  98         if (!np_connector || !of_device_is_available(np_connector))
  99                 return NULL;
 100
 101         drm_for_each_connector(connector, drm_dev) {
 102                 if (connector->port == np_connector)
 103                         return connector;
 104         }
 105
 106         return NULL;
 107 }
 108
 109 void rockchip_free_loader_memory(struct drm_device *drm)
 110 {
 111         struct rockchip_drm_private *private = drm->dev_private;
 112         struct rockchip_logo *logo;
 113         void *start, *end;
 114
 115         if (!private || !private->logo || --private->logo->count)
 116                 return;
 117
 118         logo = private->logo;
 119         start = phys_to_virt(logo->start);
 120         end = phys_to_virt(logo->start + logo->size);
 121
 122         if (private->domain) {
 123                 iommu_unmap(private->domain, logo->dma_addr,
 124                             logo->iommu_map_size);
 125                 drm_mm_remove_node(&logo->mm);
 126         } else {
 127                 dma_unmap_sg(drm->dev, logo->sgt->sgl,
 128                              logo->sgt->nents, DMA_TO_DEVICE);
 129         }
 130         sg_free_table(logo->sgt);
 131         memblock_free(logo->start, logo->size);
 132         free_reserved_area(start, end, -1, "drm_logo");
 133         kfree(logo);
 134         private->logo = NULL;
 135 }
 136
 137 static int init_loader_memory(struct drm_device *drm_dev)
 138 {
 139         struct rockchip_drm_private *private = drm_dev->dev_private;
 140         struct rockchip_logo *logo;
 141         struct device_node *np = drm_dev->dev->of_node;
 142         struct device_node *node;
 143         unsigned long nr_pages;
 144         struct page **pages;
 145         struct sg_table *sgt;
 146         phys_addr_t start, size;
 147         struct resource res;
 148         int i, ret;
 149
 150         node = of_parse_phandle(np, "memory-region", 0);
 151         if (!node)
 152                 return -ENOMEM;
 153
 154         ret = of_address_to_resource(node, 0, &res);
 155         if (ret)
 156                 return ret;
 157         start = res.start;
 158         size = resource_size(&res);
 159         if (!size)
 160                 return -ENOMEM;
 161
 162         logo = kmalloc(sizeof(*logo), GFP_KERNEL);
 163         if (!logo)
 164                 return -ENOMEM;
 165
 166         nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
 167         pages = kmalloc_array(nr_pages, sizeof(*pages), GFP_KERNEL);
 168         if (!pages)
 169                 goto err_free_logo;
 170         i = 0;
 171         while (i < nr_pages) {
 172                 pages[i] = phys_to_page(start);
 173                 start += PAGE_SIZE;
 174                 i++;
 175         }
 176         sgt = drm_prime_pages_to_sg(pages, nr_pages);
 177         if (IS_ERR(sgt)) {
 178                 ret = PTR_ERR(sgt);
 179                 goto err_free_pages;
 180         }
 181
 182         if (private->domain) {
 183                 memset(&logo->mm, 0, sizeof(logo->mm));
 184                 ret = drm_mm_insert_node_generic(&private->mm, &logo->mm,
 185                                                  size, PAGE_SIZE,
 186                                                  0, 0, 0);
 187                 if (ret < 0) {
 188                         DRM_ERROR("out of I/O virtual memory: %d\n", ret);
 189                         goto err_free_pages;
 190                 }
 191
 192                 logo->dma_addr = logo->mm.start;
 193
 194                 logo->iommu_map_size = iommu_map_sg(private->domain,
 195                                                     logo->dma_addr, sgt->sgl,
 196                                                     sgt->nents, IOMMU_READ);
 197                 if (logo->iommu_map_size < size) {
 198                         DRM_ERROR("failed to map buffer");
 199                         ret = -ENOMEM;
 200                         goto err_remove_node;
 201                 }
 202         } else {
 203                 dma_map_sg(drm_dev->dev, sgt->sgl, sgt->nents, DMA_TO_DEVICE);
 204                 logo->dma_addr = sg_dma_address(sgt->sgl);
 205         }
 206
 207         logo->sgt = sgt;
 208         logo->start = res.start;
 209         logo->size = size;
 210         logo->count = 1;
 211         private->logo = logo;
 212
 213         return 0;
 214
 215 err_remove_node:
 216         drm_mm_remove_node(&logo->mm);
 217 err_free_pages:
 218         kfree(pages);
 219 err_free_logo:
 220         kfree(logo);
 221
 222         return ret;
 223 }
 224
 225 static struct drm_framebuffer *
 226 get_framebuffer_by_node(struct drm_device *drm_dev, struct device_node *node)
 227 {
 228         struct rockchip_drm_private *private = drm_dev->dev_private;
 229         struct drm_mode_fb_cmd2 mode_cmd = { 0 };
 230         u32 val;
 231         int bpp;
 232
 233         if (WARN_ON(!private->logo))
 234                 return NULL;
 235
 236         if (of_property_read_u32(node, "logo,offset", &val)) {
 237                 pr_err("%s: failed to get logo,offset\n", __func__);
 238                 return NULL;
 239         }
 240         mode_cmd.offsets[0] = val;
 241
 242         if (of_property_read_u32(node, "logo,width", &val)) {
 243                 pr_err("%s: failed to get logo,width\n", __func__);
 244                 return NULL;
 245         }
 246         mode_cmd.width = val;
 247
 248         if (of_property_read_u32(node, "logo,height", &val)) {
 249                 pr_err("%s: failed to get logo,height\n", __func__);
 250                 return NULL;
 251         }
 252         mode_cmd.height = val;
 253
 254         if (of_property_read_u32(node, "logo,bpp", &val)) {
 255                 pr_err("%s: failed to get logo,bpp\n", __func__);
 256                 return NULL;
 257         }
 258         bpp = val;
 259
 260         mode_cmd.pitches[0] = ALIGN(mode_cmd.width * bpp, 32) / 8;
 261
 262         switch (bpp) {
 263         case 16:
 264                 mode_cmd.pixel_format = DRM_FORMAT_BGR565;
 265                 break;
 266         case 24:
 267                 mode_cmd.pixel_format = DRM_FORMAT_BGR888;
 268                 break;
 269         case 32:
 270                 mode_cmd.pixel_format = DRM_FORMAT_XRGB8888;
 271                 break;
 272         default:
 273                 pr_err("%s: unsupport to logo bpp %d\n", __func__, bpp);
 274                 return NULL;
 275         }
 276
 277         return rockchip_fb_alloc(drm_dev, &mode_cmd, NULL, private->logo, 1);
 278 }
 279
 280 static struct rockchip_drm_mode_set *
 281 of_parse_display_resource(struct drm_device *drm_dev, struct device_node *route)
 282 {
 283         struct rockchip_drm_mode_set *set;
 284         struct device_node *connect;
 285         struct drm_framebuffer *fb;
 286         struct drm_connector *connector;
 287         struct drm_crtc *crtc;
 288         const char *string;
 289         u32 val;
 290
 291         connect = of_parse_phandle(route, "connect", 0);
 292         if (!connect)
 293                 return NULL;
 294
 295         fb = get_framebuffer_by_node(drm_dev, route);
 296         if (IS_ERR_OR_NULL(fb))
 297                 return NULL;
 298
 299         crtc = find_crtc_by_node(drm_dev, connect);
 300         connector = find_connector_by_node(drm_dev, connect);
 301         if (!crtc || !connector) {
 302                 dev_warn(drm_dev->dev,
 303                          "No available crtc or connector for display");
 304                 drm_framebuffer_unreference(fb);
 305                 return NULL;
 306         }
 307
 308         set = kzalloc(sizeof(*set), GFP_KERNEL);
 309         if (!set)
 310                 return NULL;
 311
 312         if (!of_property_read_u32(route, "video,hdisplay", &val))
 313                 set->hdisplay = val;
 314
 315         if (!of_property_read_u32(route, "video,vdisplay", &val))
 316                 set->vdisplay = val;
 317
 318         if (!of_property_read_u32(route, "video,vrefresh", &val))
 319                 set->vrefresh = val;
 320
 321         if (!of_property_read_u32(route, "logo,ymirror", &val))
 322                 set->ymirror = val;
 323
 324         set->ratio = 1;
 325         if (!of_property_read_string(route, "logo,mode", &string) &&
 326             !strcmp(string, "fullscreen"))
 327                         set->ratio = 0;
 328
 329         set->fb = fb;
 330         set->crtc = crtc;
 331         set->connector = connector;
 332
 333         return set;
 334 }
 335
 336 int setup_initial_state(struct drm_device *drm_dev,
 337                         struct drm_atomic_state *state,
 338                         struct rockchip_drm_mode_set *set)
 339 {
 340         struct drm_connector *connector = set->connector;
 341         struct drm_crtc *crtc = set->crtc;
 342         struct drm_crtc_state *crtc_state;
 343         struct drm_connector_state *conn_state;
 344         struct drm_plane_state *primary_state;
 345         struct drm_display_mode *mode = NULL;
 346         const struct drm_connector_helper_funcs *funcs;
 347         const struct drm_encoder_helper_funcs *encoder_funcs;
 348         bool is_crtc_enabled = true;
 349         int hdisplay, vdisplay;
 350         int fb_width, fb_height;
 351         int found = 0, match = 0;
 352         int num_modes;
 353         int ret = 0;
 354
 355         if (!set->hdisplay || !set->vdisplay || !set->vrefresh)
 356                 is_crtc_enabled = false;
 357
 358         conn_state = drm_atomic_get_connector_state(state, connector);
 359         if (IS_ERR(conn_state))
 360                 return PTR_ERR(conn_state);
 361
 362         funcs = connector->helper_private;
 363         conn_state->best_encoder = funcs->best_encoder(connector);
 364         if (funcs->loader_protect)
 365                 funcs->loader_protect(connector, true);
 366         connector->loader_protect = true;
 367         encoder_funcs = conn_state->best_encoder->helper_private;
 368         if (encoder_funcs->loader_protect)
 369                 encoder_funcs->loader_protect(conn_state->best_encoder, true);
 370         conn_state->best_encoder->loader_protect = true;
 371         num_modes = connector->funcs->fill_modes(connector, 4096, 4096);
 372         if (!num_modes) {
 373                 dev_err(drm_dev->dev, "connector[%s] can't found any modes\n",
 374                         connector->name);
 375                 ret = -EINVAL;
 376                 goto error;
 377         }
 378
 379         list_for_each_entry(mode, &connector->modes, head) {
 380                 if (mode->hdisplay == set->hdisplay &&
 381                     mode->vdisplay == set->vdisplay &&
 382                     drm_mode_vrefresh(mode) == set->vrefresh) {
 383                         found = 1;
 384                         match = 1;
 385                         break;
 386                 }
 387         }
 388
 389         if (!found) {
 390                 list_for_each_entry(mode, &connector->modes, head) {
 391                         if (mode->type & DRM_MODE_TYPE_PREFERRED) {
 392                                 found = 1;
 393                                 break;
 394                         }
 395                 }
 396
 397                 if (!found) {
 398                         mode = list_first_entry_or_null(&connector->modes,
 399                                                         struct drm_display_mode,
 400                                                         head);
 401                         if (!mode) {
 402                                 pr_err("failed to find available modes\n");
 403                                 ret = -EINVAL;
 404                                 goto error;
 405                         }
 406                 }
 407         }
 408
 409         set->mode = mode;
 410         crtc_state = drm_atomic_get_crtc_state(state, crtc);
 411         if (IS_ERR(crtc_state)) {
 412                 ret = PTR_ERR(crtc_state);
 413                 goto error;
 414         }
 415
 416         drm_mode_copy(&crtc_state->adjusted_mode, mode);
 417         if (!match || !is_crtc_enabled) {
 418                 set->mode_changed = true;
 419         } else {
 420                 ret = drm_atomic_set_crtc_for_connector(conn_state, crtc);
 421                 if (ret)
 422                         goto error;
 423
 424                 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
 425                 if (ret)
 426                         goto error;
 427
 428                 crtc_state->active = true;
 429         }
 430
 431         if (!set->fb) {
 432                 ret = 0;
 433                 goto error;
 434         }
 435         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
 436         if (IS_ERR(primary_state)) {
 437                 ret = PTR_ERR(primary_state);
 438                 goto error;
 439         }
 440
 441         hdisplay = mode->hdisplay;
 442         vdisplay = mode->vdisplay;
 443         fb_width = set->fb->width;
 444         fb_height = set->fb->height;
 445
 446         primary_state->crtc = crtc;
 447         primary_state->src_x = 0;
 448         primary_state->src_y = 0;
 449         primary_state->src_w = fb_width << 16;
 450         primary_state->src_h = fb_height << 16;
 451         if (set->ratio) {
 452                 if (set->fb->width >= hdisplay) {
 453                         primary_state->crtc_x = 0;
 454                         primary_state->crtc_w = hdisplay;
 455                 } else {
 456                         primary_state->crtc_x = (hdisplay - fb_width) / 2;
 457                         primary_state->crtc_w = set->fb->width;
 458                 }
 459
 460                 if (set->fb->height >= vdisplay) {
 461                         primary_state->crtc_y = 0;
 462                         primary_state->crtc_h = vdisplay;
 463                 } else {
 464                         primary_state->crtc_y = (vdisplay - fb_height) / 2;
 465                         primary_state->crtc_h = fb_height;
 466                 }
 467         } else {
 468                 primary_state->crtc_x = 0;
 469                 primary_state->crtc_y = 0;
 470                 primary_state->crtc_w = hdisplay;
 471                 primary_state->crtc_h = vdisplay;
 472         }
 473
 474         return 0;
 475
 476 error:
 477         if (funcs->loader_protect)
 478                 funcs->loader_protect(connector, false);
 479         connector->loader_protect = false;
 480         if (encoder_funcs->loader_protect)
 481                 encoder_funcs->loader_protect(conn_state->best_encoder, false);
 482         conn_state->best_encoder->loader_protect = false;
 483         return ret;
 484 }
 485
 486 static int update_state(struct drm_device *drm_dev,
 487                         struct drm_atomic_state *state,
 488                         struct rockchip_drm_mode_set *set,
 489                         unsigned int *plane_mask)
 490 {
 491         struct rockchip_drm_private *priv = drm_dev->dev_private;
 492         struct drm_crtc *crtc = set->crtc;
 493         struct drm_connector *connector = set->connector;
 494         struct drm_display_mode *mode = set->mode;
 495         struct drm_plane_state *primary_state;
 496         struct drm_crtc_state *crtc_state;
 497         struct drm_connector_state *conn_state;
 498         int ret;
 499
 500         crtc_state = drm_atomic_get_crtc_state(state, crtc);
 501         if (IS_ERR(crtc_state))
 502                 return PTR_ERR(crtc_state);
 503         conn_state = drm_atomic_get_connector_state(state, connector);
 504         if (IS_ERR(conn_state))
 505                 return PTR_ERR(conn_state);
 506
 507         if (set->mode_changed) {
 508                 ret = drm_atomic_set_crtc_for_connector(conn_state, crtc);
 509                 if (ret)
 510                         return ret;
 511
 512                 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
 513                 if (ret)
 514                         return ret;
 515
 516                 crtc_state->active = true;
 517         } else {
 518                 const struct drm_encoder_helper_funcs *encoder_helper_funcs;
 519                 const struct drm_connector_helper_funcs *connector_helper_funcs;
 520                 struct drm_encoder *encoder;
 521                 int pipe = drm_crtc_index(crtc);
 522
 523                 connector_helper_funcs = connector->helper_private;
 524                 if (!priv->crtc_funcs[pipe] ||
 525                     !priv->crtc_funcs[pipe]->loader_protect ||
 526                     !connector_helper_funcs ||
 527                     !connector_helper_funcs->best_encoder)
 528                         return -ENXIO;
 529                 encoder = connector_helper_funcs->best_encoder(connector);
 530                 if (!encoder)
 531                         return -ENXIO;
 532                 encoder_helper_funcs = encoder->helper_private;
 533                 if (!encoder_helper_funcs->atomic_check)
 534                         return -ENXIO;
 535                 ret = encoder_helper_funcs->atomic_check(encoder, crtc->state,
 536                                                          conn_state);
 537                 if (ret)
 538                         return ret;
 539                 if (encoder_helper_funcs->mode_set)
 540                         encoder_helper_funcs->mode_set(encoder, mode, mode);
 541                 priv->crtc_funcs[pipe]->loader_protect(crtc, true);
 542         }
 543
 544         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
 545         if (IS_ERR(primary_state))
 546                 return PTR_ERR(primary_state);
 547
 548         crtc_state->plane_mask = 1 << drm_plane_index(crtc->primary);
 549         *plane_mask |= crtc_state->plane_mask;
 550
 551         drm_atomic_set_fb_for_plane(primary_state, set->fb);
 552         drm_framebuffer_unreference(set->fb);
 553         ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
 554
 555         if (set->ymirror)
 556                 /*
 557                  * TODO:
 558                  * some vop maybe not support ymirror, but force use it now.
 559                  */
 560                 drm_atomic_plane_set_property(crtc->primary, primary_state,
 561                                               priv->logo_ymirror_prop,
 562                                               true);
 563
 564         return ret;
 565 }
 566
 567 static void show_loader_logo(struct drm_device *drm_dev)
 568 {
 569         struct drm_atomic_state *state, *old_state;
 570         struct device_node *np = drm_dev->dev->of_node;
 571         struct drm_mode_config *mode_config = &drm_dev->mode_config;
 572         struct device_node *root, *route;
 573         struct rockchip_drm_mode_set *set, *tmp;
 574         struct list_head mode_set_list;
 575         unsigned plane_mask = 0;
 576         int ret;
 577
 578         root = of_get_child_by_name(np, "route");
 579         if (!root) {
 580                 dev_warn(drm_dev->dev, "failed to parse display resources\n");
 581                 return;
 582         }
 583
 584         if (init_loader_memory(drm_dev)) {
 585                 dev_warn(drm_dev->dev, "failed to parse loader memory\n");
 586                 return;
 587         }
 588
 589         INIT_LIST_HEAD(&mode_set_list);
 590         drm_modeset_lock_all(drm_dev);
 591         state = drm_atomic_state_alloc(drm_dev);
 592         if (!state) {
 593                 dev_err(drm_dev->dev, "failed to alloc atomic state\n");
 594                 ret = -ENOMEM;
 595                 goto err_unlock;
 596         }
 597
 598         state->acquire_ctx = mode_config->acquire_ctx;
 599
 600         for_each_child_of_node(root, route) {
 601                 if (!of_device_is_available(route))
 602                         continue;
 603
 604                 set = of_parse_display_resource(drm_dev, route);
 605                 if (!set)
 606                         continue;
 607
 608                 if (setup_initial_state(drm_dev, state, set)) {
 609                         drm_framebuffer_unreference(set->fb);
 610                         kfree(set);
 611                         continue;
 612                 }
 613                 INIT_LIST_HEAD(&set->head);
 614                 list_add_tail(&set->head, &mode_set_list);
 615         }
 616
 617         if (list_empty(&mode_set_list)) {
 618                 dev_warn(drm_dev->dev, "can't not find any loader display\n");
 619                 ret = -ENXIO;
 620                 goto err_free_state;
 621         }
 622
 623         old_state = drm_atomic_helper_duplicate_state(drm_dev,
 624                                                       mode_config->acquire_ctx);
 625         if (IS_ERR(old_state)) {
 626                 dev_err(drm_dev->dev, "failed to duplicate atomic state\n");
 627                 ret = PTR_ERR_OR_ZERO(old_state);
 628                 goto err_free_state;
 629         }
 630
 631         /*
 632          * The state save initial devices status, swap the state into
 633          * drm deivces as old state, so if new state come, can compare
 634          * with this state to judge which status need to update.
 635          */
 636         drm_atomic_helper_swap_state(drm_dev, state);
 637         drm_atomic_state_free(state);
 638         state = drm_atomic_helper_duplicate_state(drm_dev,
 639                                                   mode_config->acquire_ctx);
 640         if (IS_ERR(state)) {
 641                 dev_err(drm_dev->dev, "failed to duplicate atomic state\n");
 642                 ret = PTR_ERR_OR_ZERO(state);
 643                 goto err_free_old_state;
 644         }
 645         state->acquire_ctx = mode_config->acquire_ctx;
 646         list_for_each_entry(set, &mode_set_list, head)
 647                 /*
 648                  * We don't want to see any fail on update_state.
 649                  */
 650                 WARN_ON(update_state(drm_dev, state, set, &plane_mask));
 651
 652         ret = drm_atomic_commit(state);
 653         drm_atomic_clean_old_fb(drm_dev, plane_mask, ret);
 654
 655         list_for_each_entry_safe(set, tmp, &mode_set_list, head) {
 656                 list_del(&set->head);
 657                 kfree(set);
 658         }
 659
 660         /*
 661          * Is possible get deadlock here?
 662          */
 663         WARN_ON(ret == -EDEADLK);
 664
 665         if (ret) {
 666                 /*
 667                  * restore display status if atomic commit failed.
 668                  */
 669                 drm_atomic_helper_swap_state(drm_dev, old_state);
 670                 goto err_free_old_state;
 671         }
 672
 673         rockchip_free_loader_memory(drm_dev);
 674         drm_atomic_state_free(old_state);
 675
 676         drm_modeset_unlock_all(drm_dev);
 677         return;
 678
 679 err_free_old_state:
 680         drm_atomic_state_free(old_state);
 681 err_free_state:
 682         drm_atomic_state_free(state);
 683 err_unlock:
 684         drm_modeset_unlock_all(drm_dev);
 685         if (ret)
 686                 dev_err(drm_dev->dev, "failed to show loader logo\n");
 687 }
 688
 689 static const char *const loader_protect_clocks[] __initconst = {
 690         "hclk_vio",
 691         "aclk_vio",
 692         "aclk_vio0",
 693 };
 694
 695 static struct clk **loader_clocks __initdata;
 696 static int __init rockchip_clocks_loader_protect(void)
 697 {
 698         int nclocks = ARRAY_SIZE(loader_protect_clocks);
 699         struct clk *clk;
 700         int i;
 701
 702         loader_clocks = kcalloc(nclocks, sizeof(void *), GFP_KERNEL);
 703         if (!loader_clocks)
 704                 return -ENOMEM;
 705
 706         for (i = 0; i < nclocks; i++) {
 707                 clk = __clk_lookup(loader_protect_clocks[i]);
 708
 709                 if (clk) {
 710                         loader_clocks[i] = clk;
 711                         clk_prepare_enable(clk);
 712                 }
 713         }
 714
 715         return 0;
 716 }
 717 fs_initcall(rockchip_clocks_loader_protect);
 718
 719 static int __init rockchip_clocks_loader_unprotect(void)
 720 {
 721         int i;
 722
 723         if (!loader_clocks)
 724                 return -ENODEV;
 725
 726         for (i = 0; i < ARRAY_SIZE(loader_protect_clocks); i++) {
 727                 struct clk *clk = loader_clocks[i];
 728
 729                 if (clk)
 730                         clk_disable_unprepare(clk);
 731         }
 732         kfree(loader_clocks);
 733
 734         return 0;
 735 }
 736 late_initcall_sync(rockchip_clocks_loader_unprotect);
 737 #endif
 738
 739 /*
 740  * Attach a (component) device to the shared drm dma mapping from master drm
 741  * device.  This is used by the VOPs to map GEM buffers to a common DMA
 742  * mapping.
 743  */
 744 int rockchip_drm_dma_attach_device(struct drm_device *drm_dev,
 745                                    struct device *dev)
 746 {
 747         struct rockchip_drm_private *private = drm_dev->dev_private;
 748         int ret;
 749
 750         if (!is_support_iommu)
 751                 return 0;
 752
 753         ret = iommu_attach_device(private->domain, dev);
 754         if (ret) {
 755                 dev_err(dev, "Failed to attach iommu device\n");
 756                 return ret;
 757         }
 758
 759         return 0;
 760 }
 761
 762 void rockchip_drm_dma_detach_device(struct drm_device *drm_dev,
 763                                     struct device *dev)
 764 {
 765         struct rockchip_drm_private *private = drm_dev->dev_private;
 766         struct iommu_domain *domain = private->domain;
 767
 768         if (!is_support_iommu)
 769                 return;
 770
 771         iommu_detach_device(domain, dev);
 772 }
 773
 774 int rockchip_register_crtc_funcs(struct drm_crtc *crtc,
 775                                  const struct rockchip_crtc_funcs *crtc_funcs)
 776 {
 777         int pipe = drm_crtc_index(crtc);
 778         struct rockchip_drm_private *priv = crtc->dev->dev_private;
 779
 780         if (pipe >= ROCKCHIP_MAX_CRTC)
 781                 return -EINVAL;
 782
 783         priv->crtc_funcs[pipe] = crtc_funcs;
 784
 785         return 0;
 786 }
 787
 788 void rockchip_unregister_crtc_funcs(struct drm_crtc *crtc)
 789 {
 790         int pipe = drm_crtc_index(crtc);
 791         struct rockchip_drm_private *priv = crtc->dev->dev_private;
 792
 793         if (pipe >= ROCKCHIP_MAX_CRTC)
 794                 return;
 795
 796         priv->crtc_funcs[pipe] = NULL;
 797 }
 798
 799 static struct drm_crtc *rockchip_crtc_from_pipe(struct drm_device *drm,
 800                                                 int pipe)
 801 {
 802         struct drm_crtc *crtc;
 803         int i = 0;
 804
 805         list_for_each_entry(crtc, &drm->mode_config.crtc_list, head)
 806                 if (i++ == pipe)
 807                         return crtc;
 808
 809         return NULL;
 810 }
 811
 812 static int rockchip_drm_crtc_enable_vblank(struct drm_device *dev,
 813                                            unsigned int pipe)
 814 {
 815         struct rockchip_drm_private *priv = dev->dev_private;
 816         struct drm_crtc *crtc = rockchip_crtc_from_pipe(dev, pipe);
 817
 818         if (crtc && priv->crtc_funcs[pipe] &&
 819             priv->crtc_funcs[pipe]->enable_vblank)
 820                 return priv->crtc_funcs[pipe]->enable_vblank(crtc);
 821
 822         return 0;
 823 }
 824
 825 static void rockchip_drm_crtc_disable_vblank(struct drm_device *dev,
 826                                              unsigned int pipe)
 827 {
 828         struct rockchip_drm_private *priv = dev->dev_private;
 829         struct drm_crtc *crtc = rockchip_crtc_from_pipe(dev, pipe);
 830
 831         if (crtc && priv->crtc_funcs[pipe] &&
 832             priv->crtc_funcs[pipe]->enable_vblank)
 833                 priv->crtc_funcs[pipe]->disable_vblank(crtc);
 834 }
 835
 836 static int rockchip_drm_fault_handler(struct iommu_domain *iommu,
 837                                       struct device *dev,
 838                                       unsigned long iova, int flags, void *arg)
 839 {
 840         struct drm_device *drm_dev = arg;
 841         struct rockchip_drm_private *priv = drm_dev->dev_private;
 842         struct drm_crtc *crtc;
 843
 844         drm_for_each_crtc(crtc, drm_dev) {
 845                 int pipe = drm_crtc_index(crtc);
 846
 847                 if (priv->crtc_funcs[pipe] &&
 848                     priv->crtc_funcs[pipe]->regs_dump)
 849                         priv->crtc_funcs[pipe]->regs_dump(crtc, NULL);
 850
 851                 if (priv->crtc_funcs[pipe] &&
 852                     priv->crtc_funcs[pipe]->debugfs_dump)
 853                         priv->crtc_funcs[pipe]->debugfs_dump(crtc, NULL);
 854         }
 855
 856         return 0;
 857 }
 858
 859 static int rockchip_drm_init_iommu(struct drm_device *drm_dev)
 860 {
 861         struct rockchip_drm_private *private = drm_dev->dev_private;
 862         struct iommu_domain_geometry *geometry;
 863         u64 start, end;
 864
 865         if (!is_support_iommu)
 866                 return 0;
 867
 868         private->domain = iommu_domain_alloc(&platform_bus_type);
 869         if (!private->domain)
 870                 return -ENOMEM;
 871
 872         geometry = &private->domain->geometry;
 873         start = geometry->aperture_start;
 874         end = geometry->aperture_end;
 875
 876         DRM_DEBUG("IOMMU context initialized (aperture: %#llx-%#llx)\n",
 877                   start, end);
 878         drm_mm_init(&private->mm, start, end - start + 1);
 879         mutex_init(&private->mm_lock);
 880
 881         iommu_set_fault_handler(private->domain, rockchip_drm_fault_handler,
 882                                 drm_dev);
 883
 884         return 0;
 885 }
 886
 887 static void rockchip_iommu_cleanup(struct drm_device *drm_dev)
 888 {
 889         struct rockchip_drm_private *private = drm_dev->dev_private;
 890
 891         if (!is_support_iommu)
 892                 return;
 893
 894         drm_mm_takedown(&private->mm);
 895         iommu_domain_free(private->domain);
 896 }
 897
 898 #ifdef CONFIG_DEBUG_FS
 899 static int rockchip_drm_mm_dump(struct seq_file *s, void *data)
 900 {
 901         struct drm_info_node *node = s->private;
 902         struct drm_minor *minor = node->minor;
 903         struct drm_device *drm_dev = minor->dev;
 904         struct rockchip_drm_private *priv = drm_dev->dev_private;
 905         int ret;
 906
 907         if (!priv->domain)
 908                 return 0;
 909
 910         mutex_lock(&priv->mm_lock);
 911
 912         ret = drm_mm_dump_table(s, &priv->mm);
 913
 914         mutex_unlock(&priv->mm_lock);
 915
 916         return ret;
 917 }
 918
 919 static int rockchip_drm_summary_show(struct seq_file *s, void *data)
 920 {
 921         struct drm_info_node *node = s->private;
 922         struct drm_minor *minor = node->minor;
 923         struct drm_device *drm_dev = minor->dev;
 924         struct rockchip_drm_private *priv = drm_dev->dev_private;
 925         struct drm_crtc *crtc;
 926
 927         drm_for_each_crtc(crtc, drm_dev) {
 928                 int pipe = drm_crtc_index(crtc);
 929
 930                 if (priv->crtc_funcs[pipe] &&
 931                     priv->crtc_funcs[pipe]->debugfs_dump)
 932                         priv->crtc_funcs[pipe]->debugfs_dump(crtc, s);
 933         }
 934
 935         return 0;
 936 }
 937
 938 static struct drm_info_list rockchip_debugfs_files[] = {
 939         { "summary", rockchip_drm_summary_show, 0, NULL },
 940         { "mm_dump", rockchip_drm_mm_dump, 0, NULL },
 941 };
 942
 943 static int rockchip_drm_debugfs_init(struct drm_minor *minor)
 944 {
 945         struct drm_device *dev = minor->dev;
 946         int ret;
 947
 948         ret = drm_debugfs_create_files(rockchip_debugfs_files,
 949                                        ARRAY_SIZE(rockchip_debugfs_files),
 950                                        minor->debugfs_root,
 951                                        minor);
 952         if (ret) {
 953                 dev_err(dev->dev, "could not install rockchip_debugfs_list\n");
 954                 return ret;
 955         }
 956
 957         return 0;
 958 }
 959
 960 static void rockchip_drm_debugfs_cleanup(struct drm_minor *minor)
 961 {
 962         drm_debugfs_remove_files(rockchip_debugfs_files,
 963                                  ARRAY_SIZE(rockchip_debugfs_files), minor);
 964 }
 965 #endif
 966
 967 static int rockchip_drm_create_properties(struct drm_device *dev)
 968 {
 969         struct drm_property *prop;
 970         struct rockchip_drm_private *private = dev->dev_private;
 971         const struct drm_prop_enum_list cabc_mode_enum_list[] = {
 972                 { ROCKCHIP_DRM_CABC_MODE_DISABLE, "Disable" },
 973                 { ROCKCHIP_DRM_CABC_MODE_NORMAL, "Normal" },
 974                 { ROCKCHIP_DRM_CABC_MODE_LOWPOWER, "LowPower" },
 975                 { ROCKCHIP_DRM_CABC_MODE_USERSPACE, "Userspace" },
 976         };
 977
 978         prop = drm_property_create_enum(dev, 0, "CABC_MODE", cabc_mode_enum_list,
 979                         ARRAY_SIZE(cabc_mode_enum_list));
 980
 981         private->cabc_mode_property = prop;
 982
 983         prop = drm_property_create(dev, DRM_MODE_PROP_BLOB, "CABC_LUT", 0);
 984         if (!prop)
 985                 return -ENOMEM;
 986         private->cabc_lut_property = prop;
 987
 988         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 989                                         "CABC_STAGE_UP", 0, 512);
 990         if (!prop)
 991                 return -ENOMEM;
 992         private->cabc_stage_up_property = prop;
 993
 994         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 995                                         "CABC_STAGE_DOWN", 0, 255);
 996         if (!prop)
 997                 return -ENOMEM;
 998         private->cabc_stage_down_property = prop;
 999
1000         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1001                                         "CABC_GLOBAL_DN", 0, 255);
1002         if (!prop)
1003                 return -ENOMEM;
1004         private->cabc_global_dn_property = prop;
1005
1006         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1007                                         "CABC_CALC_PIXEL_NUM", 0, 1000);
1008         if (!prop)
1009                 return -ENOMEM;
1010         private->cabc_calc_pixel_num_property = prop;
1011
1012         return 0;
1013 }
1014
1015 static int rockchip_drm_bind(struct device *dev)
1016 {
1017         struct drm_device *drm_dev;
1018         struct rockchip_drm_private *private;
1019         int ret;
1020
1021         drm_dev = drm_dev_alloc(&rockchip_drm_driver, dev);
1022         if (!drm_dev)
1023                 return -ENOMEM;
1024
1025         ret = drm_dev_set_unique(drm_dev, "%s", dev_name(dev));
1026         if (ret)
1027                 goto err_free;
1028
1029         dev_set_drvdata(dev, drm_dev);
1030
1031         private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL);
1032         if (!private) {
1033                 ret = -ENOMEM;
1034                 goto err_free;
1035         }
1036
1037         mutex_init(&private->commit.lock);
1038         INIT_WORK(&private->commit.work, rockchip_drm_atomic_work);
1039
1040         drm_dev->dev_private = private;
1041
1042         private->hdmi_pll.pll = devm_clk_get(dev, "hdmi-tmds-pll");
1043         if (PTR_ERR(private->hdmi_pll.pll) == -ENOENT) {
1044                 private->hdmi_pll.pll = NULL;
1045         } else if (PTR_ERR(private->hdmi_pll.pll) == -EPROBE_DEFER) {
1046                 ret = -EPROBE_DEFER;
1047                 goto err_free;
1048         } else if (IS_ERR(private->hdmi_pll.pll)) {
1049                 dev_err(dev, "failed to get hdmi-tmds-pll\n");
1050                 ret = PTR_ERR(private->hdmi_pll.pll);
1051                 goto err_free;
1052         }
1053
1054         private->default_pll.pll = devm_clk_get(dev, "default-vop-pll");
1055         if (PTR_ERR(private->default_pll.pll) == -ENOENT) {
1056                 private->default_pll.pll = NULL;
1057         } else if (PTR_ERR(private->default_pll.pll) == -EPROBE_DEFER) {
1058                 ret = -EPROBE_DEFER;
1059                 goto err_free;
1060         } else if (IS_ERR(private->default_pll.pll)) {
1061                 dev_err(dev, "failed to get default vop pll\n");
1062                 ret = PTR_ERR(private->default_pll.pll);
1063                 goto err_free;
1064         }
1065
1066 #ifdef CONFIG_DRM_DMA_SYNC
1067         private->cpu_fence_context = fence_context_alloc(1);
1068         atomic_set(&private->cpu_fence_seqno, 0);
1069 #endif
1070
1071         drm_mode_config_init(drm_dev);
1072
1073         rockchip_drm_mode_config_init(drm_dev);
1074         rockchip_drm_create_properties(drm_dev);
1075
1076         ret = rockchip_drm_init_iommu(drm_dev);
1077         if (ret)
1078                 goto err_config_cleanup;
1079
1080         /* Try to bind all sub drivers. */
1081         ret = component_bind_all(dev, drm_dev);
1082         if (ret)
1083                 goto err_iommu_cleanup;
1084
1085         /* init kms poll for handling hpd */
1086         drm_kms_helper_poll_init(drm_dev);
1087
1088         /*
1089          * enable drm irq mode.
1090          * - with irq_enabled = true, we can use the vblank feature.
1091          */
1092         drm_dev->irq_enabled = true;
1093
1094         ret = drm_vblank_init(drm_dev, ROCKCHIP_MAX_CRTC);
1095         if (ret)
1096                 goto err_kms_helper_poll_fini;
1097
1098         /*
1099          * with vblank_disable_allowed = true, vblank interrupt will be disabled
1100          * by drm timer once a current process gives up ownership of
1101          * vblank event.(after drm_vblank_put function is called)
1102          */
1103         drm_dev->vblank_disable_allowed = true;
1104
1105         drm_mode_config_reset(drm_dev);
1106
1107 #ifndef MODULE
1108         show_loader_logo(drm_dev);
1109 #endif
1110
1111         ret = rockchip_drm_fbdev_init(drm_dev);
1112         if (ret)
1113                 goto err_vblank_cleanup;
1114
1115         drm_dev->mode_config.allow_fb_modifiers = true;
1116
1117         ret = drm_dev_register(drm_dev, 0);
1118         if (ret)
1119                 goto err_fbdev_fini;
1120
1121         return 0;
1122 err_fbdev_fini:
1123         rockchip_drm_fbdev_fini(drm_dev);
1124 err_vblank_cleanup:
1125         drm_vblank_cleanup(drm_dev);
1126 err_kms_helper_poll_fini:
1127         drm_kms_helper_poll_fini(drm_dev);
1128         component_unbind_all(dev, drm_dev);
1129 err_iommu_cleanup:
1130         rockchip_iommu_cleanup(drm_dev);
1131 err_config_cleanup:
1132         drm_mode_config_cleanup(drm_dev);
1133         drm_dev->dev_private = NULL;
1134 err_free:
1135         drm_dev_unref(drm_dev);
1136         return ret;
1137 }
1138
1139 static void rockchip_drm_unbind(struct device *dev)
1140 {
1141         struct drm_device *drm_dev = dev_get_drvdata(dev);
1142
1143         rockchip_drm_fbdev_fini(drm_dev);
1144         drm_vblank_cleanup(drm_dev);
1145         drm_kms_helper_poll_fini(drm_dev);
1146         component_unbind_all(dev, drm_dev);
1147         rockchip_iommu_cleanup(drm_dev);
1148         drm_mode_config_cleanup(drm_dev);
1149         drm_dev->dev_private = NULL;
1150         drm_dev_unregister(drm_dev);
1151         drm_dev_unref(drm_dev);
1152         dev_set_drvdata(dev, NULL);
1153 }
1154
1155 static void rockchip_drm_crtc_cancel_pending_vblank(struct drm_crtc *crtc,
1156                                                     struct drm_file *file_priv)
1157 {
1158         struct rockchip_drm_private *priv = crtc->dev->dev_private;
1159         int pipe = drm_crtc_index(crtc);
1160
1161         if (pipe < ROCKCHIP_MAX_CRTC &&
1162             priv->crtc_funcs[pipe] &&
1163             priv->crtc_funcs[pipe]->cancel_pending_vblank)
1164                 priv->crtc_funcs[pipe]->cancel_pending_vblank(crtc, file_priv);
1165 }
1166
1167 int rockchip_drm_register_subdrv(struct drm_rockchip_subdrv *subdrv)
1168 {
1169         if (!subdrv)
1170                 return -EINVAL;
1171
1172         mutex_lock(&subdrv_list_mutex);
1173         list_add_tail(&subdrv->list, &rockchip_drm_subdrv_list);
1174         mutex_unlock(&subdrv_list_mutex);
1175
1176         return 0;
1177 }
1178 EXPORT_SYMBOL_GPL(rockchip_drm_register_subdrv);
1179
1180 int rockchip_drm_unregister_subdrv(struct drm_rockchip_subdrv *subdrv)
1181 {
1182         if (!subdrv)
1183                 return -EINVAL;
1184
1185         mutex_lock(&subdrv_list_mutex);
1186         list_del(&subdrv->list);
1187         mutex_unlock(&subdrv_list_mutex);
1188
1189         return 0;
1190 }
1191 EXPORT_SYMBOL_GPL(rockchip_drm_unregister_subdrv);
1192
1193 static int rockchip_drm_open(struct drm_device *dev, struct drm_file *file)
1194 {
1195         struct rockchip_drm_file_private *file_priv;
1196         struct drm_rockchip_subdrv *subdrv;
1197         int ret = 0;
1198
1199         file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
1200         if (!file_priv)
1201                 return -ENOMEM;
1202         INIT_LIST_HEAD(&file_priv->gem_cpu_acquire_list);
1203
1204         file->driver_priv = file_priv;
1205
1206         mutex_lock(&subdrv_list_mutex);
1207         list_for_each_entry(subdrv, &rockchip_drm_subdrv_list, list) {
1208                 ret = subdrv->open(dev, subdrv->dev, file);
1209                 if (ret) {
1210                         mutex_unlock(&subdrv_list_mutex);
1211                         goto err_free_file_priv;
1212                 }
1213         }
1214         mutex_unlock(&subdrv_list_mutex);
1215
1216         return 0;
1217
1218 err_free_file_priv:
1219         kfree(file_priv);
1220         file_priv = NULL;
1221
1222         return ret;
1223 }
1224
1225 static void rockchip_drm_preclose(struct drm_device *dev,
1226                                   struct drm_file *file_priv)
1227 {
1228         struct rockchip_drm_file_private *file_private = file_priv->driver_priv;
1229         struct rockchip_gem_object_node *cur, *d;
1230         struct drm_rockchip_subdrv *subdrv;
1231         struct drm_crtc *crtc;
1232
1233         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
1234                 rockchip_drm_crtc_cancel_pending_vblank(crtc, file_priv);
1235
1236         mutex_lock(&dev->struct_mutex);
1237         list_for_each_entry_safe(cur, d,
1238                         &file_private->gem_cpu_acquire_list, list) {
1239 #ifdef CONFIG_DRM_DMA_SYNC
1240                 BUG_ON(!cur->rockchip_gem_obj->acquire_fence);
1241                 drm_fence_signal_and_put(&cur->rockchip_gem_obj->acquire_fence);
1242 #endif
1243                 drm_gem_object_unreference(&cur->rockchip_gem_obj->base);
1244                 kfree(cur);
1245         }
1246         /* since we are deleting the whole list, just initialize the header
1247          * instead of calling list_del for every element
1248          */
1249         INIT_LIST_HEAD(&file_private->gem_cpu_acquire_list);
1250         mutex_unlock(&dev->struct_mutex);
1251
1252         mutex_lock(&subdrv_list_mutex);
1253         list_for_each_entry(subdrv, &rockchip_drm_subdrv_list, list)
1254                 subdrv->close(dev, subdrv->dev, file_priv);
1255         mutex_unlock(&subdrv_list_mutex);
1256 }
1257
1258 static void rockchip_drm_postclose(struct drm_device *dev, struct drm_file *file)
1259 {
1260         kfree(file->driver_priv);
1261         file->driver_priv = NULL;
1262 }
1263
1264 void rockchip_drm_lastclose(struct drm_device *dev)
1265 {
1266         struct rockchip_drm_private *priv = dev->dev_private;
1267
1268         if (!priv->logo)
1269                 drm_fb_helper_restore_fbdev_mode_unlocked(priv->fbdev_helper);
1270 }
1271
1272 static const struct drm_ioctl_desc rockchip_ioctls[] = {
1273         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_CREATE, rockchip_gem_create_ioctl,
1274                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
1275         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_MAP_OFFSET,
1276                           rockchip_gem_map_offset_ioctl,
1277                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
1278         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_CPU_ACQUIRE,
1279                           rockchip_gem_cpu_acquire_ioctl,
1280                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
1281         DRM_IOCTL_DEF_DRV(ROCKCHIP_GEM_CPU_RELEASE,
1282                           rockchip_gem_cpu_release_ioctl,
1283                           DRM_UNLOCKED | DRM_AUTH | DRM_RENDER_ALLOW),
1284         DRM_IOCTL_DEF_DRV(ROCKCHIP_RGA_GET_VER, rockchip_rga_get_ver_ioctl,
1285                           DRM_AUTH | DRM_RENDER_ALLOW),
1286         DRM_IOCTL_DEF_DRV(ROCKCHIP_RGA_SET_CMDLIST,
1287                           rockchip_rga_set_cmdlist_ioctl,
1288                           DRM_AUTH | DRM_RENDER_ALLOW),
1289         DRM_IOCTL_DEF_DRV(ROCKCHIP_RGA_EXEC, rockchip_rga_exec_ioctl,
1290                           DRM_AUTH | DRM_RENDER_ALLOW),
1291 };
1292
1293 static const struct file_operations rockchip_drm_driver_fops = {
1294         .owner = THIS_MODULE,
1295         .open = drm_open,
1296         .mmap = rockchip_gem_mmap,
1297         .poll = drm_poll,
1298         .read = drm_read,
1299         .unlocked_ioctl = drm_ioctl,
1300 #ifdef CONFIG_COMPAT
1301         .compat_ioctl = drm_compat_ioctl,
1302 #endif
1303         .release = drm_release,
1304 };
1305
1306 const struct vm_operations_struct rockchip_drm_vm_ops = {
1307         .open = drm_gem_vm_open,
1308         .close = drm_gem_vm_close,
1309 };
1310
1311 static struct drm_driver rockchip_drm_driver = {
1312         .driver_features        = DRIVER_MODESET | DRIVER_GEM |
1313                                   DRIVER_PRIME | DRIVER_ATOMIC |
1314                                   DRIVER_RENDER,
1315         .preclose               = rockchip_drm_preclose,
1316         .lastclose              = rockchip_drm_lastclose,
1317         .get_vblank_counter     = drm_vblank_no_hw_counter,
1318         .open                   = rockchip_drm_open,
1319         .postclose              = rockchip_drm_postclose,
1320         .enable_vblank          = rockchip_drm_crtc_enable_vblank,
1321         .disable_vblank         = rockchip_drm_crtc_disable_vblank,
1322         .gem_vm_ops             = &rockchip_drm_vm_ops,
1323         .gem_free_object        = rockchip_gem_free_object,
1324         .dumb_create            = rockchip_gem_dumb_create,
1325         .dumb_map_offset        = rockchip_gem_dumb_map_offset,
1326         .dumb_destroy           = drm_gem_dumb_destroy,
1327         .prime_handle_to_fd     = drm_gem_prime_handle_to_fd,
1328         .prime_fd_to_handle     = drm_gem_prime_fd_to_handle,
1329         .gem_prime_import       = drm_gem_prime_import,
1330         .gem_prime_export       = drm_gem_prime_export,
1331         .gem_prime_get_sg_table = rockchip_gem_prime_get_sg_table,
1332         .gem_prime_import_sg_table      = rockchip_gem_prime_import_sg_table,
1333         .gem_prime_vmap         = rockchip_gem_prime_vmap,
1334         .gem_prime_vunmap       = rockchip_gem_prime_vunmap,
1335         .gem_prime_mmap         = rockchip_gem_mmap_buf,
1336         .gem_prime_begin_cpu_access = rockchip_gem_prime_begin_cpu_access,
1337         .gem_prime_end_cpu_access = rockchip_gem_prime_end_cpu_access,
1338 #ifdef CONFIG_DEBUG_FS
1339         .debugfs_init           = rockchip_drm_debugfs_init,
1340         .debugfs_cleanup        = rockchip_drm_debugfs_cleanup,
1341 #endif
1342         .ioctls                 = rockchip_ioctls,
1343         .num_ioctls             = ARRAY_SIZE(rockchip_ioctls),
1344         .fops                   = &rockchip_drm_driver_fops,
1345         .name   = DRIVER_NAME,
1346         .desc   = DRIVER_DESC,
1347         .date   = DRIVER_DATE,
1348         .major  = DRIVER_MAJOR,
1349         .minor  = DRIVER_MINOR,
1350 };
1351
1352 #ifdef CONFIG_PM_SLEEP
1353 void rockchip_drm_fb_suspend(struct drm_device *drm)
1354 {
1355         struct rockchip_drm_private *priv = drm->dev_private;
1356
1357         console_lock();
1358         drm_fb_helper_set_suspend(priv->fbdev_helper, 1);
1359         console_unlock();
1360 }
1361
1362 void rockchip_drm_fb_resume(struct drm_device *drm)
1363 {
1364         struct rockchip_drm_private *priv = drm->dev_private;
1365
1366         console_lock();
1367         drm_fb_helper_set_suspend(priv->fbdev_helper, 0);
1368         console_unlock();
1369 }
1370
1371 static int rockchip_drm_sys_suspend(struct device *dev)
1372 {
1373         struct drm_device *drm = dev_get_drvdata(dev);
1374         struct rockchip_drm_private *priv = drm->dev_private;
1375
1376         drm_kms_helper_poll_disable(drm);
1377         rockchip_drm_fb_suspend(drm);
1378
1379         priv->state = drm_atomic_helper_suspend(drm);
1380         if (IS_ERR(priv->state)) {
1381                 rockchip_drm_fb_resume(drm);
1382                 drm_kms_helper_poll_enable(drm);
1383                 return PTR_ERR(priv->state);
1384         }
1385
1386         return 0;
1387 }
1388
1389 static int rockchip_drm_sys_resume(struct device *dev)
1390 {
1391         struct drm_device *drm = dev_get_drvdata(dev);
1392         struct rockchip_drm_private *priv = drm->dev_private;
1393
1394         drm_atomic_helper_resume(drm, priv->state);
1395         rockchip_drm_fb_resume(drm);
1396         drm_kms_helper_poll_enable(drm);
1397
1398         return 0;
1399 }
1400 #endif
1401
1402 static const struct dev_pm_ops rockchip_drm_pm_ops = {
1403         SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend,
1404                                 rockchip_drm_sys_resume)
1405 };
1406
1407 static int compare_of(struct device *dev, void *data)
1408 {
1409         struct device_node *np = data;
1410
1411         return dev->of_node == np;
1412 }
1413
1414 static void rockchip_add_endpoints(struct device *dev,
1415                                    struct component_match **match,
1416                                    struct device_node *port)
1417 {
1418         struct device_node *ep, *remote;
1419
1420         for_each_child_of_node(port, ep) {
1421                 remote = of_graph_get_remote_port_parent(ep);
1422                 if (!remote || !of_device_is_available(remote)) {
1423                         of_node_put(remote);
1424                         continue;
1425                 } else if (!of_device_is_available(remote->parent)) {
1426                         dev_warn(dev, "parent device of %s is not available\n",
1427                                  remote->full_name);
1428                         of_node_put(remote);
1429                         continue;
1430                 }
1431
1432                 component_match_add(dev, match, compare_of, remote);
1433                 of_node_put(remote);
1434         }
1435 }
1436
1437 static const struct component_master_ops rockchip_drm_ops = {
1438         .bind = rockchip_drm_bind,
1439         .unbind = rockchip_drm_unbind,
1440 };
1441
1442 static int rockchip_drm_platform_probe(struct platform_device *pdev)
1443 {
1444         struct device *dev = &pdev->dev;
1445         struct component_match *match = NULL;
1446         struct device_node *np = dev->of_node;
1447         struct device_node *port;
1448         int i;
1449
1450         if (!np)
1451                 return -ENODEV;
1452         /*
1453          * Bind the crtc ports first, so that
1454          * drm_of_find_possible_crtcs called from encoder .bind callbacks
1455          * works as expected.
1456          */
1457         for (i = 0;; i++) {
1458                 struct device_node *iommu;
1459
1460                 port = of_parse_phandle(np, "ports", i);
1461                 if (!port)
1462                         break;
1463
1464                 if (!of_device_is_available(port->parent)) {
1465                         of_node_put(port);
1466                         continue;
1467                 }
1468
1469                 iommu = of_parse_phandle(port->parent, "iommus", 0);
1470                 if (!iommu || !of_device_is_available(iommu->parent)) {
1471                         dev_dbg(dev, "no iommu attached for %s, using non-iommu buffers\n",
1472                                 port->parent->full_name);
1473                         /*
1474                          * if there is a crtc not support iommu, force set all
1475                          * crtc use non-iommu buffer.
1476                          */
1477                         is_support_iommu = false;
1478                 }
1479
1480                 component_match_add(dev, &match, compare_of, port->parent);
1481                 of_node_put(port);
1482         }
1483
1484         if (i == 0) {
1485                 dev_err(dev, "missing 'ports' property\n");
1486                 return -ENODEV;
1487         }
1488
1489         if (!match) {
1490                 dev_err(dev, "No available vop found for display-subsystem.\n");
1491                 return -ENODEV;
1492         }
1493         /*
1494          * For each bound crtc, bind the encoders attached to its
1495          * remote endpoint.
1496          */
1497         for (i = 0;; i++) {
1498                 port = of_parse_phandle(np, "ports", i);
1499                 if (!port)
1500                         break;
1501
1502                 if (!of_device_is_available(port->parent)) {
1503                         of_node_put(port);
1504                         continue;
1505                 }
1506
1507                 rockchip_add_endpoints(dev, &match, port);
1508                 of_node_put(port);
1509         }
1510
1511         port = of_parse_phandle(np, "backlight", 0);
1512         if (port && of_device_is_available(port)) {
1513                 component_match_add(dev, &match, compare_of, port);
1514                 of_node_put(port);
1515         }
1516
1517         return component_master_add_with_match(dev, &rockchip_drm_ops, match);
1518 }
1519
1520 static int rockchip_drm_platform_remove(struct platform_device *pdev)
1521 {
1522         component_master_del(&pdev->dev, &rockchip_drm_ops);
1523
1524         return 0;
1525 }
1526
1527 static const struct of_device_id rockchip_drm_dt_ids[] = {
1528         { .compatible = "rockchip,display-subsystem", },
1529         { /* sentinel */ },
1530 };
1531 MODULE_DEVICE_TABLE(of, rockchip_drm_dt_ids);
1532
1533 static struct platform_driver rockchip_drm_platform_driver = {
1534         .probe = rockchip_drm_platform_probe,
1535         .remove = rockchip_drm_platform_remove,
1536         .driver = {
1537                 .name = "rockchip-drm",
1538                 .of_match_table = rockchip_drm_dt_ids,
1539                 .pm = &rockchip_drm_pm_ops,
1540         },
1541 };
1542
1543 module_platform_driver(rockchip_drm_platform_driver);
1544
1545 MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>");
1546 MODULE_DESCRIPTION("ROCKCHIP DRM Driver");
1547 MODULE_LICENSE("GPL v2");