msm_drv.c 32.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2
/*
3
 * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
4 5 6 7
 * Copyright (C) 2013 Red Hat
 * Author: Rob Clark <robdclark@gmail.com>
 */

S
Sam Ravnborg 已提交
8
#include <linux/dma-mapping.h>
9
#include <linux/kthread.h>
10
#include <linux/sched/mm.h>
S
Sam Ravnborg 已提交
11
#include <linux/uaccess.h>
12
#include <uapi/linux/sched/types.h>
S
Sam Ravnborg 已提交
13 14 15 16 17 18

#include <drm/drm_drv.h>
#include <drm/drm_file.h>
#include <drm/drm_ioctl.h>
#include <drm/drm_irq.h>
#include <drm/drm_prime.h>
19
#include <drm/drm_of.h>
S
Sam Ravnborg 已提交
20
#include <drm/drm_vblank.h>
21

22
#include "msm_drv.h"
23
#include "msm_debugfs.h"
24
#include "msm_fence.h"
25
#include "msm_gem.h"
R
Rob Clark 已提交
26
#include "msm_gpu.h"
R
Rob Clark 已提交
27
#include "msm_kms.h"
J
Jonathan Marek 已提交
28
#include "adreno/adreno_gpu.h"
29

R
Rob Clark 已提交
30 31 32 33
/*
 * MSM driver version:
 * - 1.0.0 - initial interface
 * - 1.1.0 - adds madvise, and support for submits with > 4 cmd buffers
34
 * - 1.2.0 - adds explicit fence support for submit ioctl
35 36 37
 * - 1.3.0 - adds GMEM_BASE + NR_RINGS params, SUBMITQUEUE_NEW +
 *           SUBMITQUEUE_CLOSE ioctls, and MSM_INFO_IOVA flag for
 *           MSM_GEM_INFO ioctl.
R
Rob Clark 已提交
38 39
 * - 1.4.0 - softpin, MSM_RELOC_BO_DUMP, and GEM_INFO support to set/get
 *           GEM object's debug name
40
 * - 1.5.0 - Add SUBMITQUERY_QUERY ioctl
41
 * - 1.6.0 - Syncobj support
R
Rob Clark 已提交
42 43
 */
#define MSM_VERSION_MAJOR	1
44
#define MSM_VERSION_MINOR	6
R
Rob Clark 已提交
45 46
#define MSM_VERSION_PATCHLEVEL	0

47 48
static const struct drm_mode_config_funcs mode_config_funcs = {
	.fb_create = msm_framebuffer_create,
49
	.output_poll_changed = drm_fb_helper_output_poll_changed,
50
	.atomic_check = drm_atomic_helper_check,
51 52 53 54 55
	.atomic_commit = drm_atomic_helper_commit,
};

static const struct drm_mode_config_helper_funcs mode_config_helper_funcs = {
	.atomic_commit_tail = msm_atomic_commit_tail,
56 57 58 59 60 61 62 63 64 65
};

#ifdef CONFIG_DRM_MSM_REGISTER_LOGGING
static bool reglog = false;
MODULE_PARM_DESC(reglog, "Enable register read/write logging");
module_param(reglog, bool, 0600);
#else
#define reglog 0
#endif

66
#ifdef CONFIG_DRM_FBDEV_EMULATION
67 68 69 70 71
static bool fbdev = true;
MODULE_PARM_DESC(fbdev, "Enable fbdev compat layer");
module_param(fbdev, bool, 0600);
#endif

72
static char *vram = "16m";
R
Rob Clark 已提交
73
MODULE_PARM_DESC(vram, "Configure VRAM size (for devices without IOMMU/GPUMMU)");
74 75
module_param(vram, charp, 0);

76 77 78 79
bool dumpstate = false;
MODULE_PARM_DESC(dumpstate, "Dump KMS state on errors");
module_param(dumpstate, bool, 0600);

R
Rob Clark 已提交
80 81 82 83
static bool modeset = true;
MODULE_PARM_DESC(modeset, "Use kernel modesetting [KMS] (1=on (default), 0=disable)");
module_param(modeset, bool, 0600);

84 85 86 87
/*
 * Util/helpers:
 */

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
struct clk *msm_clk_bulk_get_clock(struct clk_bulk_data *bulk, int count,
		const char *name)
{
	int i;
	char n[32];

	snprintf(n, sizeof(n), "%s_clk", name);

	for (i = 0; bulk && i < count; i++) {
		if (!strcmp(bulk[i].id, name) || !strcmp(bulk[i].id, n))
			return bulk[i].clk;
	}


	return NULL;
}

105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
struct clk *msm_clk_get(struct platform_device *pdev, const char *name)
{
	struct clk *clk;
	char name2[32];

	clk = devm_clk_get(&pdev->dev, name);
	if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)
		return clk;

	snprintf(name2, sizeof(name2), "%s_clk", name);

	clk = devm_clk_get(&pdev->dev, name2);
	if (!IS_ERR(clk))
		dev_warn(&pdev->dev, "Using legacy clk name binding.  Use "
				"\"%s\" instead of \"%s\"\n", name, name2);

	return clk;
}

124 125
static void __iomem *_msm_ioremap(struct platform_device *pdev, const char *name,
				  const char *dbgname, bool quiet)
126 127 128 129 130 131 132 133 134 135 136
{
	struct resource *res;
	unsigned long size;
	void __iomem *ptr;

	if (name)
		res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
	else
		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {
137 138
		if (!quiet)
			DRM_DEV_ERROR(&pdev->dev, "failed to get memory resource: %s\n", name);
139 140 141 142 143
		return ERR_PTR(-EINVAL);
	}

	size = resource_size(res);

144
	ptr = devm_ioremap(&pdev->dev, res->start, size);
145
	if (!ptr) {
146 147
		if (!quiet)
			DRM_DEV_ERROR(&pdev->dev, "failed to ioremap: %s\n", name);
148 149 150 151
		return ERR_PTR(-ENOMEM);
	}

	if (reglog)
152
		printk(KERN_DEBUG "IO:region %s %p %08lx\n", dbgname, ptr, size);
153 154 155 156

	return ptr;
}

157 158 159 160 161 162 163 164 165 166 167 168
void __iomem *msm_ioremap(struct platform_device *pdev, const char *name,
			  const char *dbgname)
{
	return _msm_ioremap(pdev, name, dbgname, false);
}

