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