drivers/gpu/drm/tegra/drm.c

   1 /*
   2  * Copyright (C) 2012 Avionic Design GmbH
   3  * Copyright (C) 2012-2013 NVIDIA CORPORATION.  All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  */
   9
  10 #include <linux/host1x.h>
  11
  12 #include "drm.h"
  13 #include "gem.h"
  14
  15 #define DRIVER_NAME "tegra"
  16 #define DRIVER_DESC "NVIDIA Tegra graphics"
  17 #define DRIVER_DATE "20120330"
  18 #define DRIVER_MAJOR 0
  19 #define DRIVER_MINOR 0
  20 #define DRIVER_PATCHLEVEL 0
  21
  22 struct tegra_drm_file {
  23         struct list_head contexts;
  24 };
  25
  26 static int tegra_drm_load(struct drm_device *drm, unsigned long flags)
  27 {
  28         struct host1x_device *device = to_host1x_device(drm->dev);
  29         struct tegra_drm *tegra;
  30         int err;
  31
  32         tegra = kzalloc(sizeof(*tegra), GFP_KERNEL);
  33         if (!tegra)
  34                 return -ENOMEM;
  35
  36         dev_set_drvdata(drm->dev, tegra);
  37         mutex_init(&tegra->clients_lock);
  38         INIT_LIST_HEAD(&tegra->clients);
  39         drm->dev_private = tegra;
  40         tegra->drm = drm;
  41
  42         drm_mode_config_init(drm);
  43
  44         err = host1x_device_init(device);
  45         if (err < 0)
  46                 return err;
  47
  48         /*
  49          * We don't use the drm_irq_install() helpers provided by the DRM
  50          * core, so we need to set this manually in order to allow the
  51          * DRM_IOCTL_WAIT_VBLANK to operate correctly.
  52          */
  53         drm->irq_enabled = true;
  54
  55         err = drm_vblank_init(drm, drm->mode_config.num_crtc);
  56         if (err < 0)
  57                 return err;
  58
  59         err = tegra_drm_fb_init(drm);
  60         if (err < 0)
  61                 return err;
  62
  63         drm_kms_helper_poll_init(drm);
  64
  65         return 0;
  66 }
  67
  68 static int tegra_drm_unload(struct drm_device *drm)
  69 {
  70         struct host1x_device *device = to_host1x_device(drm->dev);
  71         int err;
  72
  73         drm_kms_helper_poll_fini(drm);
  74         tegra_drm_fb_exit(drm);
  75         drm_vblank_cleanup(drm);
  76         drm_mode_config_cleanup(drm);
  77
  78         err = host1x_device_exit(device);
  79         if (err < 0)
  80                 return err;
  81
  82         return 0;
  83 }
  84
  85 static int tegra_drm_open(struct drm_device *drm, struct drm_file *filp)
  86 {
  87         struct tegra_drm_file *fpriv;
  88
  89         fpriv = kzalloc(sizeof(*fpriv), GFP_KERNEL);
  90         if (!fpriv)
  91                 return -ENOMEM;
  92
  93         INIT_LIST_HEAD(&fpriv->contexts);
  94         filp->driver_priv = fpriv;
  95
  96         return 0;
  97 }
  98
  99 static void tegra_drm_context_free(struct tegra_drm_context *context)
 100 {
 101         context->client->ops->close_channel(context);
 102         kfree(context);
 103 }
 104
 105 static void tegra_drm_lastclose(struct drm_device *drm)
 106 {
 107         struct tegra_drm *tegra = drm->dev_private;
 108
 109         tegra_fbdev_restore_mode(tegra->fbdev);
 110 }
 111
 112 static struct host1x_bo *
 113 host1x_bo_lookup(struct drm_device *drm, struct drm_file *file, u32 handle)
 114 {
 115         struct drm_gem_object *gem;
 116         struct tegra_bo *bo;
 117
 118         gem = drm_gem_object_lookup(drm, file, handle);
 119         if (!gem)
 120                 return NULL;
 121
 122         mutex_lock(&drm->struct_mutex);
 123         drm_gem_object_unreference(gem);
 124         mutex_unlock(&drm->struct_mutex);
 125
 126         bo = to_tegra_bo(gem);
 127         return &bo->base;
 128 }
 129
 130 int tegra_drm_submit(struct tegra_drm_context *context,
 131                      struct drm_tegra_submit *args, struct drm_device *drm,
 132                      struct drm_file *file)
 133 {
 134         unsigned int num_cmdbufs = args->num_cmdbufs;
 135         unsigned int num_relocs = args->num_relocs;
 136         unsigned int num_waitchks = args->num_waitchks;
 137         struct drm_tegra_cmdbuf __user *cmdbufs =
 138                 (void * __user)(uintptr_t)args->cmdbufs;
 139         struct drm_tegra_reloc __user *relocs =
 140                 (void * __user)(uintptr_t)args->relocs;
 141         struct drm_tegra_waitchk __user *waitchks =
 142                 (void * __user)(uintptr_t)args->waitchks;
 143         struct drm_tegra_syncpt syncpt;
 144         struct host1x_job *job;
 145         int err;
 146
 147         /* We don't yet support other than one syncpt_incr struct per submit */
 148         if (args->num_syncpts != 1)
 149                 return -EINVAL;
 150
 151         job = host1x_job_alloc(context->channel, args->num_cmdbufs,
 152                                args->num_relocs, args->num_waitchks);
 153         if (!job)
 154                 return -ENOMEM;
 155
 156         job->num_relocs = args->num_relocs;
 157         job->num_waitchk = args->num_waitchks;
 158         job->client = (u32)args->context;
 159         job->class = context->client->base.class;
 160         job->serialize = true;
 161
 162         while (num_cmdbufs) {
 163                 struct drm_tegra_cmdbuf cmdbuf;
 164                 struct host1x_bo *bo;
 165
 166                 err = copy_from_user(&cmdbuf, cmdbufs, sizeof(cmdbuf));
 167                 if (err)
 168                         goto fail;
 169
 170                 bo = host1x_bo_lookup(drm, file, cmdbuf.handle);
 171                 if (!bo) {
 172                         err = -ENOENT;
 173                         goto fail;
 174                 }
 175
 176                 host1x_job_add_gather(job, bo, cmdbuf.words, cmdbuf.offset);
 177                 num_cmdbufs--;
 178                 cmdbufs++;
 179         }
 180
 181         err = copy_from_user(job->relocarray, relocs,
 182                              sizeof(*relocs) * num_relocs);
 183         if (err)
 184                 goto fail;
 185
 186         while (num_relocs--) {
 187                 struct host1x_reloc *reloc = &job->relocarray[num_relocs];
 188                 struct host1x_bo *cmdbuf, *target;
 189
 190                 cmdbuf = host1x_bo_lookup(drm, file, (u32)reloc->cmdbuf);
 191                 target = host1x_bo_lookup(drm, file, (u32)reloc->target);
 192
 193                 reloc->cmdbuf = cmdbuf;
 194                 reloc->target = target;
 195
 196                 if (!reloc->target || !reloc->cmdbuf) {
 197                         err = -ENOENT;
 198                         goto fail;
 199                 }
 200         }
 201
 202         err = copy_from_user(job->waitchk, waitchks,
 203                              sizeof(*waitchks) * num_waitchks);
 204         if (err)
 205                 goto fail;
 206
 207         err = copy_from_user(&syncpt, (void * __user)(uintptr_t)args->syncpts,
 208                              sizeof(syncpt));
 209         if (err)
 210                 goto fail;
 211
 212         job->is_addr_reg = context->client->ops->is_addr_reg;
 213         job->syncpt_incrs = syncpt.incrs;
 214         job->syncpt_id = syncpt.id;
 215         job->timeout = 10000;
 216
 217         if (args->timeout && args->timeout < 10000)
 218                 job->timeout = args->timeout;
 219
 220         err = host1x_job_pin(job, context->client->base.dev);
 221         if (err)
 222                 goto fail;
 223
 224         err = host1x_job_submit(job);
 225         if (err)
 226                 goto fail_submit;
 227
 228         args->fence = job->syncpt_end;
 229
 230         host1x_job_put(job);
 231         return 0;
 232
 233 fail_submit:
 234         host1x_job_unpin(job);
 235 fail:
 236         host1x_job_put(job);
 237         return err;
 238 }
 239
 240
 241 #ifdef CONFIG_DRM_TEGRA_STAGING
 242 static struct tegra_drm_context *tegra_drm_get_context(__u64 context)
 243 {
 244         return (struct tegra_drm_context *)(uintptr_t)context;
 245 }
 246
 247 static bool tegra_drm_file_owns_context(struct tegra_drm_file *file,
 248                                         struct tegra_drm_context *context)
 249 {
 250         struct tegra_drm_context *ctx;
 251
 252         list_for_each_entry(ctx, &file->contexts, list)
 253                 if (ctx == context)
 254                         return true;
 255
 256         return false;
 257 }
 258
 259 static int tegra_gem_create(struct drm_device *drm, void *data,
 260                             struct drm_file *file)
 261 {
 262         struct drm_tegra_gem_create *args = data;
 263         struct tegra_bo *bo;
 264
 265         bo = tegra_bo_create_with_handle(file, drm, args->size, args->flags,
 266                                          &args->handle);
 267         if (IS_ERR(bo))
 268                 return PTR_ERR(bo);
 269
 270         return 0;
 271 }
 272
 273 static int tegra_gem_mmap(struct drm_device *drm, void *data,
 274                           struct drm_file *file)
 275 {
 276         struct drm_tegra_gem_mmap *args = data;
 277         struct drm_gem_object *gem;
 278         struct tegra_bo *bo;
 279
 280         gem = drm_gem_object_lookup(drm, file, args->handle);
 281         if (!gem)
 282                 return -EINVAL;
 283
 284         bo = to_tegra_bo(gem);
 285
 286         args->offset = drm_vma_node_offset_addr(&bo->gem.vma_node);
 287
 288         drm_gem_object_unreference(gem);
 289
 290         return 0;
 291 }
 292
 293 static int tegra_syncpt_read(struct drm_device *drm, void *data,
 294                              struct drm_file *file)
 295 {
 296         struct host1x *host = dev_get_drvdata(drm->dev->parent);
 297         struct drm_tegra_syncpt_read *args = data;
 298         struct host1x_syncpt *sp;
 299
 300         sp = host1x_syncpt_get(host, args->id);
 301         if (!sp)
 302                 return -EINVAL;
 303
 304         args->value = host1x_syncpt_read_min(sp);
 305         return 0;
 306 }
 307
 308 static int tegra_syncpt_incr(struct drm_device *drm, void *data,
 309                              struct drm_file *file)
 310 {
 311         struct host1x *host1x = dev_get_drvdata(drm->dev->parent);
 312         struct drm_tegra_syncpt_incr *args = data;
 313         struct host1x_syncpt *sp;
 314
 315         sp = host1x_syncpt_get(host1x, args->id);
 316         if (!sp)
 317                 return -EINVAL;
 318
 319         return host1x_syncpt_incr(sp);
 320 }
 321
 322 static int tegra_syncpt_wait(struct drm_device *drm, void *data,
 323                              struct drm_file *file)
 324 {
 325         struct host1x *host1x = dev_get_drvdata(drm->dev->parent);
 326         struct drm_tegra_syncpt_wait *args = data;
 327         struct host1x_syncpt *sp;
 328
 329         sp = host1x_syncpt_get(host1x, args->id);
 330         if (!sp)
 331                 return -EINVAL;
 332
 333         return host1x_syncpt_wait(sp, args->thresh, args->timeout,
 334                                   &args->value);
 335 }
 336
 337 static int tegra_open_channel(struct drm_device *drm, void *data,
 338                               struct drm_file *file)
 339 {
 340         struct tegra_drm_file *fpriv = file->driver_priv;
 341         struct tegra_drm *tegra = drm->dev_private;
 342         struct drm_tegra_open_channel *args = data;
 343         struct tegra_drm_context *context;
 344         struct tegra_drm_client *client;
 345         int err = -ENODEV;
 346
 347         context = kzalloc(sizeof(*context), GFP_KERNEL);
 348         if (!context)
 349                 return -ENOMEM;
 350
 351         list_for_each_entry(client, &tegra->clients, list)
 352                 if (client->base.class == args->client) {
 353                         err = client->ops->open_channel(client, context);
 354                         if (err)
 355                                 break;
 356
 357                         list_add(&context->list, &fpriv->contexts);
 358                         args->context = (uintptr_t)context;
 359                         context->client = client;
 360                         return 0;
 361                 }
 362
 363         kfree(context);
 364         return err;
 365 }
 366
 367 static int tegra_close_channel(struct drm_device *drm, void *data,
 368                                struct drm_file *file)
 369 {
 370         struct tegra_drm_file *fpriv = file->driver_priv;
 371         struct drm_tegra_close_channel *args = data;
 372         struct tegra_drm_context *context;
 373
 374         context = tegra_drm_get_context(args->context);
 375
 376         if (!tegra_drm_file_owns_context(fpriv, context))
 377                 return -EINVAL;
 378
 379         list_del(&context->list);
 380         tegra_drm_context_free(context);
 381
 382         return 0;
 383 }
 384
 385 static int tegra_get_syncpt(struct drm_device *drm, void *data,
 386                             struct drm_file *file)
 387 {
 388         struct tegra_drm_file *fpriv = file->driver_priv;
 389         struct drm_tegra_get_syncpt *args = data;
 390         struct tegra_drm_context *context;
 391         struct host1x_syncpt *syncpt;
 392
 393         context = tegra_drm_get_context(args->context);
 394
 395         if (!tegra_drm_file_owns_context(fpriv, context))
 396                 return -ENODEV;
 397
 398         if (args->index >= context->client->base.num_syncpts)
 399                 return -EINVAL;
 400
 401         syncpt = context->client->base.syncpts[args->index];
 402         args->id = host1x_syncpt_id(syncpt);
 403
 404         return 0;
 405 }
 406
 407 static int tegra_submit(struct drm_device *drm, void *data,
 408                         struct drm_file *file)
 409 {
 410         struct tegra_drm_file *fpriv = file->driver_priv;
 411         struct drm_tegra_submit *args = data;
 412         struct tegra_drm_context *context;
 413
 414         context = tegra_drm_get_context(args->context);
 415
 416         if (!tegra_drm_file_owns_context(fpriv, context))
 417                 return -ENODEV;
 418
 419         return context->client->ops->submit(context, args, drm, file);
 420 }
 421
 422 static int tegra_get_syncpt_base(struct drm_device *drm, void *data,
 423                                  struct drm_file *file)
 424 {
 425         struct tegra_drm_file *fpriv = file->driver_priv;
 426         struct drm_tegra_get_syncpt_base *args = data;
 427         struct tegra_drm_context *context;
 428         struct host1x_syncpt_base *base;
 429         struct host1x_syncpt *syncpt;
 430
 431         context = tegra_drm_get_context(args->context);
 432
 433         if (!tegra_drm_file_owns_context(fpriv, context))
 434                 return -ENODEV;
 435
 436         if (args->syncpt >= context->client->base.num_syncpts)
 437                 return -EINVAL;
 438
 439         syncpt = context->client->base.syncpts[args->syncpt];
 440
 441         base = host1x_syncpt_get_base(syncpt);
 442         if (!base)
 443                 return -ENXIO;
 444
 445         args->id = host1x_syncpt_base_id(base);
 446
 447         return 0;
 448 }
 449 #endif
 450
 451 static const struct drm_ioctl_desc tegra_drm_ioctls[] = {
 452 #ifdef CONFIG_DRM_TEGRA_STAGING
 453         DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE, tegra_gem_create, DRM_UNLOCKED | DRM_AUTH),
 454         DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP, tegra_gem_mmap, DRM_UNLOCKED),
 455         DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_READ, tegra_syncpt_read, DRM_UNLOCKED),
 456         DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_INCR, tegra_syncpt_incr, DRM_UNLOCKED),
 457         DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_WAIT, tegra_syncpt_wait, DRM_UNLOCKED),
 458         DRM_IOCTL_DEF_DRV(TEGRA_OPEN_CHANNEL, tegra_open_channel, DRM_UNLOCKED),
 459         DRM_IOCTL_DEF_DRV(TEGRA_CLOSE_CHANNEL, tegra_close_channel, DRM_UNLOCKED),
 460         DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT, tegra_get_syncpt, DRM_UNLOCKED),
 461         DRM_IOCTL_DEF_DRV(TEGRA_SUBMIT, tegra_submit, DRM_UNLOCKED),
 462         DRM_IOCTL_DEF_DRV(TEGRA_GET_SYNCPT_BASE, tegra_get_syncpt_base, DRM_UNLOCKED),
 463 #endif
 464 };
 465
 466 static const struct file_operations tegra_drm_fops = {
 467         .owner = THIS_MODULE,
 468         .open = drm_open,
 469         .release = drm_release,
 470         .unlocked_ioctl = drm_ioctl,
 471         .mmap = tegra_drm_mmap,
 472         .poll = drm_poll,
 473         .read = drm_read,
 474 #ifdef CONFIG_COMPAT
 475         .compat_ioctl = drm_compat_ioctl,
 476 #endif
 477         .llseek = noop_llseek,
 478 };
 479
 480 static struct drm_crtc *tegra_crtc_from_pipe(struct drm_device *drm, int pipe)
 481 {
 482         struct drm_crtc *crtc;
 483
 484         list_for_each_entry(crtc, &drm->mode_config.crtc_list, head) {
 485                 struct tegra_dc *dc = to_tegra_dc(crtc);
 486
 487                 if (dc->pipe == pipe)
 488                         return crtc;
 489         }
 490
 491         return NULL;
 492 }
 493
 494 static u32 tegra_drm_get_vblank_counter(struct drm_device *dev, int crtc)
 495 {
 496         /* TODO: implement real hardware counter using syncpoints */
 497         return drm_vblank_count(dev, crtc);
 498 }
 499
 500 static int tegra_drm_enable_vblank(struct drm_device *drm, int pipe)
 501 {
 502         struct drm_crtc *crtc = tegra_crtc_from_pipe(drm, pipe);
 503         struct tegra_dc *dc = to_tegra_dc(crtc);
 504
 505         if (!crtc)
 506                 return -ENODEV;
 507
 508         tegra_dc_enable_vblank(dc);
 509
 510         return 0;
 511 }
 512
 513 static void tegra_drm_disable_vblank(struct drm_device *drm, int pipe)
 514 {
 515         struct drm_crtc *crtc = tegra_crtc_from_pipe(drm, pipe);
 516         struct tegra_dc *dc = to_tegra_dc(crtc);
 517
 518         if (crtc)
 519                 tegra_dc_disable_vblank(dc);
 520 }
 521
 522 static void tegra_drm_preclose(struct drm_device *drm, struct drm_file *file)
 523 {
 524         struct tegra_drm_file *fpriv = file->driver_priv;
 525         struct tegra_drm_context *context, *tmp;
 526         struct drm_crtc *crtc;
 527
 528         list_for_each_entry(crtc, &drm->mode_config.crtc_list, head)
 529                 tegra_dc_cancel_page_flip(crtc, file);
 530
 531         list_for_each_entry_safe(context, tmp, &fpriv->contexts, list)
 532                 tegra_drm_context_free(context);
 533
 534         kfree(fpriv);
 535 }
 536
 537 #ifdef CONFIG_DEBUG_FS
 538 static int tegra_debugfs_framebuffers(struct seq_file *s, void *data)
 539 {
 540         struct drm_info_node *node = (struct drm_info_node *)s->private;
 541         struct drm_device *drm = node->minor->dev;
 542         struct drm_framebuffer *fb;
 543
 544         mutex_lock(&drm->mode_config.fb_lock);
 545
 546         list_for_each_entry(fb, &drm->mode_config.fb_list, head) {
 547                 seq_printf(s, "%3d: user size: %d x %d, depth %d, %d bpp, refcount %d\n",
 548                            fb->base.id, fb->width, fb->height, fb->depth,
 549                            fb->bits_per_pixel,
 550                            atomic_read(&fb->refcount.refcount));
 551         }
 552
 553         mutex_unlock(&drm->mode_config.fb_lock);
 554
 555         return 0;
 556 }
 557
 558 static struct drm_info_list tegra_debugfs_list[] = {
 559         { "framebuffers", tegra_debugfs_framebuffers, 0 },
 560 };
 561
 562 static int tegra_debugfs_init(struct drm_minor *minor)
 563 {
 564         return drm_debugfs_create_files(tegra_debugfs_list,
 565                                         ARRAY_SIZE(tegra_debugfs_list),
 566                                         minor->debugfs_root, minor);
 567 }
 568
 569 static void tegra_debugfs_cleanup(struct drm_minor *minor)
 570 {
 571         drm_debugfs_remove_files(tegra_debugfs_list,
 572                                  ARRAY_SIZE(tegra_debugfs_list), minor);
 573 }
 574 #endif
 575
 576 struct drm_driver tegra_drm_driver = {
 577         .driver_features = DRIVER_MODESET | DRIVER_GEM,
 578         .load = tegra_drm_load,
 579         .unload = tegra_drm_unload,
 580         .open = tegra_drm_open,
 581         .preclose = tegra_drm_preclose,
 582         .lastclose = tegra_drm_lastclose,
 583
 584         .get_vblank_counter = tegra_drm_get_vblank_counter,
 585         .enable_vblank = tegra_drm_enable_vblank,
 586         .disable_vblank = tegra_drm_disable_vblank,
 587
 588 #if defined(CONFIG_DEBUG_FS)
 589         .debugfs_init = tegra_debugfs_init,
 590         .debugfs_cleanup = tegra_debugfs_cleanup,
 591 #endif
 592
 593         .gem_free_object = tegra_bo_free_object,
 594         .gem_vm_ops = &tegra_bo_vm_ops,
 595         .dumb_create = tegra_bo_dumb_create,
 596         .dumb_map_offset = tegra_bo_dumb_map_offset,
 597         .dumb_destroy = drm_gem_dumb_destroy,
 598
 599         .ioctls = tegra_drm_ioctls,
 600         .num_ioctls = ARRAY_SIZE(tegra_drm_ioctls),
 601         .fops = &tegra_drm_fops,
 602
 603         .name = DRIVER_NAME,
 604         .desc = DRIVER_DESC,
 605         .date = DRIVER_DATE,
 606         .major = DRIVER_MAJOR,
 607         .minor = DRIVER_MINOR,
 608         .patchlevel = DRIVER_PATCHLEVEL,
 609 };
 610
 611 int tegra_drm_register_client(struct tegra_drm *tegra,
 612                               struct tegra_drm_client *client)
 613 {
 614         mutex_lock(&tegra->clients_lock);
 615         list_add_tail(&client->list, &tegra->clients);
 616         mutex_unlock(&tegra->clients_lock);
 617
 618         return 0;
 619 }
 620
 621 int tegra_drm_unregister_client(struct tegra_drm *tegra,
 622                                 struct tegra_drm_client *client)
 623 {
 624         mutex_lock(&tegra->clients_lock);
 625         list_del_init(&client->list);
 626         mutex_unlock(&tegra->clients_lock);
 627
 628         return 0;
 629 }
 630
 631 static int host1x_drm_probe(struct host1x_device *device)
 632 {
 633         return drm_host1x_init(&tegra_drm_driver, device);
 634 }
 635
 636 static int host1x_drm_remove(struct host1x_device *device)
 637 {
 638         drm_host1x_exit(&tegra_drm_driver, device);
 639
 640         return 0;
 641 }
 642
 643 static const struct of_device_id host1x_drm_subdevs[] = {
 644         { .compatible = "nvidia,tegra20-dc", },
 645         { .compatible = "nvidia,tegra20-hdmi", },
 646         { .compatible = "nvidia,tegra20-gr2d", },
 647         { .compatible = "nvidia,tegra20-gr3d", },
 648         { .compatible = "nvidia,tegra30-dc", },
 649         { .compatible = "nvidia,tegra30-hdmi", },
 650         { .compatible = "nvidia,tegra30-gr2d", },
 651         { .compatible = "nvidia,tegra30-gr3d", },
 652         { .compatible = "nvidia,tegra114-hdmi", },
 653         { .compatible = "nvidia,tegra114-gr3d", },
 654         { /* sentinel */ }
 655 };
 656
 657 static struct host1x_driver host1x_drm_driver = {
 658         .name = "drm",
 659         .probe = host1x_drm_probe,
 660         .remove = host1x_drm_remove,
 661         .subdevs = host1x_drm_subdevs,
 662 };
 663
 664 static int __init host1x_drm_init(void)
 665 {
 666         int err;
 667
 668         err = host1x_driver_register(&host1x_drm_driver);
 669         if (err < 0)
 670                 return err;
 671
 672         err = platform_driver_register(&tegra_dc_driver);
 673         if (err < 0)
 674                 goto unregister_host1x;
 675
 676         err = platform_driver_register(&tegra_hdmi_driver);
 677         if (err < 0)
 678                 goto unregister_dc;
 679
 680         err = platform_driver_register(&tegra_gr2d_driver);
 681         if (err < 0)
 682                 goto unregister_hdmi;
 683
 684         err = platform_driver_register(&tegra_gr3d_driver);
 685         if (err < 0)
 686                 goto unregister_gr2d;
 687
 688         return 0;
 689
 690 unregister_gr2d:
 691         platform_driver_unregister(&tegra_gr2d_driver);
 692 unregister_hdmi:
 693         platform_driver_unregister(&tegra_hdmi_driver);
 694 unregister_dc:
 695         platform_driver_unregister(&tegra_dc_driver);
 696 unregister_host1x:
 697         host1x_driver_unregister(&host1x_drm_driver);
 698         return err;
 699 }
 700 module_init(host1x_drm_init);
 701
 702 static void __exit host1x_drm_exit(void)
 703 {
 704         platform_driver_unregister(&tegra_gr3d_driver);
 705         platform_driver_unregister(&tegra_gr2d_driver);
 706         platform_driver_unregister(&tegra_hdmi_driver);
 707         platform_driver_unregister(&tegra_dc_driver);
 708         host1x_driver_unregister(&host1x_drm_driver);
 709 }
 710 module_exit(host1x_drm_exit);
 711
 712 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
 713 MODULE_DESCRIPTION("NVIDIA Tegra DRM driver");
 714 MODULE_LICENSE("GPL v2");