exynos_drm_drv.c 18.8 KB
Newer Older
1 2 3 4 5 6 7
/*
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 * Authors:
 *	Inki Dae <inki.dae@samsung.com>
 *	Joonyoung Shim <jy0922.shim@samsung.com>
 *	Seung-Woo Kim <sw0312.kim@samsung.com>
 *
8 9 10 11
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
12 13
 */

14
#include <linux/pm_runtime.h>
15 16
#include <drm/drmP.h>
#include <drm/drm_crtc_helper.h>
17

18
#include <linux/anon_inodes.h>
19
#include <linux/component.h>
20

21 22 23 24
#include <drm/exynos_drm.h>

#include "exynos_drm_drv.h"
#include "exynos_drm_crtc.h"
25
#include "exynos_drm_encoder.h"
26 27 28
#include "exynos_drm_fbdev.h"
#include "exynos_drm_fb.h"
#include "exynos_drm_gem.h"
29
#include "exynos_drm_plane.h"
30
#include "exynos_drm_vidi.h"
I
Inki Dae 已提交
31
#include "exynos_drm_dmabuf.h"
J
Joonyoung Shim 已提交
32
#include "exynos_drm_g2d.h"
E
Eunchul Kim 已提交
33
#include "exynos_drm_ipp.h"
34
#include "exynos_drm_iommu.h"
35

I
Inki Dae 已提交
36
#define DRIVER_NAME	"exynos"
37 38 39 40 41
#define DRIVER_DESC	"Samsung SoC DRM"
#define DRIVER_DATE	"20110530"
#define DRIVER_MAJOR	1
#define DRIVER_MINOR	0

42 43
static struct platform_device *exynos_drm_pdev;

44 45 46 47 48
static DEFINE_MUTEX(drm_component_lock);
static LIST_HEAD(drm_component_list);

struct component_dev {
	struct list_head list;
49 50 51 52
	struct device *crtc_dev;
	struct device *conn_dev;
	enum exynos_drm_output_type out_type;
	unsigned int dev_type_flag;
53 54
};

55 56 57 58 59 60 61
static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
{
	struct exynos_drm_private *private;
	int ret;
	int nr;

	private = kzalloc(sizeof(struct exynos_drm_private), GFP_KERNEL);
62
	if (!private)
63 64 65
		return -ENOMEM;

	INIT_LIST_HEAD(&private->pageflip_event_list);
66
	dev_set_drvdata(dev->dev, dev);
67 68
	dev->dev_private = (void *)private;

69 70 71 72 73 74 75 76 77
	/*
	 * create mapping to manage iommu table and set a pointer to iommu
	 * mapping structure to iommu_mapping of private data.
	 * also this iommu_mapping can be used to check if iommu is supported
	 * or not.
	 */
	ret = drm_create_iommu_mapping(dev);
	if (ret < 0) {
		DRM_ERROR("failed to create iommu mapping.\n");
78
		goto err_free_private;
79 80
	}

81 82 83 84
	drm_mode_config_init(dev);

	exynos_drm_mode_config_init(dev);

85
	for (nr = 0; nr < MAX_PLANE; nr++) {
86
		struct drm_plane *plane;
87
		unsigned long possible_crtcs = (1 << MAX_CRTC) - 1;
88 89 90

		plane = exynos_plane_init(dev, possible_crtcs, false);
		if (!plane)
91
			goto err_mode_config_cleanup;
92 93
	}

94 95 96
	/* init kms poll for handling hpd */
	drm_kms_helper_poll_init(dev);

97 98
	ret = drm_vblank_init(dev, MAX_CRTC);
	if (ret)
99
		goto err_mode_config_cleanup;
100

101 102 103
	/* setup possible_clones. */
	exynos_drm_encoder_setup(dev);

104 105
	platform_set_drvdata(dev->platformdev, dev);

106 107 108 109 110
	/* Try to bind all sub drivers. */
	ret = component_bind_all(dev->dev, dev);
	if (ret)
		goto err_cleanup_vblank;

111
	/* Probe non kms sub drivers and virtual display driver. */
112 113 114 115
	ret = exynos_drm_device_subdrv_probe(dev);
	if (ret)
		goto err_unbind_all;

116 117 118
	/* force connectors detection */
	drm_helper_hpd_irq_event(dev);

119 120
	return 0;

121 122 123
err_unbind_all:
	component_unbind_all(dev->dev, dev);
err_cleanup_vblank:
124
	drm_vblank_cleanup(dev);
125 126
err_mode_config_cleanup:
	drm_mode_config_cleanup(dev);
127
	drm_release_iommu_mapping(dev);
128
err_free_private:
129 130 131 132 133 134 135
	kfree(private);

	return ret;
}