void __iomem *msm_ioremap_quiet(struct platform_device *pdev, const char *name,
				const char *dbgname)
{
	return _msm_ioremap(pdev, name, dbgname, true);
}

169 170 171
void msm_writel(u32 data, void __iomem *addr)
{
	if (reglog)
172
		printk(KERN_DEBUG "IO:W %p %08x\n", addr, data);
173 174 175 176 177 178 179
	writel(data, addr);
}

u32 msm_readl(const void __iomem *addr)
{
	u32 val = readl(addr);
	if (reglog)
180
		pr_err("IO:R %p %08x\n", addr, val);
181 182 183
	return val;
}

184 185
struct msm_vblank_work {
	struct work_struct work;
186 187
	int crtc_id;
	bool enable;
188
	struct msm_drm_private *priv;
189 190
};

191
static void vblank_ctrl_worker(struct work_struct *work)
192
{
193 194 195
	struct msm_vblank_work *vbl_work = container_of(work,
						struct msm_vblank_work, work);
	struct msm_drm_private *priv = vbl_work->priv;
196 197
	struct msm_kms *kms = priv->kms;

198 199 200 201
	if (vbl_work->enable)
		kms->funcs->enable_vblank(kms, priv->crtcs[vbl_work->crtc_id]);
	else
		kms->funcs->disable_vblank(kms,	priv->crtcs[vbl_work->crtc_id]);
202

203
	kfree(vbl_work);
204 205 206 207 208
}

static int vblank_ctrl_queue_work(struct msm_drm_private *priv,
					int crtc_id, bool enable)
{
209
	struct msm_vblank_work *vbl_work;
210

211 212
	vbl_work = kzalloc(sizeof(*vbl_work), GFP_ATOMIC);
	if (!vbl_work)
213 214
		return -ENOMEM;

215
	INIT_WORK(&vbl_work->work, vblank_ctrl_worker);
216

217 218 219
	vbl_work->crtc_id = crtc_id;
	vbl_work->enable = enable;
	vbl_work->priv = priv;
220

221
	queue_work(priv->wq, &vbl_work->work);
222 223 224 225

	return 0;
}

226
static int msm_drm_uninit(struct device *dev)
227
{
228 229 230
	struct platform_device *pdev = to_platform_device(dev);
	struct drm_device *ddev = platform_get_drvdata(pdev);
	struct msm_drm_private *priv = ddev->dev_private;
231
	struct msm_kms *kms = priv->kms;
232
	struct msm_mdss *mdss = priv->mdss;
233
	int i;
234

235 236 237 238 239 240 241 242 243 244 245 246
	/*
	 * Shutdown the hw if we're far enough along where things might be on.
	 * If we run this too early, we'll end up panicking in any variety of
	 * places. Since we don't register the drm device until late in
	 * msm_drm_init, drm_dev->registered is used as an indicator that the
	 * shutdown will be successful.
	 */
	if (ddev->registered) {
		drm_dev_unregister(ddev);
		drm_atomic_helper_shutdown(ddev);
	}

247 248 249 250
	/* We must cancel and cleanup any pending vblank enable/disable
	 * work before drm_irq_uninstall() to avoid work re-enabling an
	 * irq after uninstall has disabled it.
	 */
251

252
	flush_workqueue(priv->wq);
253

254
	/* clean up event worker threads */
255
	for (i = 0; i < priv->num_crtcs; i++) {
256 257
		if (priv->event_thread[i].worker)
			kthread_destroy_worker(priv->event_thread[i].worker);
258 259
	}

R
Rob Clark 已提交
260 261
	msm_gem_shrinker_cleanup(ddev);

262 263
	drm_kms_helper_poll_fini(ddev);

264 265 266
	msm_perf_debugfs_cleanup(priv);
	msm_rd_debugfs_cleanup(priv);

267 268
#ifdef CONFIG_DRM_FBDEV_EMULATION
	if (fbdev && priv->fbdev)
269
		msm_fbdev_free(ddev);
270
#endif
271

272
	drm_mode_config_cleanup(ddev);
273

274 275 276
	pm_runtime_get_sync(dev);
	drm_irq_uninstall(ddev);
	pm_runtime_put_sync(dev);
277

278
	if (kms && kms->funcs)
279 280
		kms->funcs->destroy(kms);

281
	if (priv->vram.paddr) {
282
		unsigned long attrs = DMA_ATTR_NO_KERNEL_MAPPING;
283
		drm_mm_takedown(&priv->vram.mm);
284
		dma_free_attrs(dev, priv->vram.size, NULL,
285
			       priv->vram.paddr, attrs);
286 287
	}

288
	component_unbind_all(dev, ddev);
289

290 291
	if (mdss && mdss->funcs)
		mdss->funcs->destroy(ddev);
292

293
	ddev->dev_private = NULL;
294
	drm_dev_put(ddev);
295

296
	destroy_workqueue(priv->wq);
297 298 299 300 301
	kfree(priv);

	return 0;
}

302 303
#define KMS_MDP4 4
#define KMS_MDP5 5
304
#define KMS_DPU  3
305

R
Rob Clark 已提交
306 307 308
static int get_mdp_ver(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
309 310

	return (int) (unsigned long) of_device_get_match_data(dev);
R
Rob Clark 已提交
311 312
}

313 314
#include <linux/of_address.h>

J
Jonathan Marek 已提交
315 316 317 318 319 320 321 322
bool msm_use_mmu(struct drm_device *dev)
{
	struct msm_drm_private *priv = dev->dev_private;

	/* a2xx comes with its own MMU */
	return priv->is_a2xx || iommu_present(&platform_bus_type);
}

