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