static int exynos_drm_unload(struct drm_device *dev)
{
136 137
	exynos_drm_device_subdrv_remove(dev);

138 139
	exynos_drm_fbdev_fini(dev);
	drm_vblank_cleanup(dev);
140
	drm_kms_helper_poll_fini(dev);
141
	drm_mode_config_cleanup(dev);
142 143

	drm_release_iommu_mapping(dev);
144 145
	kfree(dev->dev_private);

146
	component_unbind_all(dev->dev, dev);
147 148 149 150 151
	dev->dev_private = NULL;

	return 0;
}

152 153 154 155
static const struct file_operations exynos_drm_gem_fops = {
	.mmap = exynos_drm_gem_mmap_buffer,
};

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
static int exynos_drm_suspend(struct drm_device *dev, pm_message_t state)
{
	struct drm_connector *connector;

	drm_modeset_lock_all(dev);
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		int old_dpms = connector->dpms;

		if (connector->funcs->dpms)
			connector->funcs->dpms(connector, DRM_MODE_DPMS_OFF);

		/* Set the old mode back to the connector for resume */
		connector->dpms = old_dpms;
	}
	drm_modeset_unlock_all(dev);

	return 0;
}

static int exynos_drm_resume(struct drm_device *dev)
{
	struct drm_connector *connector;

	drm_modeset_lock_all(dev);
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (connector->funcs->dpms)
			connector->funcs->dpms(connector, connector->dpms);
	}
184
	drm_modeset_unlock_all(dev);
185 186 187 188 189 190

	drm_helper_resume_force_mode(dev);

	return 0;
}

191 192
static int exynos_drm_open(struct drm_device *dev, struct drm_file *file)
{
J
Joonyoung Shim 已提交
193
	struct drm_exynos_file_private *file_priv;
194
	struct file *anon_filp;
195
	int ret;
J
Joonyoung Shim 已提交
196 197 198 199 200 201

	file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
	if (!file_priv)
		return -ENOMEM;

	file->driver_priv = file_priv;
I
Inki Dae 已提交
202

203
	ret = exynos_drm_subdrv_open(dev, file);
204
	if (ret)
205
		goto err_file_priv_free;
206

207 208 209
	anon_filp = anon_inode_getfile("exynos_gem", &exynos_drm_gem_fops,
					NULL, 0);
	if (IS_ERR(anon_filp)) {
210
		ret = PTR_ERR(anon_filp);
211
		goto err_subdrv_close;
212 213 214 215 216
	}

	anon_filp->f_mode = FMODE_READ | FMODE_WRITE;
	file_priv->anon_filp = anon_filp;

217
	return ret;
218 219 220 221 222

err_subdrv_close:
	exynos_drm_subdrv_close(dev, file);

err_file_priv_free:
223 224
	kfree(file_priv);
	file->driver_priv = NULL;
225
	return ret;
226 227
}

I
Inki Dae 已提交
228
static void exynos_drm_preclose(struct drm_device *dev,
229
					struct drm_file *file)
230 231 232 233 234
{
	exynos_drm_subdrv_close(dev, file);
}

static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
I
Inki Dae 已提交
235
{
236
	struct exynos_drm_private *private = dev->dev_private;
237
	struct drm_exynos_file_private *file_priv;
238 239
	struct drm_pending_vblank_event *v, *vt;
	struct drm_pending_event *e, *et;
240 241
	unsigned long flags;

242 243 244 245
	if (!file->driver_priv)
		return;

	/* Release all events not unhandled by page flip handler. */
246
	spin_lock_irqsave(&dev->event_lock, flags);
247
	list_for_each_entry_safe(v, vt, &private->pageflip_event_list,
248
			base.link) {
249 250 251 252
		if (v->base.file_priv == file) {
			list_del(&v->base.link);
			drm_vblank_put(dev, v->pipe);
			v->base.destroy(&v->base);
253 254
		}
	}
255

256 257 258 259 260 261
	/* Release all events handled by page flip handler but not freed. */
	list_for_each_entry_safe(e, et, &file->event_list, link) {
		list_del(&e->link);
		e->destroy(e);
	}
	spin_unlock_irqrestore(&dev->event_lock, flags);
I
Inki Dae 已提交
262

263 264 265
	file_priv = file->driver_priv;
	if (file_priv->anon_filp)
		fput(file_priv->anon_filp);
266 267 268 269 270

	kfree(file->driver_priv);
	file->driver_priv = NULL;
}