323
static int msm_init_vram(struct drm_device *dev)
324
{
325
	struct msm_drm_private *priv = dev->dev_private;
326
	struct device_node *node;
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
	unsigned long size = 0;
	int ret = 0;

	/* In the device-tree world, we could have a 'memory-region'
	 * phandle, which gives us a link to our "vram".  Allocating
	 * is all nicely abstracted behind the dma api, but we need
	 * to know the entire size to allocate it all in one go. There
	 * are two cases:
	 *  1) device with no IOMMU, in which case we need exclusive
	 *     access to a VRAM carveout big enough for all gpu
	 *     buffers
	 *  2) device with IOMMU, but where the bootloader puts up
	 *     a splash screen.  In this case, the VRAM carveout
	 *     need only be large enough for fbdev fb.  But we need
	 *     exclusive access to the buffer to avoid the kernel
	 *     using those pages for other purposes (which appears
	 *     as corruption on screen before we have a chance to
	 *     load and do initial modeset)
	 */

	node = of_parse_phandle(dev->dev->of_node, "memory-region", 0);
	if (node) {
		struct resource r;
		ret = of_address_to_resource(node, 0, &r);
351
		of_node_put(node);
352 353 354
		if (ret)
			return ret;
		size = r.end - r.start;
355
		DRM_INFO("using VRAM carveout: %lx@%pa\n", size, &r.start);
356

357 358 359 360
		/* if we have no IOMMU, then we need to use carveout allocator.
		 * Grab the entire CMA chunk carved out in early startup in
		 * mach-msm:
		 */
J
Jonathan Marek 已提交
361
	} else if (!msm_use_mmu(dev)) {
362 363 364 365 366
		DRM_INFO("using %s VRAM carveout\n", vram);
		size = memparse(vram, NULL);
	}

	if (size) {
367
		unsigned long attrs = 0;
368 369 370 371 372
		void *p;

		priv->vram.size = size;

		drm_mm_init(&priv->vram.mm, 0, (size >> PAGE_SHIFT) - 1);
373
		spin_lock_init(&priv->vram.lock);
374

375 376
		attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
		attrs |= DMA_ATTR_WRITE_COMBINE;
377 378 379 380 381

		/* note that for no-kernel-mapping, the vaddr returned
		 * is bogus, but non-null if allocation succeeded:
		 */
		p = dma_alloc_attrs(dev->dev, size,
382
				&priv->vram.paddr, GFP_KERNEL, attrs);
383
		if (!p) {
384
			DRM_DEV_ERROR(dev->dev, "failed to allocate VRAM\n");
385
			priv->vram.paddr = 0;
386
			return -ENOMEM;
387 388
		}

389
		DRM_DEV_INFO(dev->dev, "VRAM: %08x->%08x\n",
390 391 392 393
				(uint32_t)priv->vram.paddr,
				(uint32_t)(priv->vram.paddr + size));
	}

394
	return ret;
395 396
}

397
static int msm_drm_init(struct device *dev, struct drm_driver *drv)
398
{
399 400
	struct platform_device *pdev = to_platform_device(dev);
	struct drm_device *ddev;
401 402
	struct msm_drm_private *priv;
	struct msm_kms *kms;
403
	struct msm_mdss *mdss;
404
	int ret, i;
405

406
	ddev = drm_dev_alloc(drv, dev);
407
	if (IS_ERR(ddev)) {
408
		DRM_DEV_ERROR(dev, "failed to allocate drm_device\n");
409
		return PTR_ERR(ddev);
410 411 412 413
	}

	platform_set_drvdata(pdev, ddev);

414 415
	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv) {
416
		ret = -ENOMEM;
417
		goto err_put_drm_dev;
418 419
	}

420
	ddev->dev_private = priv;
R
Rob Clark 已提交
421
	priv->dev = ddev;
422

423 424 425 426 427 428 429 430 431 432 433
	switch (get_mdp_ver(pdev)) {
	case KMS_MDP5:
		ret = mdp5_mdss_init(ddev);
		break;
	case KMS_DPU:
		ret = dpu_mdss_init(ddev);
		break;
	default:
		ret = 0;
		break;
	}
434 435
	if (ret)
		goto err_free_priv;
436

437 438
	mdss = priv->mdss;

439 440
	priv->wq = alloc_ordered_workqueue("msm", 0);

441 442
	INIT_LIST_HEAD(&priv->inactive_willneed);
	INIT_LIST_HEAD(&priv->inactive_dontneed);
443 444 445 446 447 448
	mutex_init(&priv->mm_lock);

	/* Teach lockdep about lock ordering wrt. shrinker: */
	fs_reclaim_acquire(GFP_KERNEL);
	might_lock(&priv->mm_lock);
	fs_reclaim_release(GFP_KERNEL);
449

450
	drm_mode_config_init(ddev);
451 452

	/* Bind all our sub-components: */
453
	ret = component_bind_all(dev, ddev);
454 455
	if (ret)
		goto err_destroy_mdss;
456

457
	ret = msm_init_vram(ddev);
458
	if (ret)
459
		goto err_msm_uninit;
460

R
Robin Murphy 已提交
461
	dma_set_max_seg_size(dev, UINT_MAX);
462

R
Rob Clark 已提交
463 464
	msm_gem_shrinker_init(ddev);

R
Rob Clark 已提交
465
	switch (get_mdp_ver(pdev)) {
466
	case KMS_MDP4:
467
		kms = mdp4_kms_init(ddev);
468
		priv->kms = kms;
R
Rob Clark 已提交
469
		break;
470
	case KMS_MDP5:
471
		kms = mdp5_kms_init(ddev);
R
Rob Clark 已提交
472
		break;
473 474 475 476
	case KMS_DPU:
		kms = dpu_kms_init(ddev);
		priv->kms = kms;
		break;
R
Rob Clark 已提交
477
	default:
478 479 480
		/* valid only for the dummy headless case, where of_node=NULL */
		WARN_ON(dev->of_node);
		kms = NULL;
R
Rob Clark 已提交
481 482 483
		break;
	}

484
	if (IS_ERR(kms)) {
485
		DRM_DEV_ERROR(dev, "failed to load kms\n");
T
Thomas Meyer 已提交
486
		ret = PTR_ERR(kms);
487
		priv->kms = NULL;
488
		goto err_msm_uninit;
489 490
	}

491 492 493
	/* Enable normalization of plane zpos */
	ddev->mode_config.normalize_zpos = true;

494
	if (kms) {
R
Rob Clark 已提交
495
		kms->dev = ddev;
496 497
		ret = kms->funcs->hw_init(kms);
		if (ret) {
498
			DRM_DEV_ERROR(dev, "kms hw init failed: %d\n", ret);
499
			goto err_msm_uninit;
500 501 502
		}
	}

503
	ddev->mode_config.funcs = &mode_config_funcs;
504
	ddev->mode_config.helper_private = &mode_config_helper_funcs;
505

