drivers/staging/omapdrm/omap_drv.c

   1 /*
   2  * drivers/staging/omapdrm/omap_drv.c
   3  *
   4  * Copyright (C) 2011 Texas Instruments
   5  * Author: Rob Clark <rob@ti.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published by
   9  * the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "omap_drv.h"
  21
  22 #include "drm_crtc_helper.h"
  23 #include "drm_fb_helper.h"
  24 #include "omap_dmm_tiler.h"
  25
  26 #define DRIVER_NAME             MODULE_NAME
  27 #define DRIVER_DESC             "OMAP DRM"
  28 #define DRIVER_DATE             "20110917"
  29 #define DRIVER_MAJOR            1
  30 #define DRIVER_MINOR            0
  31 #define DRIVER_PATCHLEVEL       0
  32
  33 static int num_crtc = CONFIG_DRM_OMAP_NUM_CRTCS;
  34
  35 MODULE_PARM_DESC(num_crtc, "Number of overlays to use as CRTCs");
  36 module_param(num_crtc, int, 0600);
  37
  38 /*
  39  * mode config funcs
  40  */
  41
  42 /* Notes about mapping DSS and DRM entities:
  43  *    CRTC:        overlay
  44  *    encoder:     manager.. with some extension to allow one primary CRTC
  45  *                 and zero or more video CRTC's to be mapped to one encoder?
  46  *    connector:   dssdev.. manager can be attached/detached from different
  47  *                 devices
  48  */
  49
  50 static void omap_fb_output_poll_changed(struct drm_device *dev)
  51 {
  52         struct omap_drm_private *priv = dev->dev_private;
  53         DBG("dev=%p", dev);
  54         if (priv->fbdev)
  55                 drm_fb_helper_hotplug_event(priv->fbdev);
  56 }
  57
  58 static const struct drm_mode_config_funcs omap_mode_config_funcs = {
  59         .fb_create = omap_framebuffer_create,
  60         .output_poll_changed = omap_fb_output_poll_changed,
  61 };
  62
  63 static int get_connector_type(struct omap_dss_device *dssdev)
  64 {
  65         switch (dssdev->type) {
  66         case OMAP_DISPLAY_TYPE_HDMI:
  67                 return DRM_MODE_CONNECTOR_HDMIA;
  68         case OMAP_DISPLAY_TYPE_DPI:
  69                 if (!strcmp(dssdev->name, "dvi"))
  70                         return DRM_MODE_CONNECTOR_DVID;
  71                 /* fallthrough */
  72         default:
  73                 return DRM_MODE_CONNECTOR_Unknown;
  74         }
  75 }
  76
  77 #if 0 /* enable when dss2 supports hotplug */
  78 static int omap_drm_notifier(struct notifier_block *nb,
  79                 unsigned long evt, void *arg)
  80 {
  81         switch (evt) {
  82         case OMAP_DSS_SIZE_CHANGE:
  83         case OMAP_DSS_HOTPLUG_CONNECT:
  84         case OMAP_DSS_HOTPLUG_DISCONNECT: {
  85                 struct drm_device *dev = drm_device;
  86                 DBG("hotplug event: evt=%d, dev=%p", evt, dev);
  87                 if (dev)
  88                         drm_sysfs_hotplug_event(dev);
  89
  90                 return NOTIFY_OK;
  91         }
  92         default:  /* don't care about other events for now */
  93                 return NOTIFY_DONE;
  94         }
  95 }
  96 #endif
  97
  98 static void dump_video_chains(void)
  99 {
 100         int i;
 101
 102         DBG("dumping video chains: ");
 103         for (i = 0; i < omap_dss_get_num_overlays(); i++) {
 104                 struct omap_overlay *ovl = omap_dss_get_overlay(i);
 105                 struct omap_overlay_manager *mgr = ovl->manager;
 106                 struct omap_dss_device *dssdev = mgr ?
 107                                         mgr->get_device(mgr) : NULL;
 108                 if (dssdev) {
 109                         DBG("%d: %s -> %s -> %s", i, ovl->name, mgr->name,
 110                                                 dssdev->name);
 111                 } else if (mgr) {
 112                         DBG("%d: %s -> %s", i, ovl->name, mgr->name);
 113                 } else {
 114                         DBG("%d: %s", i, ovl->name);
 115                 }
 116         }
 117 }
 118
 119 /* create encoders for each manager */
 120 static int create_encoder(struct drm_device *dev,
 121                 struct omap_overlay_manager *mgr)
 122 {
 123         struct omap_drm_private *priv = dev->dev_private;
 124         struct drm_encoder *encoder = omap_encoder_init(dev, mgr);
 125
 126         if (!encoder) {
 127                 dev_err(dev->dev, "could not create encoder: %s\n",
 128                                 mgr->name);
 129                 return -ENOMEM;
 130         }
 131
 132         BUG_ON(priv->num_encoders >= ARRAY_SIZE(priv->encoders));
 133
 134         priv->encoders[priv->num_encoders++] = encoder;
 135
 136         return 0;
 137 }
 138
 139 /* create connectors for each display device */
 140 static int create_connector(struct drm_device *dev,
 141                 struct omap_dss_device *dssdev)
 142 {
 143         struct omap_drm_private *priv = dev->dev_private;
 144         static struct notifier_block *notifier;
 145         struct drm_connector *connector;
 146         int j;
 147
 148         if (!dssdev->driver) {
 149                 dev_warn(dev->dev, "%s has no driver.. skipping it\n",
 150                                 dssdev->name);
 151                 return 0;
 152         }
 153
 154         if (!(dssdev->driver->get_timings ||
 155                                 dssdev->driver->read_edid)) {
 156                 dev_warn(dev->dev, "%s driver does not support "
 157                         "get_timings or read_edid.. skipping it!\n",
 158                         dssdev->name);
 159                 return 0;
 160         }
 161
 162         connector = omap_connector_init(dev,
 163                         get_connector_type(dssdev), dssdev);
 164
 165         if (!connector) {
 166                 dev_err(dev->dev, "could not create connector: %s\n",
 167                                 dssdev->name);
 168                 return -ENOMEM;
 169         }
 170
 171         BUG_ON(priv->num_connectors >= ARRAY_SIZE(priv->connectors));
 172
 173         priv->connectors[priv->num_connectors++] = connector;
 174
 175 #if 0 /* enable when dss2 supports hotplug */
 176         notifier = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
 177         notifier->notifier_call = omap_drm_notifier;
 178         omap_dss_add_notify(dssdev, notifier);
 179 #else
 180         notifier = NULL;
 181 #endif
 182
 183         for (j = 0; j < priv->num_encoders; j++) {
 184                 struct omap_overlay_manager *mgr =
 185                         omap_encoder_get_manager(priv->encoders[j]);
 186                 if (mgr->get_device(mgr) == dssdev) {
 187                         drm_mode_connector_attach_encoder(connector,
 188                                         priv->encoders[j]);
 189                 }
 190         }
 191
 192         return 0;
 193 }
 194
 195 /* create up to max_overlays CRTCs mapping to overlays.. by default,
 196  * connect the overlays to different managers/encoders, giving priority
 197  * to encoders connected to connectors with a detected connection
 198  */
 199 static int create_crtc(struct drm_device *dev, struct omap_overlay *ovl,
 200                 int *j, unsigned int connected_connectors)
 201 {
 202         struct omap_drm_private *priv = dev->dev_private;
 203         struct omap_overlay_manager *mgr = NULL;
 204         struct drm_crtc *crtc;
 205
 206         /* find next best connector, ones with detected connection first
 207          */
 208         while (*j < priv->num_connectors && !mgr) {
 209                 if (connected_connectors & (1 << *j)) {
 210                         struct drm_encoder *encoder =
 211                                 omap_connector_attached_encoder(
 212                                                 priv->connectors[*j]);
 213                         if (encoder)
 214                                 mgr = omap_encoder_get_manager(encoder);
 215
 216                 }
 217                 (*j)++;
 218         }
 219
 220         /* if we couldn't find another connected connector, lets start
 221          * looking at the unconnected connectors:
 222          *
 223          * note: it might not be immediately apparent, but thanks to
 224          * the !mgr check in both this loop and the one above, the only
 225          * way to enter this loop is with *j == priv->num_connectors,
 226          * so idx can never go negative.
 227          */
 228         while (*j < 2 * priv->num_connectors && !mgr) {
 229                 int idx = *j - priv->num_connectors;
 230                 if (!(connected_connectors & (1 << idx))) {
 231                         struct drm_encoder *encoder =
 232                                 omap_connector_attached_encoder(
 233                                                 priv->connectors[idx]);
 234                         if (encoder)
 235                                 mgr = omap_encoder_get_manager(encoder);
 236
 237                 }
 238                 (*j)++;
 239         }
 240
 241         crtc = omap_crtc_init(dev, ovl, priv->num_crtcs);
 242
 243         if (!crtc) {
 244                 dev_err(dev->dev, "could not create CRTC: %s\n",
 245                                 ovl->name);
 246                 return -ENOMEM;
 247         }
 248
 249         BUG_ON(priv->num_crtcs >= ARRAY_SIZE(priv->crtcs));
 250
 251         priv->crtcs[priv->num_crtcs++] = crtc;
 252
 253         return 0;
 254 }
 255
 256 static int create_plane(struct drm_device *dev, struct omap_overlay *ovl,
 257                 unsigned int possible_crtcs)
 258 {
 259         struct omap_drm_private *priv = dev->dev_private;
 260         struct drm_plane *plane =
 261                         omap_plane_init(dev, ovl, possible_crtcs, false);
 262
 263         if (!plane) {
 264                 dev_err(dev->dev, "could not create plane: %s\n",
 265                                 ovl->name);
 266                 return -ENOMEM;
 267         }
 268
 269         BUG_ON(priv->num_planes >= ARRAY_SIZE(priv->planes));
 270
 271         priv->planes[priv->num_planes++] = plane;
 272
 273         return 0;
 274 }
 275
 276 static int match_dev_name(struct omap_dss_device *dssdev, void *data)
 277 {
 278         return !strcmp(dssdev->name, data);
 279 }
 280
 281 static unsigned int detect_connectors(struct drm_device *dev)
 282 {
 283         struct omap_drm_private *priv = dev->dev_private;
 284         unsigned int connected_connectors = 0;
 285         int i;
 286
 287         for (i = 0; i < priv->num_connectors; i++) {
 288                 struct drm_connector *connector = priv->connectors[i];
 289                 if (omap_connector_detect(connector, true) ==
 290                                 connector_status_connected) {
 291                         connected_connectors |= (1 << i);
 292                 }
 293         }
 294
 295         return connected_connectors;
 296 }
 297
 298 static int omap_modeset_init(struct drm_device *dev)
 299 {
 300         const struct omap_drm_platform_data *pdata = dev->dev->platform_data;
 301         struct omap_kms_platform_data *kms_pdata = NULL;
 302         struct omap_drm_private *priv = dev->dev_private;
 303         struct omap_dss_device *dssdev = NULL;
 304         int i, j;
 305         unsigned int connected_connectors = 0;
 306
 307         drm_mode_config_init(dev);
 308
 309         if (pdata && pdata->kms_pdata) {
 310                 kms_pdata = pdata->kms_pdata;
 311
 312                 /* if platform data is provided by the board file, use it to
 313                  * control which overlays, managers, and devices we own.
 314                  */
 315                 for (i = 0; i < kms_pdata->mgr_cnt; i++) {
 316                         struct omap_overlay_manager *mgr =
 317                                 omap_dss_get_overlay_manager(
 318                                                 kms_pdata->mgr_ids[i]);
 319                         create_encoder(dev, mgr);
 320                 }
 321
 322                 for (i = 0; i < kms_pdata->dev_cnt; i++) {
 323                         struct omap_dss_device *dssdev =
 324                                 omap_dss_find_device(
 325                                         (void *)kms_pdata->dev_names[i],
 326                                         match_dev_name);
 327                         if (!dssdev) {
 328                                 dev_warn(dev->dev, "no such dssdev: %s\n",
 329                                                 kms_pdata->dev_names[i]);
 330                                 continue;
 331                         }
 332                         create_connector(dev, dssdev);
 333                 }
 334
 335                 connected_connectors = detect_connectors(dev);
 336
 337                 j = 0;
 338                 for (i = 0; i < kms_pdata->ovl_cnt; i++) {
 339                         struct omap_overlay *ovl =
 340                                 omap_dss_get_overlay(kms_pdata->ovl_ids[i]);
 341                         create_crtc(dev, ovl, &j, connected_connectors);
 342                 }
 343
 344                 for (i = 0; i < kms_pdata->pln_cnt; i++) {
 345                         struct omap_overlay *ovl =
 346                                 omap_dss_get_overlay(kms_pdata->pln_ids[i]);
 347                         create_plane(dev, ovl, (1 << priv->num_crtcs) - 1);
 348                 }
 349         } else {
 350                 /* otherwise just grab up to CONFIG_DRM_OMAP_NUM_CRTCS and try
 351                  * to make educated guesses about everything else
 352                  */
 353                 int max_overlays = min(omap_dss_get_num_overlays(), num_crtc);
 354
 355                 for (i = 0; i < omap_dss_get_num_overlay_managers(); i++)
 356                         create_encoder(dev, omap_dss_get_overlay_manager(i));
 357
 358                 for_each_dss_dev(dssdev) {
 359                         create_connector(dev, dssdev);
 360                 }
 361
 362                 connected_connectors = detect_connectors(dev);
 363
 364                 j = 0;
 365                 for (i = 0; i < max_overlays; i++) {
 366                         create_crtc(dev, omap_dss_get_overlay(i),
 367                                         &j, connected_connectors);
 368                 }
 369
 370                 /* use any remaining overlays as drm planes */
 371                 for (; i < omap_dss_get_num_overlays(); i++) {
 372                         struct omap_overlay *ovl = omap_dss_get_overlay(i);
 373                         create_plane(dev, ovl, (1 << priv->num_crtcs) - 1);
 374                 }
 375         }
 376
 377         /* for now keep the mapping of CRTCs and encoders static.. */
 378         for (i = 0; i < priv->num_encoders; i++) {
 379                 struct drm_encoder *encoder = priv->encoders[i];
 380                 struct omap_overlay_manager *mgr =
 381                                 omap_encoder_get_manager(encoder);
 382
 383                 encoder->possible_crtcs = (1 << priv->num_crtcs) - 1;
 384
 385                 DBG("%s: possible_crtcs=%08x", mgr->name,
 386                                         encoder->possible_crtcs);
 387         }
 388
 389         dump_video_chains();
 390
 391         dev->mode_config.min_width = 32;
 392         dev->mode_config.min_height = 32;
 393
 394         /* note: eventually will need some cpu_is_omapXYZ() type stuff here
 395          * to fill in these limits properly on different OMAP generations..
 396          */
 397         dev->mode_config.max_width = 2048;
 398         dev->mode_config.max_height = 2048;
 399
 400         dev->mode_config.funcs = &omap_mode_config_funcs;
 401
 402         return 0;
 403 }
 404
 405 static void omap_modeset_free(struct drm_device *dev)
 406 {
 407         drm_mode_config_cleanup(dev);
 408 }
 409
 410 /*
 411  * drm ioctl funcs
 412  */
 413
 414
 415 static int ioctl_get_param(struct drm_device *dev, void *data,
 416                 struct drm_file *file_priv)
 417 {
 418         struct omap_drm_private *priv = dev->dev_private;
 419         struct drm_omap_param *args = data;
 420
 421         DBG("%p: param=%llu", dev, args->param);
 422
 423         switch (args->param) {
 424         case OMAP_PARAM_CHIPSET_ID:
 425                 args->value = priv->omaprev;
 426                 break;
 427         default:
 428                 DBG("unknown parameter %lld", args->param);
 429                 return -EINVAL;
 430         }
 431
 432         return 0;
 433 }
 434
 435 static int ioctl_set_param(struct drm_device *dev, void *data,
 436                 struct drm_file *file_priv)
 437 {
 438         struct drm_omap_param *args = data;
 439
 440         switch (args->param) {
 441         default:
 442                 DBG("unknown parameter %lld", args->param);
 443                 return -EINVAL;
 444         }
 445
 446         return 0;
 447 }
 448
 449 static int ioctl_gem_new(struct drm_device *dev, void *data,
 450                 struct drm_file *file_priv)
 451 {
 452         struct drm_omap_gem_new *args = data;
 453         DBG("%p:%p: size=0x%08x, flags=%08x", dev, file_priv,
 454                         args->size.bytes, args->flags);
 455         return omap_gem_new_handle(dev, file_priv, args->size,
 456                         args->flags, &args->handle);
 457 }
 458
 459 static int ioctl_gem_cpu_prep(struct drm_device *dev, void *data,
 460                 struct drm_file *file_priv)
 461 {
 462         struct drm_omap_gem_cpu_prep *args = data;
 463         struct drm_gem_object *obj;
 464         int ret;
 465
 466         VERB("%p:%p: handle=%d, op=%x", dev, file_priv, args->handle, args->op);
 467
 468         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 469         if (!obj)
 470                 return -ENOENT;
 471
 472         ret = omap_gem_op_sync(obj, args->op);
 473
 474         if (!ret)
 475                 ret = omap_gem_op_start(obj, args->op);
 476
 477         drm_gem_object_unreference_unlocked(obj);
 478
 479         return ret;
 480 }
 481
 482 static int ioctl_gem_cpu_fini(struct drm_device *dev, void *data,
 483                 struct drm_file *file_priv)
 484 {
 485         struct drm_omap_gem_cpu_fini *args = data;
 486         struct drm_gem_object *obj;
 487         int ret;
 488
 489         VERB("%p:%p: handle=%d", dev, file_priv, args->handle);
 490
 491         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 492         if (!obj)
 493                 return -ENOENT;
 494
 495         /* XXX flushy, flushy */
 496         ret = 0;
 497
 498         if (!ret)
 499                 ret = omap_gem_op_finish(obj, args->op);
 500
 501         drm_gem_object_unreference_unlocked(obj);
 502
 503         return ret;
 504 }
 505
 506 static int ioctl_gem_info(struct drm_device *dev, void *data,
 507                 struct drm_file *file_priv)
 508 {
 509         struct drm_omap_gem_info *args = data;
 510         struct drm_gem_object *obj;
 511         int ret = 0;
 512
 513         DBG("%p:%p: handle=%d", dev, file_priv, args->handle);
 514
 515         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 516         if (!obj)
 517                 return -ENOENT;
 518
 519         args->size = omap_gem_mmap_size(obj);
 520         args->offset = omap_gem_mmap_offset(obj);
 521
 522         drm_gem_object_unreference_unlocked(obj);
 523
 524         return ret;
 525 }
 526
 527 struct drm_ioctl_desc ioctls[DRM_COMMAND_END - DRM_COMMAND_BASE] = {
 528         DRM_IOCTL_DEF_DRV(OMAP_GET_PARAM, ioctl_get_param, DRM_UNLOCKED|DRM_AUTH),
 529         DRM_IOCTL_DEF_DRV(OMAP_SET_PARAM, ioctl_set_param, DRM_UNLOCKED|DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 530         DRM_IOCTL_DEF_DRV(OMAP_GEM_NEW, ioctl_gem_new, DRM_UNLOCKED|DRM_AUTH),
 531         DRM_IOCTL_DEF_DRV(OMAP_GEM_CPU_PREP, ioctl_gem_cpu_prep, DRM_UNLOCKED|DRM_AUTH),
 532         DRM_IOCTL_DEF_DRV(OMAP_GEM_CPU_FINI, ioctl_gem_cpu_fini, DRM_UNLOCKED|DRM_AUTH),
 533         DRM_IOCTL_DEF_DRV(OMAP_GEM_INFO, ioctl_gem_info, DRM_UNLOCKED|DRM_AUTH),
 534 };
 535
 536 /*
 537  * drm driver funcs
 538  */
 539
 540 /**
 541  * load - setup chip and create an initial config
 542  * @dev: DRM device
 543  * @flags: startup flags
 544  *
 545  * The driver load routine has to do several things:
 546  *   - initialize the memory manager
 547  *   - allocate initial config memory
 548  *   - setup the DRM framebuffer with the allocated memory
 549  */
 550 static int dev_load(struct drm_device *dev, unsigned long flags)
 551 {
 552         struct omap_drm_platform_data *pdata = dev->dev->platform_data;
 553         struct omap_drm_private *priv;
 554         int ret;
 555
 556         DBG("load: dev=%p", dev);
 557
 558         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 559         if (!priv) {
 560                 dev_err(dev->dev, "could not allocate priv\n");
 561                 return -ENOMEM;
 562         }
 563
 564         priv->omaprev = pdata->omaprev;
 565
 566         dev->dev_private = priv;
 567
 568         priv->wq = alloc_ordered_workqueue("omapdrm", 0);
 569
 570         INIT_LIST_HEAD(&priv->obj_list);
 571
 572         omap_gem_init(dev);
 573
 574         ret = omap_modeset_init(dev);
 575         if (ret) {
 576                 dev_err(dev->dev, "omap_modeset_init failed: ret=%d\n", ret);
 577                 dev->dev_private = NULL;
 578                 kfree(priv);
 579                 return ret;
 580         }
 581
 582         priv->fbdev = omap_fbdev_init(dev);
 583         if (!priv->fbdev) {
 584                 dev_warn(dev->dev, "omap_fbdev_init failed\n");
 585                 /* well, limp along without an fbdev.. maybe X11 will work? */
 586         }
 587
 588         drm_kms_helper_poll_init(dev);
 589
 590         ret = drm_vblank_init(dev, priv->num_crtcs);
 591         if (ret)
 592                 dev_warn(dev->dev, "could not init vblank\n");
 593
 594         return 0;
 595 }
 596
 597 static int dev_unload(struct drm_device *dev)
 598 {
 599         struct omap_drm_private *priv = dev->dev_private;
 600
 601         DBG("unload: dev=%p", dev);
 602
 603         drm_vblank_cleanup(dev);
 604         drm_kms_helper_poll_fini(dev);
 605
 606         omap_fbdev_free(dev);
 607         omap_modeset_free(dev);
 608         omap_gem_deinit(dev);
 609
 610         flush_workqueue(priv->wq);
 611         destroy_workqueue(priv->wq);
 612
 613         kfree(dev->dev_private);
 614         dev->dev_private = NULL;
 615
 616         return 0;
 617 }
 618
 619 static int dev_open(struct drm_device *dev, struct drm_file *file)
 620 {
 621         file->driver_priv = NULL;
 622
 623         DBG("open: dev=%p, file=%p", dev, file);
 624
 625         return 0;
 626 }
 627
 628 static int dev_firstopen(struct drm_device *dev)
 629 {
 630         DBG("firstopen: dev=%p", dev);
 631         return 0;
 632 }
 633
 634 /**
 635  * lastclose - clean up after all DRM clients have exited
 636  * @dev: DRM device
 637  *
 638  * Take care of cleaning up after all DRM clients have exited.  In the
 639  * mode setting case, we want to restore the kernel's initial mode (just
 640  * in case the last client left us in a bad state).
 641  */
 642 static void dev_lastclose(struct drm_device *dev)
 643 {
 644         int i;
 645
 646         /* we don't support vga-switcheroo.. so just make sure the fbdev
 647          * mode is active
 648          */
 649         struct omap_drm_private *priv = dev->dev_private;
 650         int ret;
 651
 652         DBG("lastclose: dev=%p", dev);
 653
 654         if (priv->rotation_prop) {
 655                 /* need to restore default rotation state.. not sure
 656                  * if there is a cleaner way to restore properties to
 657                  * default state?  Maybe a flag that properties should
 658                  * automatically be restored to default state on
 659                  * lastclose?
 660                  */
 661                 for (i = 0; i < priv->num_crtcs; i++) {
 662                         drm_object_property_set_value(&priv->crtcs[i]->base,
 663                                         priv->rotation_prop, 0);
 664                 }
 665
 666                 for (i = 0; i < priv->num_planes; i++) {
 667                         drm_object_property_set_value(&priv->planes[i]->base,
 668                                         priv->rotation_prop, 0);
 669                 }
 670         }
 671
 672         ret = drm_fb_helper_restore_fbdev_mode(priv->fbdev);
 673         if (ret)
 674                 DBG("failed to restore crtc mode");
 675 }
 676
 677 static void dev_preclose(struct drm_device *dev, struct drm_file *file)
 678 {
 679         DBG("preclose: dev=%p", dev);
 680 }
 681
 682 static void dev_postclose(struct drm_device *dev, struct drm_file *file)
 683 {
 684         DBG("postclose: dev=%p, file=%p", dev, file);
 685 }
 686
 687 /**
 688  * enable_vblank - enable vblank interrupt events
 689  * @dev: DRM device
 690  * @crtc: which irq to enable
 691  *
 692  * Enable vblank interrupts for @crtc.  If the device doesn't have
 693  * a hardware vblank counter, this routine should be a no-op, since
 694  * interrupts will have to stay on to keep the count accurate.
 695  *
 696  * RETURNS
 697  * Zero on success, appropriate errno if the given @crtc's vblank
 698  * interrupt cannot be enabled.
 699  */
 700 static int dev_enable_vblank(struct drm_device *dev, int crtc)
 701 {
 702         DBG("enable_vblank: dev=%p, crtc=%d", dev, crtc);
 703         return 0;
 704 }
 705
 706 /**
 707  * disable_vblank - disable vblank interrupt events
 708  * @dev: DRM device
 709  * @crtc: which irq to enable
 710  *
 711  * Disable vblank interrupts for @crtc.  If the device doesn't have
 712  * a hardware vblank counter, this routine should be a no-op, since
 713  * interrupts will have to stay on to keep the count accurate.
 714  */
 715 static void dev_disable_vblank(struct drm_device *dev, int crtc)
 716 {
 717         DBG("disable_vblank: dev=%p, crtc=%d", dev, crtc);
 718 }
 719
 720 static irqreturn_t dev_irq_handler(DRM_IRQ_ARGS)
 721 {
 722         return IRQ_HANDLED;
 723 }
 724
 725 static void dev_irq_preinstall(struct drm_device *dev)
 726 {
 727         DBG("irq_preinstall: dev=%p", dev);
 728 }
 729
 730 static int dev_irq_postinstall(struct drm_device *dev)
 731 {
 732         DBG("irq_postinstall: dev=%p", dev);
 733         return 0;
 734 }
 735
 736 static void dev_irq_uninstall(struct drm_device *dev)
 737 {
 738         DBG("irq_uninstall: dev=%p", dev);
 739 }
 740
 741 static const struct vm_operations_struct omap_gem_vm_ops = {
 742         .fault = omap_gem_fault,
 743         .open = drm_gem_vm_open,
 744         .close = drm_gem_vm_close,
 745 };
 746
 747 static const struct file_operations omapdriver_fops = {
 748                 .owner = THIS_MODULE,
 749                 .open = drm_open,
 750                 .unlocked_ioctl = drm_ioctl,
 751                 .release = drm_release,
 752                 .mmap = omap_gem_mmap,
 753                 .poll = drm_poll,
 754                 .fasync = drm_fasync,
 755                 .read = drm_read,
 756                 .llseek = noop_llseek,
 757 };
 758
 759 static struct drm_driver omap_drm_driver = {
 760                 .driver_features =
 761                                 DRIVER_HAVE_IRQ | DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
 762                 .load = dev_load,
 763                 .unload = dev_unload,
 764                 .open = dev_open,
 765                 .firstopen = dev_firstopen,
 766                 .lastclose = dev_lastclose,
 767                 .preclose = dev_preclose,
 768                 .postclose = dev_postclose,
 769                 .get_vblank_counter = drm_vblank_count,
 770                 .enable_vblank = dev_enable_vblank,
 771                 .disable_vblank = dev_disable_vblank,
 772                 .irq_preinstall = dev_irq_preinstall,
 773                 .irq_postinstall = dev_irq_postinstall,
 774                 .irq_uninstall = dev_irq_uninstall,
 775                 .irq_handler = dev_irq_handler,
 776 #ifdef CONFIG_DEBUG_FS
 777                 .debugfs_init = omap_debugfs_init,
 778                 .debugfs_cleanup = omap_debugfs_cleanup,
 779 #endif
 780                 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
 781                 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
 782                 .gem_prime_export = omap_gem_prime_export,
 783                 .gem_prime_import = omap_gem_prime_import,
 784                 .gem_init_object = omap_gem_init_object,
 785                 .gem_free_object = omap_gem_free_object,
 786                 .gem_vm_ops = &omap_gem_vm_ops,
 787                 .dumb_create = omap_gem_dumb_create,
 788                 .dumb_map_offset = omap_gem_dumb_map_offset,
 789                 .dumb_destroy = omap_gem_dumb_destroy,
 790                 .ioctls = ioctls,
 791                 .num_ioctls = DRM_OMAP_NUM_IOCTLS,
 792                 .fops = &omapdriver_fops,
 793                 .name = DRIVER_NAME,
 794                 .desc = DRIVER_DESC,
 795                 .date = DRIVER_DATE,
 796                 .major = DRIVER_MAJOR,
 797                 .minor = DRIVER_MINOR,
 798                 .patchlevel = DRIVER_PATCHLEVEL,
 799 };
 800
 801 static int pdev_suspend(struct platform_device *pDevice, pm_message_t state)
 802 {
 803         DBG("");
 804         return 0;
 805 }
 806
 807 static int pdev_resume(struct platform_device *device)
 808 {
 809         DBG("");
 810         return 0;
 811 }
 812
 813 static void pdev_shutdown(struct platform_device *device)
 814 {
 815         DBG("");
 816 }
 817
 818 static int pdev_probe(struct platform_device *device)
 819 {
 820         DBG("%s", device->name);
 821         return drm_platform_init(&omap_drm_driver, device);
 822 }
 823
 824 static int pdev_remove(struct platform_device *device)
 825 {
 826         DBG("");
 827         drm_platform_exit(&omap_drm_driver, device);
 828
 829         platform_driver_unregister(&omap_dmm_driver);
 830         return 0;
 831 }
 832
 833 struct platform_driver pdev = {
 834                 .driver = {
 835                         .name = DRIVER_NAME,
 836                         .owner = THIS_MODULE,
 837                 },
 838                 .probe = pdev_probe,
 839                 .remove = pdev_remove,
 840                 .suspend = pdev_suspend,
 841                 .resume = pdev_resume,
 842                 .shutdown = pdev_shutdown,
 843 };
 844
 845 static int __init omap_drm_init(void)
 846 {
 847         DBG("init");
 848         if (platform_driver_register(&omap_dmm_driver)) {
 849                 /* we can continue on without DMM.. so not fatal */
 850                 dev_err(NULL, "DMM registration failed\n");
 851         }
 852         return platform_driver_register(&pdev);
 853 }
 854
 855 static void __exit omap_drm_fini(void)
 856 {
 857         DBG("fini");
 858         platform_driver_unregister(&pdev);
 859 }
 860
 861 /* need late_initcall() so we load after dss_driver's are loaded */
 862 late_initcall(omap_drm_init);
 863 module_exit(omap_drm_fini);
 864
 865 MODULE_AUTHOR("Rob Clark <rob@ti.com>");
 866 MODULE_DESCRIPTION("OMAP DRM Display Driver");
 867 MODULE_ALIAS("platform:" DRIVER_NAME);
 868 MODULE_LICENSE("GPL v2");