271 272 273 274 275
static void exynos_drm_lastclose(struct drm_device *dev)
{
	exynos_drm_fbdev_restore_mode(dev);
}

276
static const struct vm_operations_struct exynos_drm_gem_vm_ops = {
277 278 279 280 281
	.fault = exynos_drm_gem_fault,
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
};

R
Rob Clark 已提交
282
static const struct drm_ioctl_desc exynos_ioctls[] = {
283 284 285 286 287 288 289
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_CREATE, exynos_drm_gem_create_ioctl,
			DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MAP_OFFSET,
			exynos_drm_gem_map_offset_ioctl, DRM_UNLOCKED |
			DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_MMAP,
			exynos_drm_gem_mmap_ioctl, DRM_UNLOCKED | DRM_AUTH),
290 291
	DRM_IOCTL_DEF_DRV(EXYNOS_GEM_GET,
			exynos_drm_gem_get_ioctl, DRM_UNLOCKED),
292 293
	DRM_IOCTL_DEF_DRV(EXYNOS_VIDI_CONNECTION,
			vidi_connection_ioctl, DRM_UNLOCKED | DRM_AUTH),
J
Joonyoung Shim 已提交
294 295 296 297 298 299
	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_GET_VER,
			exynos_g2d_get_ver_ioctl, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_SET_CMDLIST,
			exynos_g2d_set_cmdlist_ioctl, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_G2D_EXEC,
			exynos_g2d_exec_ioctl, DRM_UNLOCKED | DRM_AUTH),
E
Eunchul Kim 已提交
300 301 302 303 304 305 306 307
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_GET_PROPERTY,
			exynos_drm_ipp_get_property, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_SET_PROPERTY,
			exynos_drm_ipp_set_property, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_QUEUE_BUF,
			exynos_drm_ipp_queue_buf, DRM_UNLOCKED | DRM_AUTH),
	DRM_IOCTL_DEF_DRV(EXYNOS_IPP_CMD_CTRL,
			exynos_drm_ipp_cmd_ctrl, DRM_UNLOCKED | DRM_AUTH),
308 309
};

J
Joonyoung Shim 已提交
310 311 312 313 314 315 316
static const struct file_operations exynos_drm_driver_fops = {
	.owner		= THIS_MODULE,
	.open		= drm_open,
	.mmap		= exynos_drm_gem_mmap,
	.poll		= drm_poll,
	.read		= drm_read,
	.unlocked_ioctl	= drm_ioctl,
317 318 319
#ifdef CONFIG_COMPAT
	.compat_ioctl = drm_compat_ioctl,
#endif
J
Joonyoung Shim 已提交
320 321 322
	.release	= drm_release,
};

