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