506 507 508 509
	for (i = 0; i < priv->num_crtcs; i++) {
		/* initialize event thread */
		priv->event_thread[i].crtc_id = priv->crtcs[i]->base.id;
		priv->event_thread[i].dev = ddev;
510 511 512
		priv->event_thread[i].worker = kthread_create_worker(0,
			"crtc_event:%d", priv->event_thread[i].crtc_id);
		if (IS_ERR(priv->event_thread[i].worker)) {
513
			DRM_DEV_ERROR(dev, "failed to create crtc_event kthread\n");
514 515 516
			goto err_msm_uninit;
		}

517
		sched_set_fifo(priv->event_thread[i].worker->task);
518 519
	}

520
	ret = drm_vblank_init(ddev, priv->num_crtcs);
521
	if (ret < 0) {
522
		DRM_DEV_ERROR(dev, "failed to initialize vblank\n");
523
		goto err_msm_uninit;
524 525
	}

526 527 528 529 530
	if (kms) {
		pm_runtime_get_sync(dev);
		ret = drm_irq_install(ddev, kms->irq);
		pm_runtime_put_sync(dev);
		if (ret < 0) {
531
			DRM_DEV_ERROR(dev, "failed to install IRQ handler\n");
532
			goto err_msm_uninit;
533
		}
534 535
	}

536 537
	ret = drm_dev_register(ddev, 0);
	if (ret)
538
		goto err_msm_uninit;
539 540

	drm_mode_config_reset(ddev);
R
Rob Clark 已提交
541

542
#ifdef CONFIG_DRM_FBDEV_EMULATION
543
	if (kms && fbdev)
544
		priv->fbdev = msm_fbdev_init(ddev);
545 546
#endif

547
	ret = msm_debugfs_late_init(ddev);
R
Rob Clark 已提交
548
	if (ret)
549
		goto err_msm_uninit;
R
Rob Clark 已提交
550

551
	drm_kms_helper_poll_init(ddev);
552 553 554

	return 0;

555
err_msm_uninit:
556
	msm_drm_uninit(dev);
557
	return ret;
558 559 560 561 562
err_destroy_mdss:
	if (mdss && mdss->funcs)
		mdss->funcs->destroy(ddev);
err_free_priv:
	kfree(priv);
563 564
err_put_drm_dev:
	drm_dev_put(ddev);
565
	return ret;
566 567
}

568 569 570 571
/*
 * DRM operations:
 */

R
Rob Clark 已提交
572 573
static void load_gpu(struct drm_device *dev)
{
574
	static DEFINE_MUTEX(init_lock);
R
Rob Clark 已提交
575 576
	struct msm_drm_private *priv = dev->dev_private;

577 578
	mutex_lock(&init_lock);

579 580
	if (!priv->gpu)
		priv->gpu = adreno_load_gpu(dev);
R
Rob Clark 已提交
581

582
	mutex_unlock(&init_lock);
R
Rob Clark 已提交
583 584
}

585
static int context_init(struct drm_device *dev, struct drm_file *file)
R
Rob Clark 已提交
586
{
587
	struct msm_drm_private *priv = dev->dev_private;
R
Rob Clark 已提交
588 589 590 591 592 593
	struct msm_file_private *ctx;

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

594
	kref_init(&ctx->ref);
595
	msm_submitqueue_init(dev, ctx);
596

597
	ctx->aspace = msm_gpu_create_private_address_space(priv->gpu, current);
R
Rob Clark 已提交
598 599 600 601 602
	file->driver_priv = ctx;

	return 0;
}

603 604 605 606 607 608 609
static int msm_open(struct drm_device *dev, struct drm_file *file)
{
	/* For now, load gpu on open.. to avoid the requirement of having
	 * firmware in the initrd.
	 */
	load_gpu(dev);

610
	return context_init(dev, file);
611 612 613 614 615
}

static void context_close(struct msm_file_private *ctx)
{
	msm_submitqueue_close(ctx);
616
	msm_file_private_put(ctx);
617 618
}

D
Daniel Vetter 已提交
619
static void msm_postclose(struct drm_device *dev, struct drm_file *file)
620 621
{
	struct msm_drm_private *priv = dev->dev_private;
R
Rob Clark 已提交
622 623 624 625 626 627 628
	struct msm_file_private *ctx = file->driver_priv;

	mutex_lock(&dev->struct_mutex);
	if (ctx == priv->lastctx)
		priv->lastctx = NULL;
	mutex_unlock(&dev->struct_mutex);

629
	context_close(ctx);
630 631
}

D
Daniel Vetter 已提交
632
static irqreturn_t msm_irq(int irq, void *arg)
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
{
	struct drm_device *dev = arg;
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	BUG_ON(!kms);
	return kms->funcs->irq(kms);
}

static void msm_irq_preinstall(struct drm_device *dev)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	BUG_ON(!kms);
	kms->funcs->irq_preinstall(kms);
}

static int msm_irq_postinstall(struct drm_device *dev)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	BUG_ON(!kms);
654 655 656 657 658

	if (kms->funcs->irq_postinstall)
		return kms->funcs->irq_postinstall(kms);

	return 0;
659 660 661 662 663 664 665 666 667 668
}

static void msm_irq_uninstall(struct drm_device *dev)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	BUG_ON(!kms);
	kms->funcs->irq_uninstall(kms);
}

669
int msm_crtc_enable_vblank(struct drm_crtc *crtc)
670
{
671 672
	struct drm_device *dev = crtc->dev;
	unsigned int pipe = crtc->index;
673 674 675 676
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	if (!kms)
		return -ENXIO;
677 678
	DBG("dev=%p, crtc=%u", dev, pipe);
	return vblank_ctrl_queue_work(priv, pipe, true);
679 680
}

681
void msm_crtc_disable_vblank(struct drm_crtc *crtc)
682
{
683 684
	struct drm_device *dev = crtc->dev;
	unsigned int pipe = crtc->index;
685 686 687 688
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	if (!kms)
		return;
689 690
	DBG("dev=%p, crtc=%u", dev, pipe);
	vblank_ctrl_queue_work(priv, pipe, false);
691 692
}

R
Rob Clark 已提交
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
/*
 * DRM ioctls:
 */

static int msm_ioctl_get_param(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct drm_msm_param *args = data;
	struct msm_gpu *gpu;

	/* for now, we just have 3d pipe.. eventually this would need to
	 * be more clever to dispatch to appropriate gpu module:
	 */
	if (args->pipe != MSM_PIPE_3D0)
		return -EINVAL;

	gpu = priv->gpu;

	if (!gpu)
		return -ENXIO;

	return gpu->funcs->get_param(gpu, args->param, &args->value);
}