323
static struct drm_driver exynos_drm_driver = {
324
	.driver_features	= DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
325 326
	.load			= exynos_drm_load,
	.unload			= exynos_drm_unload,
327 328
	.suspend		= exynos_drm_suspend,
	.resume			= exynos_drm_resume,
329
	.open			= exynos_drm_open,
I
Inki Dae 已提交
330
	.preclose		= exynos_drm_preclose,
331
	.lastclose		= exynos_drm_lastclose,
332
	.postclose		= exynos_drm_postclose,
333 334 335 336 337 338 339
	.get_vblank_counter	= drm_vblank_count,
	.enable_vblank		= exynos_drm_crtc_enable_vblank,
	.disable_vblank		= exynos_drm_crtc_disable_vblank,
	.gem_free_object	= exynos_drm_gem_free_object,
	.gem_vm_ops		= &exynos_drm_gem_vm_ops,
	.dumb_create		= exynos_drm_gem_dumb_create,
	.dumb_map_offset	= exynos_drm_gem_dumb_map_offset,
340
	.dumb_destroy		= drm_gem_dumb_destroy,
I
Inki Dae 已提交
341 342 343 344
	.prime_handle_to_fd	= drm_gem_prime_handle_to_fd,
	.prime_fd_to_handle	= drm_gem_prime_fd_to_handle,
	.gem_prime_export	= exynos_dmabuf_prime_export,
	.gem_prime_import	= exynos_dmabuf_prime_import,
345
	.ioctls			= exynos_ioctls,
R
Rob Clark 已提交
346
	.num_ioctls		= ARRAY_SIZE(exynos_ioctls),
J
Joonyoung Shim 已提交
347
	.fops			= &exynos_drm_driver_fops,
348 349 350 351 352 353 354
	.name	= DRIVER_NAME,
	.desc	= DRIVER_DESC,
	.date	= DRIVER_DATE,
	.major	= DRIVER_MAJOR,
	.minor	= DRIVER_MINOR,
};

355 356 357 358 359 360
#ifdef CONFIG_PM_SLEEP
static int exynos_drm_sys_suspend(struct device *dev)
{
	struct drm_device *drm_dev = dev_get_drvdata(dev);
	pm_message_t message;

361
	if (pm_runtime_suspended(dev) || !drm_dev)
362 363 364 365 366 367 368 369 370 371
		return 0;

	message.event = PM_EVENT_SUSPEND;
	return exynos_drm_suspend(drm_dev, message);
}

static int exynos_drm_sys_resume(struct device *dev)
{
	struct drm_device *drm_dev = dev_get_drvdata(dev);

372
	if (pm_runtime_suspended(dev) || !drm_dev)
373 374 375 376 377 378 379 380 381 382
		return 0;

	return exynos_drm_resume(drm_dev);
}
#endif

static const struct dev_pm_ops exynos_drm_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(exynos_drm_sys_suspend, exynos_drm_sys_resume)
};

383
int exynos_drm_component_add(struct device *dev,
384 385
				enum exynos_drm_device_type dev_type,
				enum exynos_drm_output_type out_type)
386 387
{
	struct component_dev *cdev;
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430

	if (dev_type != EXYNOS_DEVICE_TYPE_CRTC &&
			dev_type != EXYNOS_DEVICE_TYPE_CONNECTOR) {
		DRM_ERROR("invalid device type.\n");
		return -EINVAL;
	}

	mutex_lock(&drm_component_lock);

	/*
	 * Make sure to check if there is a component which has two device
	 * objects, for connector and for encoder/connector.
	 * It should make sure that crtc and encoder/connector drivers are
	 * ready before exynos drm core binds them.
	 */
	list_for_each_entry(cdev, &drm_component_list, list) {
		if (cdev->out_type == out_type) {
			/*
			 * If crtc and encoder/connector device objects are
			 * added already just return.
			 */
			if (cdev->dev_type_flag == (EXYNOS_DEVICE_TYPE_CRTC |
						EXYNOS_DEVICE_TYPE_CONNECTOR)) {
				mutex_unlock(&drm_component_lock);
				return 0;
			}

			if (dev_type == EXYNOS_DEVICE_TYPE_CRTC) {
				cdev->crtc_dev = dev;
				cdev->dev_type_flag |= dev_type;
			}

			if (dev_type == EXYNOS_DEVICE_TYPE_CONNECTOR) {
				cdev->conn_dev = dev;
				cdev->dev_type_flag |= dev_type;
			}

			mutex_unlock(&drm_component_lock);
			return 0;
		}
	}

	mutex_unlock(&drm_component_lock);
431 432 433 434 435

	cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
	if (!cdev)
		return -ENOMEM;

436 437 438 439
	if (dev_type == EXYNOS_DEVICE_TYPE_CRTC)
		cdev->crtc_dev = dev;
	if (dev_type == EXYNOS_DEVICE_TYPE_CONNECTOR)
		cdev->conn_dev = dev;
440

441 442
	cdev->out_type = out_type;
	cdev->dev_type_flag = dev_type;
443 444 445 446 447 448 449 450 451

	mutex_lock(&drm_component_lock);
	list_add_tail(&cdev->list, &drm_component_list);
	mutex_unlock(&drm_component_lock);

	return 0;
}

