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