static int msm_ioctl_gem_new(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	struct drm_msm_gem_new *args = data;
R
Rob Clark 已提交
722 723 724 725 726 727

	if (args->flags & ~MSM_BO_FLAGS) {
		DRM_ERROR("invalid flags: %08x\n", args->flags);
		return -EINVAL;
	}

R
Rob Clark 已提交
728
	return msm_gem_new_handle(dev, file, args->size,
729
			args->flags, &args->handle, NULL);
R
Rob Clark 已提交
730 731
}

R
Rob Clark 已提交
732 733 734 735
static inline ktime_t to_ktime(struct drm_msm_timespec timeout)
{
	return ktime_set(timeout.tv_sec, timeout.tv_nsec);
}
R
Rob Clark 已提交
736 737 738 739 740 741

static int msm_ioctl_gem_cpu_prep(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	struct drm_msm_gem_cpu_prep *args = data;
	struct drm_gem_object *obj;
R
Rob Clark 已提交
742
	ktime_t timeout = to_ktime(args->timeout);
R
Rob Clark 已提交
743 744
	int ret;

R
Rob Clark 已提交
745 746 747 748 749
	if (args->op & ~MSM_PREP_FLAGS) {
		DRM_ERROR("invalid op: %08x\n", args->op);
		return -EINVAL;
	}

750
	obj = drm_gem_object_lookup(file, args->handle);
R
Rob Clark 已提交
751 752 753
	if (!obj)
		return -ENOENT;

R
Rob Clark 已提交
754
	ret = msm_gem_cpu_prep(obj, args->op, &timeout);
R
Rob Clark 已提交
755

756
	drm_gem_object_put(obj);
R
Rob Clark 已提交
757 758 759 760 761 762 763 764 765 766 767

	return ret;
}

static int msm_ioctl_gem_cpu_fini(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	struct drm_msm_gem_cpu_fini *args = data;
	struct drm_gem_object *obj;
	int ret;

768
	obj = drm_gem_object_lookup(file, args->handle);
R
Rob Clark 已提交
769 770 771 772 773
	if (!obj)
		return -ENOENT;

	ret = msm_gem_cpu_fini(obj);

774
	drm_gem_object_put(obj);
R
Rob Clark 已提交
775 776 777 778

	return ret;
}

779
static int msm_ioctl_gem_info_iova(struct drm_device *dev,
780 781
		struct drm_file *file, struct drm_gem_object *obj,
		uint64_t *iova)
782
{
783
	struct msm_file_private *ctx = file->driver_priv;
784

785
	if (!ctx->aspace)
786 787
		return -EINVAL;

788 789 790 791
	/*
	 * Don't pin the memory here - just get an address so that userspace can
	 * be productive
	 */
792
	return msm_gem_get_iova(obj, ctx->aspace, iova);
793 794
}

R
Rob Clark 已提交
795 796 797 798 799
static int msm_ioctl_gem_info(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	struct drm_msm_gem_info *args = data;
	struct drm_gem_object *obj;
800 801
	struct msm_gem_object *msm_obj;
	int i, ret = 0;
R
Rob Clark 已提交
802

R
Rob Clark 已提交
803
	if (args->pad)
R
Rob Clark 已提交
804 805
		return -EINVAL;

R
Rob Clark 已提交
806 807 808 809 810 811 812
	switch (args->info) {
	case MSM_INFO_GET_OFFSET:
	case MSM_INFO_GET_IOVA:
		/* value returned as immediate, not pointer, so len==0: */
		if (args->len)
			return -EINVAL;
		break;
813 814 815
	case MSM_INFO_SET_NAME:
	case MSM_INFO_GET_NAME:
		break;
R
Rob Clark 已提交
816
	default:
R
Rob Clark 已提交
817
		return -EINVAL;
R
Rob Clark 已提交
818
	}
R
Rob Clark 已提交
819

820
	obj = drm_gem_object_lookup(file, args->handle);
R
Rob Clark 已提交
821 822 823
	if (!obj)
		return -ENOENT;

824
	msm_obj = to_msm_bo(obj);
825

R
Rob Clark 已提交
826 827 828 829 830
	switch (args->info) {
	case MSM_INFO_GET_OFFSET:
		args->value = msm_gem_mmap_offset(obj);
		break;
	case MSM_INFO_GET_IOVA:
831
		ret = msm_ioctl_gem_info_iova(dev, file, obj, &args->value);
R
Rob Clark 已提交
832
		break;
833 834 835 836 837 838
	case MSM_INFO_SET_NAME:
		/* length check should leave room for terminating null: */
		if (args->len >= sizeof(msm_obj->name)) {
			ret = -EINVAL;
			break;
		}
839
		if (copy_from_user(msm_obj->name, u64_to_user_ptr(args->value),
840 841
				   args->len)) {
			msm_obj->name[0] = '\0';
842
			ret = -EFAULT;
843 844
			break;
		}
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859
		msm_obj->name[args->len] = '\0';
		for (i = 0; i < args->len; i++) {
			if (!isprint(msm_obj->name[i])) {
				msm_obj->name[i] = '\0';
				break;
			}
		}
		break;
	case MSM_INFO_GET_NAME:
		if (args->value && (args->len < strlen(msm_obj->name))) {
			ret = -EINVAL;
			break;
		}
		args->len = strlen(msm_obj->name);
		if (args->value) {
860 861 862
			if (copy_to_user(u64_to_user_ptr(args->value),
					 msm_obj->name, args->len))
				ret = -EFAULT;
863 864
		}
		break;
865
	}
R
Rob Clark 已提交
866

867
	drm_gem_object_put(obj);
R
Rob Clark 已提交
868 869 870 871 872 873 874

	return ret;
}

static int msm_ioctl_wait_fence(struct drm_device *dev, void *data,
		struct drm_file *file)
{
R
Rob Clark 已提交
875
	struct msm_drm_private *priv = dev->dev_private;
R
Rob Clark 已提交
876
	struct drm_msm_wait_fence *args = data;
R
Rob Clark 已提交
877
	ktime_t timeout = to_ktime(args->timeout);
878 879 880
	struct msm_gpu_submitqueue *queue;
	struct msm_gpu *gpu = priv->gpu;
	int ret;
R
Rob Clark 已提交
881 882 883 884 885 886