void exynos_drm_component_del(struct device *dev,
452
				enum exynos_drm_device_type dev_type)
453 454 455 456 457 458
{
	struct component_dev *cdev, *next;

	mutex_lock(&drm_component_lock);

	list_for_each_entry_safe(cdev, next, &drm_component_list, list) {
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
		if (dev_type == EXYNOS_DEVICE_TYPE_CRTC) {
			if (cdev->crtc_dev == dev) {
				cdev->crtc_dev = NULL;
				cdev->dev_type_flag &= ~dev_type;
			}
		}

		if (dev_type == EXYNOS_DEVICE_TYPE_CONNECTOR) {
			if (cdev->conn_dev == dev) {
				cdev->conn_dev = NULL;
				cdev->dev_type_flag &= ~dev_type;
			}
		}

		/*
		 * Release cdev object only in case that both of crtc and
		 * encoder/connector device objects are NULL.
		 */
		if (!cdev->crtc_dev && !cdev->conn_dev) {
478 479 480
			list_del(&cdev->list);
			kfree(cdev);
		}
481 482

		break;
483 484 485 486 487 488 489 490 491 492 493 494 495
	}

	mutex_unlock(&drm_component_lock);
}

static int compare_of(struct device *dev, void *data)
{
	return dev == (struct device *)data;
}

static int exynos_drm_add_components(struct device *dev, struct master *m)
{
	struct component_dev *cdev;
496
	unsigned int attach_cnt = 0;
497 498 499 500 501 502

	mutex_lock(&drm_component_lock);

	list_for_each_entry(cdev, &drm_component_list, list) {
		int ret;

503 504 505 506 507 508 509 510 511
		/*
		 * Add components to master only in case that crtc and
		 * encoder/connector device objects exist.
		 */
		if (!cdev->crtc_dev || !cdev->conn_dev)
			continue;

		attach_cnt++;

512 513
		mutex_unlock(&drm_component_lock);

514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
		/*
		 * fimd and dpi modules have same device object so add
		 * only crtc device object in this case.
		 *
		 * TODO. if dpi module follows driver-model driver then
		 * below codes can be removed.
		 */
		if (cdev->crtc_dev == cdev->conn_dev) {
			ret = component_master_add_child(m, compare_of,
					cdev->crtc_dev);
			if (ret < 0)
				return ret;

			goto out_lock;
		}
529

530 531 532 533 534 535 536 537 538 539 540 541 542
		/*
		 * Do not chage below call order.
		 * crtc device first should be added to master because
		 * connector/encoder need pipe number of crtc when they
		 * are created.
		 */
		ret = component_master_add_child(m, compare_of, cdev->crtc_dev);
		ret |= component_master_add_child(m, compare_of,
							cdev->conn_dev);
		if (ret < 0)
			return ret;

out_lock:
543 544 545 546 547
		mutex_lock(&drm_component_lock);
	}

	mutex_unlock(&drm_component_lock);

548
	return attach_cnt ? 0 : -ENODEV;
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
}

static int exynos_drm_bind(struct device *dev)
{
	return drm_platform_init(&exynos_drm_driver, to_platform_device(dev));
}

static void exynos_drm_unbind(struct device *dev)
{
	drm_put_dev(dev_get_drvdata(dev));
}

static const struct component_master_ops exynos_drm_ops = {
	.add_components = exynos_drm_add_components,
	.bind		= exynos_drm_bind,
	.unbind		= exynos_drm_unbind,
565 566
};

567
static int exynos_drm_platform_probe(struct platform_device *pdev)
568
{
569 570
	int ret;

571
	pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
572
	exynos_drm_driver.num_ioctls = ARRAY_SIZE(exynos_ioctls);
573 574 575 576 577 578 579

#ifdef CONFIG_DRM_EXYNOS_FIMD
	ret = platform_driver_register(&fimd_driver);
	if (ret < 0)
		return ret;
#endif

580 581 582
#ifdef CONFIG_DRM_EXYNOS_DP
	ret = platform_driver_register(&dp_driver);
	if (ret < 0)
583
		goto err_unregister_fimd_drv;
584 585
#endif

A
Andrzej Hajda 已提交
586 587 588
#ifdef CONFIG_DRM_EXYNOS_DSI
	ret = platform_driver_register(&dsi_driver);
	if (ret < 0)
589
		goto err_unregister_dp_drv;
A
Andrzej Hajda 已提交
590 591
#endif

592 593 594
#ifdef CONFIG_DRM_EXYNOS_HDMI
	ret = platform_driver_register(&mixer_driver);
	if (ret < 0)
595 596
		goto err_unregister_dsi_drv;
	ret = platform_driver_register(&hdmi_driver);
597
	if (ret < 0)
598
		goto err_unregister_mixer_drv;
599 600
#endif

J
Joonyoung Shim 已提交
601 602 603
#ifdef CONFIG_DRM_EXYNOS_G2D
	ret = platform_driver_register(&g2d_driver);
	if (ret < 0)
604
		goto err_unregister_hdmi_drv;
J
Joonyoung Shim 已提交
605 606
#endif

E
Eunchul Kim 已提交
607 608 609
#ifdef CONFIG_DRM_EXYNOS_FIMC
	ret = platform_driver_register(&fimc_driver);
	if (ret < 0)
610
		goto err_unregister_g2d_drv;
E
Eunchul Kim 已提交
611 612
#endif

E
Eunchul Kim 已提交
613 614 615
#ifdef CONFIG_DRM_EXYNOS_ROTATOR
	ret = platform_driver_register(&rotator_driver);
	if (ret < 0)
616
		goto err_unregister_fimc_drv;
E
Eunchul Kim 已提交
617 618
#endif

E
Eunchul Kim 已提交
619 620 621
#ifdef CONFIG_DRM_EXYNOS_GSC
	ret = platform_driver_register(&gsc_driver);
	if (ret < 0)
622
		goto err_unregister_rotator_drv;
E
Eunchul Kim 已提交
623 624
#endif

E
Eunchul Kim 已提交
625 626 627
#ifdef CONFIG_DRM_EXYNOS_IPP
	ret = platform_driver_register(&ipp_driver);
	if (ret < 0)
628
		goto err_unregister_gsc_drv;
629 630 631

	ret = exynos_platform_device_ipp_register();
	if (ret < 0)
632
		goto err_unregister_ipp_drv;
E
Eunchul Kim 已提交
633 634
#endif

635
	ret = component_master_add(&pdev->dev, &exynos_drm_ops);
636
	if (ret < 0)
637
		DRM_DEBUG_KMS("re-tried by last sub driver probed later.\n");
638 639 640

	return 0;

E
Eunchul Kim 已提交
641
#ifdef CONFIG_DRM_EXYNOS_IPP
642
err_unregister_ipp_drv:
E
Eunchul Kim 已提交
643
	platform_driver_unregister(&ipp_driver);
644
err_unregister_gsc_drv:
E
Eunchul Kim 已提交
645 646
#endif

E
Eunchul Kim 已提交
647 648
#ifdef CONFIG_DRM_EXYNOS_GSC
	platform_driver_unregister(&gsc_driver);
649
err_unregister_rotator_drv:
E
Eunchul Kim 已提交
650 651
#endif

E
Eunchul Kim 已提交
652 653
#ifdef CONFIG_DRM_EXYNOS_ROTATOR
	platform_driver_unregister(&rotator_driver);
654
err_unregister_fimc_drv:
E
Eunchul Kim 已提交
655 656
#endif

E
Eunchul Kim 已提交
657 658
#ifdef CONFIG_DRM_EXYNOS_FIMC
	platform_driver_unregister(&fimc_driver);
659
err_unregister_g2d_drv:
E
Eunchul Kim 已提交
660 661
#endif

J
Joonyoung Shim 已提交
662 663
#ifdef CONFIG_DRM_EXYNOS_G2D
	platform_driver_unregister(&g2d_driver);
664
err_unregister_hdmi_drv:
665 666
#endif

667 668
#ifdef CONFIG_DRM_EXYNOS_HDMI
	platform_driver_unregister(&hdmi_driver);
669 670
err_unregister_mixer_drv:
	platform_driver_unregister(&mixer_driver);
671
err_unregister_dsi_drv:
672
#endif
673

A
Andrzej Hajda 已提交
674 675
#ifdef CONFIG_DRM_EXYNOS_DSI
	platform_driver_unregister(&dsi_driver);
676
err_unregister_dp_drv:
A
Andrzej Hajda 已提交
677 678
#endif

679 680
#ifdef CONFIG_DRM_EXYNOS_DP
	platform_driver_unregister(&dp_driver);
681 682 683 684 685
err_unregister_fimd_drv:
#endif

#ifdef CONFIG_DRM_EXYNOS_FIMD
	platform_driver_unregister(&fimd_driver);
686 687
#endif
	return ret;
688 689
}