	if (args->pad) {
		DRM_ERROR("invalid pad: %08x\n", args->pad);
		return -EINVAL;
	}

887
	if (!gpu)
R
Rob Clark 已提交
888 889
		return 0;

890 891 892 893 894 895 896 897 898
	queue = msm_submitqueue_get(file->driver_priv, args->queueid);
	if (!queue)
		return -ENOENT;

	ret = msm_wait_fence(gpu->rb[queue->prio]->fctx, args->fence, &timeout,
		true);

	msm_submitqueue_put(queue);
	return ret;
R
Rob Clark 已提交
899 900
}

R
Rob Clark 已提交
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
static int msm_ioctl_gem_madvise(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	struct drm_msm_gem_madvise *args = data;
	struct drm_gem_object *obj;
	int ret;

	switch (args->madv) {
	case MSM_MADV_DONTNEED:
	case MSM_MADV_WILLNEED:
		break;
	default:
		return -EINVAL;
	}

	obj = drm_gem_object_lookup(file, args->handle);
	if (!obj) {
918
		return -ENOENT;
R
Rob Clark 已提交
919 920 921 922 923 924 925 926
	}

	ret = msm_gem_madvise(obj, args->madv);
	if (ret >= 0) {
		args->retained = ret;
		ret = 0;
	}

927
	drm_gem_object_put(obj);
R
Rob Clark 已提交
928 929 930 931

	return ret;
}

932 933 934 935 936 937 938 939 940

static int msm_ioctl_submitqueue_new(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	struct drm_msm_submitqueue *args = data;

	if (args->flags & ~MSM_SUBMITQUEUE_FLAGS)
		return -EINVAL;

941
	return msm_submitqueue_create(dev, file->driver_priv, args->prio,
942 943 944
		args->flags, &args->id);
}

945 946 947 948 949
static int msm_ioctl_submitqueue_query(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	return msm_submitqueue_query(dev, file->driver_priv, data);
}
950 951 952 953 954 955 956 957 958

static int msm_ioctl_submitqueue_close(struct drm_device *dev, void *data,
		struct drm_file *file)
{
	u32 id = *(u32 *) data;

	return msm_submitqueue_remove(file->driver_priv, id);
}

R
Rob Clark 已提交
959
static const struct drm_ioctl_desc msm_ioctls[] = {
960 961 962 963 964 965 966 967 968 969 970
	DRM_IOCTL_DEF_DRV(MSM_GET_PARAM,    msm_ioctl_get_param,    DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_GEM_NEW,      msm_ioctl_gem_new,      DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_GEM_INFO,     msm_ioctl_gem_info,     DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_GEM_CPU_PREP, msm_ioctl_gem_cpu_prep, DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_GEM_CPU_FINI, msm_ioctl_gem_cpu_fini, DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_GEM_SUBMIT,   msm_ioctl_gem_submit,   DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_WAIT_FENCE,   msm_ioctl_wait_fence,   DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_GEM_MADVISE,  msm_ioctl_gem_madvise,  DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_SUBMITQUEUE_NEW,   msm_ioctl_submitqueue_new,   DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_SUBMITQUEUE_CLOSE, msm_ioctl_submitqueue_close, DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(MSM_SUBMITQUEUE_QUERY, msm_ioctl_submitqueue_query, DRM_RENDER_ALLOW),
R
Rob Clark 已提交
971 972
};

973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
static const struct vm_operations_struct vm_ops = {
	.fault = msm_gem_fault,
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
};

static const struct file_operations fops = {
	.owner              = THIS_MODULE,
	.open               = drm_open,
	.release            = drm_release,
	.unlocked_ioctl     = drm_ioctl,
	.compat_ioctl       = drm_compat_ioctl,
	.poll               = drm_poll,
	.read               = drm_read,
	.llseek             = no_llseek,
	.mmap               = msm_gem_mmap,
};

static struct drm_driver msm_driver = {
992
	.driver_features    = DRIVER_GEM |
R
Rob Clark 已提交
993
				DRIVER_RENDER |
994
				DRIVER_ATOMIC |
995 996
				DRIVER_MODESET |
				DRIVER_SYNCOBJ,
R
Rob Clark 已提交
997
	.open               = msm_open,
D
Daniel Vetter 已提交
998
	.postclose           = msm_postclose,
999
	.lastclose          = drm_fb_helper_lastclose,
1000 1001 1002 1003
	.irq_handler        = msm_irq,
	.irq_preinstall     = msm_irq_preinstall,
	.irq_postinstall    = msm_irq_postinstall,
	.irq_uninstall      = msm_irq_uninstall,
1004
	.gem_free_object_unlocked = msm_gem_free_object,
1005 1006 1007
	.gem_vm_ops         = &vm_ops,
	.dumb_create        = msm_gem_dumb_create,
	.dumb_map_offset    = msm_gem_dumb_map_offset,
R
Rob Clark 已提交
1008 1009 1010 1011 1012 1013 1014 1015
	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
	.gem_prime_pin      = msm_gem_prime_pin,
	.gem_prime_unpin    = msm_gem_prime_unpin,
	.gem_prime_get_sg_table = msm_gem_prime_get_sg_table,
	.gem_prime_import_sg_table = msm_gem_prime_import_sg_table,
	.gem_prime_vmap     = msm_gem_prime_vmap,
	.gem_prime_vunmap   = msm_gem_prime_vunmap,
1016
	.gem_prime_mmap     = msm_gem_prime_mmap,
1017 1018 1019
#ifdef CONFIG_DEBUG_FS
	.debugfs_init       = msm_debugfs_init,
#endif
R
Rob Clark 已提交
1020
	.ioctls             = msm_ioctls,
1021
	.num_ioctls         = ARRAY_SIZE(msm_ioctls),
1022 1023 1024 1025
	.fops               = &fops,
	.name               = "msm",
	.desc               = "MSM Snapdragon DRM",
	.date               = "20130625",
R
Rob Clark 已提交
1026 1027 1028
	.major              = MSM_VERSION_MAJOR,
	.minor              = MSM_VERSION_MINOR,
	.patchlevel         = MSM_VERSION_PATCHLEVEL,
1029 1030
};

1031
static int __maybe_unused msm_runtime_suspend(struct device *dev)
1032 1033
{
	struct drm_device *ddev = dev_get_drvdata(dev);
1034
	struct msm_drm_private *priv = ddev->dev_private;
1035
	struct msm_mdss *mdss = priv->mdss;
1036

1037
	DBG("");
1038

1039 1040
	if (mdss && mdss->funcs)
		return mdss->funcs->disable(mdss);
1041

1042 1043 1044
	return 0;
}

1045
static int __maybe_unused msm_runtime_resume(struct device *dev)
1046 1047
{
	struct drm_device *ddev = dev_get_drvdata(dev);
1048
	struct msm_drm_private *priv = ddev->dev_private;
1049
	struct msm_mdss *mdss = priv->mdss;
1050

1051
	DBG("");
1052

1053 1054
	if (mdss && mdss->funcs)
		return mdss->funcs->enable(mdss);
1055

1056
	return 0;
1057 1058
}

1059
static int __maybe_unused msm_pm_suspend(struct device *dev)
1060 1061
{

1062 1063
	if (pm_runtime_suspended(dev))
		return 0;
1064

1065 1066
	return msm_runtime_suspend(dev);
}
1067

1068 1069 1070 1071 1072 1073
static int __maybe_unused msm_pm_resume(struct device *dev)
{
	if (pm_runtime_suspended(dev))
		return 0;

	return msm_runtime_resume(dev);
1074 1075
}

1076
static int __maybe_unused msm_pm_prepare(struct device *dev)
1077 1078 1079
{
	struct drm_device *ddev = dev_get_drvdata(dev);

1080 1081
	return drm_mode_config_helper_suspend(ddev);
}
1082

1083 1084 1085
static void __maybe_unused msm_pm_complete(struct device *dev)
{
	struct drm_device *ddev = dev_get_drvdata(dev);
1086

1087
	drm_mode_config_helper_resume(ddev);
1088 1089
}

1090 1091
static const struct dev_pm_ops msm_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(msm_pm_suspend, msm_pm_resume)
1092
	SET_RUNTIME_PM_OPS(msm_runtime_suspend, msm_runtime_resume, NULL)
1093 1094
	.prepare = msm_pm_prepare,
	.complete = msm_pm_complete,
1095 1096
};