690
static int exynos_drm_platform_remove(struct platform_device *pdev)
691
{
E
Eunchul Kim 已提交
692
#ifdef CONFIG_DRM_EXYNOS_IPP
693
	exynos_platform_device_ipp_unregister();
E
Eunchul Kim 已提交
694 695 696
	platform_driver_unregister(&ipp_driver);
#endif

E
Eunchul Kim 已提交
697 698 699 700
#ifdef CONFIG_DRM_EXYNOS_GSC
	platform_driver_unregister(&gsc_driver);
#endif

E
Eunchul Kim 已提交
701 702 703 704
#ifdef CONFIG_DRM_EXYNOS_ROTATOR
	platform_driver_unregister(&rotator_driver);
#endif

E
Eunchul Kim 已提交
705 706 707 708
#ifdef CONFIG_DRM_EXYNOS_FIMC
	platform_driver_unregister(&fimc_driver);
#endif

J
Joonyoung Shim 已提交
709 710 711 712
#ifdef CONFIG_DRM_EXYNOS_G2D
	platform_driver_unregister(&g2d_driver);
#endif

713 714 715 716 717 718 719 720
#ifdef CONFIG_DRM_EXYNOS_HDMI
	platform_driver_unregister(&mixer_driver);
	platform_driver_unregister(&hdmi_driver);
#endif

#ifdef CONFIG_DRM_EXYNOS_FIMD
	platform_driver_unregister(&fimd_driver);
#endif
721

A
Andrzej Hajda 已提交
722 723 724 725
#ifdef CONFIG_DRM_EXYNOS_DSI
	platform_driver_unregister(&dsi_driver);
#endif

726 727 728
#ifdef CONFIG_DRM_EXYNOS_DP
	platform_driver_unregister(&dp_driver);
#endif
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
	component_master_del(&pdev->dev, &exynos_drm_ops);
	return 0;
}

static struct platform_driver exynos_drm_platform_driver = {
	.probe	= exynos_drm_platform_probe,
	.remove	= exynos_drm_platform_remove,
	.driver	= {
		.owner	= THIS_MODULE,
		.name	= "exynos-drm",
		.pm	= &exynos_drm_pm_ops,
	},
};

static int exynos_drm_init(void)
{
	int ret;

	exynos_drm_pdev = platform_device_register_simple("exynos-drm", -1,
								NULL, 0);
	if (IS_ERR(exynos_drm_pdev))
		return PTR_ERR(exynos_drm_pdev);

#ifdef CONFIG_DRM_EXYNOS_VIDI
	ret = exynos_drm_probe_vidi();
	if (ret < 0)
		goto err_unregister_pd;
#endif

	ret = platform_driver_register(&exynos_drm_platform_driver);
	if (ret)
		goto err_remove_vidi;

	return 0;

err_remove_vidi:
#ifdef CONFIG_DRM_EXYNOS_VIDI
	exynos_drm_remove_vidi();
767 768

err_unregister_pd:
769
#endif
770
	platform_device_unregister(exynos_drm_pdev);
771 772 773 774 775 776

	return ret;
}

static void exynos_drm_exit(void)
{
777
	platform_driver_unregister(&exynos_drm_platform_driver);
778 779 780 781
#ifdef CONFIG_DRM_EXYNOS_VIDI
	exynos_drm_remove_vidi();
#endif
	platform_device_unregister(exynos_drm_pdev);
782 783 784 785 786 787 788 789 790 791
}

module_init(exynos_drm_init);
module_exit(exynos_drm_exit);

MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
MODULE_DESCRIPTION("Samsung SoC DRM Driver");
MODULE_LICENSE("GPL");