1097 1098 1099 1100
/*
 * Componentized driver support:
 */

1101 1102 1103
/*
 * NOTE: duplication of the same code as exynos or imx (or probably any other).
 * so probably some room for some helpers
1104 1105 1106 1107 1108
 */
static int compare_of(struct device *dev, void *data)
{
	return dev->of_node == data;
}
1109

1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
/*
 * Identify what components need to be added by parsing what remote-endpoints
 * our MDP output ports are connected to. In the case of LVDS on MDP4, there
 * is no external component that we need to add since LVDS is within MDP4
 * itself.
 */
static int add_components_mdp(struct device *mdp_dev,
			      struct component_match **matchptr)
{
	struct device_node *np = mdp_dev->of_node;
	struct device_node *ep_node;
A
Archit Taneja 已提交
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
	struct device *master_dev;

	/*
	 * on MDP4 based platforms, the MDP platform device is the component
	 * master that adds other display interface components to itself.
	 *
	 * on MDP5 based platforms, the MDSS platform device is the component
	 * master that adds MDP5 and other display interface components to
	 * itself.
	 */
	if (of_device_is_compatible(np, "qcom,mdp4"))
		master_dev = mdp_dev;
	else
		master_dev = mdp_dev->parent;
1135 1136 1137 1138 1139 1140 1141 1142

	for_each_endpoint_of_node(np, ep_node) {
		struct device_node *intf;
		struct of_endpoint ep;
		int ret;

		ret = of_graph_parse_endpoint(ep_node, &ep);
		if (ret) {
1143
			DRM_DEV_ERROR(mdp_dev, "unable to parse port endpoint\n");
1144 1145 1146 1147 1148 1149 1150 1151 1152
			of_node_put(ep_node);
			return ret;
		}

		/*
		 * The LCDC/LVDS port on MDP4 is a speacial case where the
		 * remote-endpoint isn't a component that we need to add
		 */
		if (of_device_is_compatible(np, "qcom,mdp4") &&
1153
		    ep.port == 0)
1154 1155 1156 1157 1158 1159 1160 1161
			continue;

		/*
		 * It's okay if some of the ports don't have a remote endpoint
		 * specified. It just means that the port isn't connected to
		 * any external interface.
		 */
		intf = of_graph_get_remote_port_parent(ep_node);
1162
		if (!intf)
1163 1164
			continue;

1165 1166 1167 1168
		if (of_device_is_available(intf))
			drm_of_component_match_add(master_dev, matchptr,
						   compare_of, intf);

1169 1170 1171 1172 1173 1174
		of_node_put(intf);
	}

	return 0;
}

A
Archit Taneja 已提交
1175 1176 1177 1178 1179
static int compare_name_mdp(struct device *dev, void *data)
{
	return (strstr(dev_name(dev), "mdp") != NULL);
}

1180 1181 1182
static int add_display_components(struct device *dev,
				  struct component_match **matchptr)
{
A
Archit Taneja 已提交
1183 1184 1185 1186
	struct device *mdp_dev;
	int ret;

	/*
1187 1188 1189 1190
	 * MDP5/DPU based devices don't have a flat hierarchy. There is a top
	 * level parent: MDSS, and children: MDP5/DPU, DSI, HDMI, eDP etc.
	 * Populate the children devices, find the MDP5/DPU node, and then add
	 * the interfaces to our components list.
A
Archit Taneja 已提交
1191
	 */
1192
	if (of_device_is_compatible(dev->of_node, "qcom,mdss") ||
1193 1194
	    of_device_is_compatible(dev->of_node, "qcom,sdm845-mdss") ||
	    of_device_is_compatible(dev->of_node, "qcom,sc7180-mdss")) {
A
Archit Taneja 已提交
1195 1196
		ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
		if (ret) {
1197
			DRM_DEV_ERROR(dev, "failed to populate children devices\n");
A
Archit Taneja 已提交
1198 1199 1200 1201 1202
			return ret;
		}

		mdp_dev = device_find_child(dev, NULL, compare_name_mdp);
		if (!mdp_dev) {
1203
			DRM_DEV_ERROR(dev, "failed to find MDSS MDP node\n");
A
Archit Taneja 已提交
1204 1205 1206 1207 1208 1209 1210
			of_platform_depopulate(dev);
			return -ENODEV;
		}

		put_device(mdp_dev);

		/* add the MDP component itself */
1211 1212
		drm_of_component_match_add(dev, matchptr, compare_of,
					   mdp_dev->of_node);
A
Archit Taneja 已提交
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
	} else {
		/* MDP4 */
		mdp_dev = dev;
	}

	ret = add_components_mdp(mdp_dev, matchptr);
	if (ret)
		of_platform_depopulate(dev);

	return ret;
1223 1224
}

A
Archit Taneja 已提交
1225 1226 1227 1228 1229 1230
/*
 * We don't know what's the best binding to link the gpu with the drm device.
 * Fow now, we just hunt for all the possible gpus that we support, and add them
 * as components.
 */
static const struct of_device_id msm_gpu_match[] = {
R
Rob Clark 已提交
1231
	{ .compatible = "qcom,adreno" },
A
Archit Taneja 已提交
1232
	{ .compatible = "qcom,adreno-3xx" },
1233
	{ .compatible = "amd,imageon" },
A
Archit Taneja 已提交
1234 1235 1236 1237
	{ .compatible = "qcom,kgsl-3d0" },
	{ },
};

1238 1239 1240
static int add_gpu_components(struct device *dev,
			      struct component_match **matchptr)
{
A
Archit Taneja 已提交
1241 1242 1243 1244 1245 1246
	struct device_node *np;

	np = of_find_matching_node(NULL, msm_gpu_match);
	if (!np)
		return 0;

J
Jeffrey Hugo 已提交
1247 1248
	if (of_device_is_available(np))
		drm_of_component_match_add(dev, matchptr, compare_of, np);
A
Archit Taneja 已提交
1249 1250 1251 1252

	of_node_put(np);

	return 0;
1253 1254
}

1255 1256
static int msm_drm_bind(struct device *dev)
{
1257
	return msm_drm_init(dev, &msm_driver);
1258 1259 1260 1261
}

static void msm_drm_unbind(struct device *dev)
{
1262
	msm_drm_uninit(dev);
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
}

static const struct component_master_ops msm_drm_ops = {
	.bind = msm_drm_bind,
	.unbind = msm_drm_unbind,
};

/*
 * Platform driver:
 */
1273

1274
static int msm_pdev_probe(struct platform_device *pdev)
1275
{
1276
	struct component_match *match = NULL;
1277 1278
	int ret;

1279 1280 1281 1282 1283
	if (get_mdp_ver(pdev)) {
		ret = add_display_components(&pdev->dev, &match);
		if (ret)
			return ret;
	}
1284

1285 1286
	ret = add_gpu_components(&pdev->dev, &match);
	if (ret)
1287
		goto fail;
1288

R
Rob Clark 已提交
1289 1290 1291 1292 1293
	/* on all devices that I am aware of, iommu's which can map
	 * any address the cpu can see are used:
	 */
	ret = dma_set_mask_and_coherent(&pdev->dev, ~0);
	if (ret)
1294 1295 1296 1297 1298
		goto fail;

	ret = component_master_add_with_match(&pdev->dev, &msm_drm_ops, match);
	if (ret)
		goto fail;
R
Rob Clark 已提交
1299

1300 1301 1302 1303 1304
	return 0;

fail:
	of_platform_depopulate(&pdev->dev);
	return ret;
1305 1306 1307 1308
}

static int msm_pdev_remove(struct platform_device *pdev)
{
1309
	component_master_del(&pdev->dev, &msm_drm_ops);
A
Archit Taneja 已提交
1310
	of_platform_depopulate(&pdev->dev);
1311 1312 1313 1314

	return 0;
}

1315 1316 1317 1318 1319 1320 1321
static void msm_pdev_shutdown(struct platform_device *pdev)
{
	struct drm_device *drm = platform_get_drvdata(pdev);

	drm_atomic_helper_shutdown(drm);
}

R
Rob Clark 已提交
1322
static const struct of_device_id dt_match[] = {
1323 1324
	{ .compatible = "qcom,mdp4", .data = (void *)KMS_MDP4 },
	{ .compatible = "qcom,mdss", .data = (void *)KMS_MDP5 },
1325
	{ .compatible = "qcom,sdm845-mdss", .data = (void *)KMS_DPU },
1326
	{ .compatible = "qcom,sc7180-mdss", .data = (void *)KMS_DPU },
R
Rob Clark 已提交
1327 1328 1329 1330
	{}
};
MODULE_DEVICE_TABLE(of, dt_match);

1331 1332 1333
static struct platform_driver msm_platform_driver = {
	.probe      = msm_pdev_probe,
	.remove     = msm_pdev_remove,
1334
	.shutdown   = msm_pdev_shutdown,
1335 1336
	.driver     = {
		.name   = "msm",
R
Rob Clark 已提交
1337
		.of_match_table = dt_match,
1338 1339 1340 1341 1342 1343
		.pm     = &msm_pm_ops,
	},
};

static int __init msm_drm_register(void)
{
R
Rob Clark 已提交
1344 1345 1346
	if (!modeset)
		return -EINVAL;

1347
	DBG("init");
1348
	msm_mdp_register();
1349
	msm_dpu_register();
1350
	msm_dsi_register();
1351
	msm_edp_register();
A
Arnd Bergmann 已提交
1352
	msm_hdmi_register();
1353
	msm_dp_register();
1354
	adreno_register();
1355 1356 1357 1358 1359 1360 1361
	return platform_driver_register(&msm_platform_driver);
}

static void __exit msm_drm_unregister(void)
{
	DBG("fini");
	platform_driver_unregister(&msm_platform_driver);
1362
	msm_dp_unregister();
A
Arnd Bergmann 已提交
1363
	msm_hdmi_unregister();
1364
	adreno_unregister();
1365
	msm_edp_unregister();
1366
	msm_dsi_unregister();
1367
	msm_mdp_unregister();
1368
	msm_dpu_unregister();
1369 1370 1371 1372 1373 1374 1375 1376
}

module_init(msm_drm_register);
module_exit(msm_drm_unregister);

MODULE_AUTHOR("Rob Clark <robdclark@gmail.com");
MODULE_DESCRIPTION("MSM DRM Driver");
MODULE_LICENSE("GPL");