[mirror_ubuntu-bionic-kernel.git] / drivers / gpu / drm / msm / msm_drv.c

/*
 * Copyright (C) 2013 Red Hat
 * Author: Rob Clark <robdclark@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "msm_drv.h"

#include <mach/iommu.h>

static void msm_fb_output_poll_changed(struct drm_device *dev)
{
	struct msm_drm_private *priv = dev->dev_private;
	if (priv->fbdev)
		drm_fb_helper_hotplug_event(priv->fbdev);
}

static const struct drm_mode_config_funcs mode_config_funcs = {
	.fb_create = msm_framebuffer_create,
	.output_poll_changed = msm_fb_output_poll_changed,
};

static int msm_fault_handler(struct iommu_domain *iommu, struct device *dev,
		unsigned long iova, int flags, void *arg)
{
	DBG("*** fault: iova=%08lx, flags=%d", iova, flags);
	return 0;
}

int msm_register_iommu(struct drm_device *dev, struct iommu_domain *iommu)
{
	struct msm_drm_private *priv = dev->dev_private;
	int idx = priv->num_iommus++;

	if (WARN_ON(idx >= ARRAY_SIZE(priv->iommus)))
		return -EINVAL;

	priv->iommus[idx] = iommu;

	iommu_set_fault_handler(iommu, msm_fault_handler, dev);

	/* need to iommu_attach_device() somewhere??  on resume?? */

	return idx;
}

int msm_iommu_attach(struct drm_device *dev, struct iommu_domain *iommu,
		const char **names, int cnt)
{
	int i, ret;

	for (i = 0; i < cnt; i++) {
		struct device *ctx = msm_iommu_get_ctx(names[i]);
		if (!ctx)
			continue;
		ret = iommu_attach_device(iommu, ctx);
		if (ret) {
			dev_warn(dev->dev, "could not attach iommu to %s", names[i]);
			return ret;
		}
	}
	return 0;
}

#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

void __iomem *msm_ioremap(struct platform_device *pdev, const char *name,
		const char *dbgname)
{
	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) {
		dev_err(&pdev->dev, "failed to get memory resource: %s\n", name);
		return ERR_PTR(-EINVAL);
	}

	size = resource_size(res);

	ptr = devm_ioremap_nocache(&pdev->dev, res->start, size);
	if (!ptr) {
		dev_err(&pdev->dev, "failed to ioremap: %s\n", name);
		return ERR_PTR(-ENOMEM);
	}

	if (reglog)
		printk(KERN_DEBUG "IO:region %s %08x %08lx\n", dbgname, (u32)ptr, size);

	return ptr;
}

void msm_writel(u32 data, void __iomem *addr)
{
	if (reglog)
		printk(KERN_DEBUG "IO:W %08x %08x\n", (u32)addr, data);
	writel(data, addr);
}

u32 msm_readl(const void __iomem *addr)
{
	u32 val = readl(addr);
	if (reglog)
		printk(KERN_ERR "IO:R %08x %08x\n", (u32)addr, val);
	return val;
}

/*
 * DRM operations:
 */

static int msm_unload(struct drm_device *dev)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;

	drm_kms_helper_poll_fini(dev);
	drm_mode_config_cleanup(dev);
	drm_vblank_cleanup(dev);

	pm_runtime_get_sync(dev->dev);
	drm_irq_uninstall(dev);
	pm_runtime_put_sync(dev->dev);

	flush_workqueue(priv->wq);
	destroy_workqueue(priv->wq);

	if (kms) {
		pm_runtime_disable(dev->dev);
		kms->funcs->destroy(kms);
	}


	dev->dev_private = NULL;

	kfree(priv);

	return 0;
}

static int msm_load(struct drm_device *dev, unsigned long flags)
{
	struct platform_device *pdev = dev->platformdev;
	struct msm_drm_private *priv;
	struct msm_kms *kms;
	int ret;

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv) {
		dev_err(dev->dev, "failed to allocate private data\n");
		return -ENOMEM;
	}

	dev->dev_private = priv;

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

	INIT_LIST_HEAD(&priv->inactive_list);

	drm_mode_config_init(dev);

	kms = mdp4_kms_init(dev);
	if (IS_ERR(kms)) {
		/*
		 * NOTE: once we have GPU support, having no kms should not
		 * be considered fatal.. ideally we would still support gpu
		 * and (for example) use dmabuf/prime to share buffers with
		 * imx drm driver on iMX5
		 */
		dev_err(dev->dev, "failed to load kms\n");
		ret = PTR_ERR(priv->kms);
		goto fail;
	}

	priv->kms = kms;

	if (kms) {
		pm_runtime_enable(dev->dev);
		ret = kms->funcs->hw_init(kms);
		if (ret) {
			dev_err(dev->dev, "kms hw init failed: %d\n", ret);
			goto fail;
		}
	}

	dev->mode_config.min_width = 0;
	dev->mode_config.min_height = 0;
	dev->mode_config.max_width = 2048;
	dev->mode_config.max_height = 2048;
	dev->mode_config.funcs = &mode_config_funcs;

	ret = drm_vblank_init(dev, 1);
	if (ret < 0) {
		dev_err(dev->dev, "failed to initialize vblank\n");
		goto fail;
	}

	pm_runtime_get_sync(dev->dev);
	ret = drm_irq_install(dev);
	pm_runtime_put_sync(dev->dev);
	if (ret < 0) {
		dev_err(dev->dev, "failed to install IRQ handler\n");
		goto fail;
	}

	platform_set_drvdata(pdev, dev);

#ifdef CONFIG_DRM_MSM_FBDEV
	priv->fbdev = msm_fbdev_init(dev);
#endif

	drm_kms_helper_poll_init(dev);

	return 0;

fail:
	msm_unload(dev);
	return ret;
}

static void msm_preclose(struct drm_device *dev, struct drm_file *file)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	if (kms)
		kms->funcs->preclose(kms, file);
}

static void msm_lastclose(struct drm_device *dev)
{
	struct msm_drm_private *priv = dev->dev_private;
	if (priv->fbdev) {
		drm_modeset_lock_all(dev);
		drm_fb_helper_restore_fbdev_mode(priv->fbdev);
		drm_modeset_unlock_all(dev);
	}
}

static irqreturn_t msm_irq(DRM_IRQ_ARGS)
{
	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);
	return kms->funcs->irq_postinstall(kms);
}

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);
}

static int msm_enable_vblank(struct drm_device *dev, int crtc_id)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	if (!kms)
		return -ENXIO;
	DBG("dev=%p, crtc=%d", dev, crtc_id);
	return kms->funcs->enable_vblank(kms, priv->crtcs[crtc_id]);
}

static void msm_disable_vblank(struct drm_device *dev, int crtc_id)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_kms *kms = priv->kms;
	if (!kms)
		return;
	DBG("dev=%p, crtc=%d", dev, crtc_id);
	kms->funcs->disable_vblank(kms, priv->crtcs[crtc_id]);
}

/*
 * DRM debugfs:
 */

#ifdef CONFIG_DEBUG_FS
static int msm_gem_show(struct drm_device *dev, struct seq_file *m)
{
	struct msm_drm_private *priv = dev->dev_private;

	seq_printf(m, "All Objects:\n");
	msm_gem_describe_objects(&priv->inactive_list, m);

	return 0;
}

static int msm_mm_show(struct drm_device *dev, struct seq_file *m)
{
	return drm_mm_dump_table(m, dev->mm_private);
}

static int msm_fb_show(struct drm_device *dev, struct seq_file *m)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct drm_framebuffer *fb, *fbdev_fb = NULL;

	if (priv->fbdev) {
		seq_printf(m, "fbcon ");
		fbdev_fb = priv->fbdev->fb;
		msm_framebuffer_describe(fbdev_fb, m);
	}

	mutex_lock(&dev->mode_config.fb_lock);
	list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
		if (fb == fbdev_fb)
			continue;

		seq_printf(m, "user ");
		msm_framebuffer_describe(fb, m);
	}
	mutex_unlock(&dev->mode_config.fb_lock);

	return 0;
}

static int show_locked(struct seq_file *m, void *arg)
{
	struct drm_info_node *node = (struct drm_info_node *) m->private;
	struct drm_device *dev = node->minor->dev;
	int (*show)(struct drm_device *dev, struct seq_file *m) =
			node->info_ent->data;
	int ret;

	ret = mutex_lock_interruptible(&dev->struct_mutex);
	if (ret)
		return ret;

	ret = show(dev, m);

	mutex_unlock(&dev->struct_mutex);

	return ret;
}

static struct drm_info_list msm_debugfs_list[] = {
		{"gem", show_locked, 0, msm_gem_show},
		{ "mm", show_locked, 0, msm_mm_show },
		{ "fb", show_locked, 0, msm_fb_show },
};

static int msm_debugfs_init(struct drm_minor *minor)
{
	struct drm_device *dev = minor->dev;
	int ret;

	ret = drm_debugfs_create_files(msm_debugfs_list,
			ARRAY_SIZE(msm_debugfs_list),
			minor->debugfs_root, minor);

	if (ret) {
		dev_err(dev->dev, "could not install msm_debugfs_list\n");
		return ret;
	}

	return ret;
}

static void msm_debugfs_cleanup(struct drm_minor *minor)
{
	drm_debugfs_remove_files(msm_debugfs_list,
			ARRAY_SIZE(msm_debugfs_list), minor);
}
#endif

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,
#ifdef CONFIG_COMPAT
	.compat_ioctl       = drm_compat_ioctl,
#endif
	.poll               = drm_poll,
	.read               = drm_read,
	.llseek             = no_llseek,
	.mmap               = msm_gem_mmap,
};

static struct drm_driver msm_driver = {
	.driver_features    = DRIVER_HAVE_IRQ | DRIVER_GEM | DRIVER_MODESET,
	.load               = msm_load,
	.unload             = msm_unload,
	.preclose           = msm_preclose,
	.lastclose          = msm_lastclose,
	.irq_handler        = msm_irq,
	.irq_preinstall     = msm_irq_preinstall,
	.irq_postinstall    = msm_irq_postinstall,
	.irq_uninstall      = msm_irq_uninstall,
	.get_vblank_counter = drm_vblank_count,
	.enable_vblank      = msm_enable_vblank,
	.disable_vblank     = msm_disable_vblank,
	.gem_free_object    = msm_gem_free_object,
	.gem_vm_ops         = &vm_ops,
	.dumb_create        = msm_gem_dumb_create,
	.dumb_map_offset    = msm_gem_dumb_map_offset,
	.dumb_destroy       = msm_gem_dumb_destroy,
#ifdef CONFIG_DEBUG_FS
	.debugfs_init       = msm_debugfs_init,
	.debugfs_cleanup    = msm_debugfs_cleanup,
#endif
	.fops               = &fops,
	.name               = "msm",
	.desc               = "MSM Snapdragon DRM",
	.date               = "20130625",
	.major              = 1,
	.minor              = 0,
};

#ifdef CONFIG_PM_SLEEP
static int msm_pm_suspend(struct device *dev)
{
	struct drm_device *ddev = dev_get_drvdata(dev);

	drm_kms_helper_poll_disable(ddev);

	return 0;
}

static int msm_pm_resume(struct device *dev)
{
	struct drm_device *ddev = dev_get_drvdata(dev);

	drm_kms_helper_poll_enable(ddev);

	return 0;
}
#endif

static const struct dev_pm_ops msm_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(msm_pm_suspend, msm_pm_resume)
};

/*
 * Platform driver:
 */

static int msm_pdev_probe(struct platform_device *pdev)
{
	return drm_platform_init(&msm_driver, pdev);
}

static int msm_pdev_remove(struct platform_device *pdev)
{
	drm_platform_exit(&msm_driver, pdev);

	return 0;
}

static const struct platform_device_id msm_id[] = {
	{ "mdp", 0 },
	{ }
};

static struct platform_driver msm_platform_driver = {
	.probe      = msm_pdev_probe,
	.remove     = msm_pdev_remove,
	.driver     = {
		.owner  = THIS_MODULE,
		.name   = "msm",
		.pm     = &msm_pm_ops,
	},
	.id_table   = msm_id,
};

static int __init msm_drm_register(void)
{
	DBG("init");
	hdmi_register();
	return platform_driver_register(&msm_platform_driver);
}

static void __exit msm_drm_unregister(void)
{
	DBG("fini");
	platform_driver_unregister(&msm_platform_driver);
	hdmi_unregister();
}

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");
Commit	Line	Data
c8afe684 RC	1	/*
	2	* Copyright (C) 2013 Red Hat
	3	* Author: Rob Clark <robdclark@gmail.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program. If not, see <http://www.gnu.org/licenses/>.
	16	*/
	17
	18	#include "msm_drv.h"
	19
	20	#include <mach/iommu.h>
	21
	22	static void msm_fb_output_poll_changed(struct drm_device *dev)
	23	{
	24	struct msm_drm_private *priv = dev->dev_private;
	25	if (priv->fbdev)
	26	drm_fb_helper_hotplug_event(priv->fbdev);
	27	}
	28
	29	static const struct drm_mode_config_funcs mode_config_funcs = {
	30	.fb_create = msm_framebuffer_create,
	31	.output_poll_changed = msm_fb_output_poll_changed,
	32	};
	33
	34	static int msm_fault_handler(struct iommu_domain iommu, struct device dev,
	35	unsigned long iova, int flags, void *arg)
	36	{
	37	DBG("*** fault: iova=%08lx, flags=%d", iova, flags);
	38	return 0;
	39	}
	40
	41	int msm_register_iommu(struct drm_device dev, struct iommu_domain iommu)
	42	{
	43	struct msm_drm_private *priv = dev->dev_private;
	44	int idx = priv->num_iommus++;
	45
	46	if (WARN_ON(idx >= ARRAY_SIZE(priv->iommus)))
	47	return -EINVAL;
	48
	49	priv->iommus[idx] = iommu;
	50
	51	iommu_set_fault_handler(iommu, msm_fault_handler, dev);
	52
	53	/* need to iommu_attach_device() somewhere?? on resume?? */
	54
	55	return idx;
	56	}
	57
	58	int msm_iommu_attach(struct drm_device dev, struct iommu_domain iommu,
	59	const char **names, int cnt)
	60	{
	61	int i, ret;
	62
	63	for (i = 0; i < cnt; i++) {
	64	struct device *ctx = msm_iommu_get_ctx(names[i]);
65	if (!ctx)
66	continue;
67	ret = iommu_attach_device(iommu, ctx);
68	if (ret) {
69	dev_warn(dev->dev, "could not attach iommu to %s", names[i]);
70	return ret;
71	}
72	}
73	return 0;
74	}
75
76	#ifdef CONFIG_DRM_MSM_REGISTER_LOGGING
77	static bool reglog = false;
78	MODULE_PARM_DESC(reglog, "Enable register read/write logging");
79	module_param(reglog, bool, 0600);
80	#else
81	#define reglog 0
82	#endif
83
84	void __iomem msm_ioremap(struct platform_device pdev, const char *name,
85	const char *dbgname)
86	{
87	struct resource *res;
88	unsigned long size;
89	void __iomem *ptr;
90
91	if (name)
92	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
93	else
94	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
95
96	if (!res) {
97	dev_err(&pdev->dev, "failed to get memory resource: %s\n", name);
98	return ERR_PTR(-EINVAL);
99	}
100
101	size = resource_size(res);
102
103	ptr = devm_ioremap_nocache(&pdev->dev, res->start, size);
104	if (!ptr) {
105	dev_err(&pdev->dev, "failed to ioremap: %s\n", name);
106	return ERR_PTR(-ENOMEM);
107	}
108
109	if (reglog)
110	printk(KERN_DEBUG "IO:region %s %08x %08lx\n", dbgname, (u32)ptr, size);
111
112	return ptr;
113	}
114
115	void msm_writel(u32 data, void __iomem *addr)
116	{
117	if (reglog)
118	printk(KERN_DEBUG "IO:W %08x %08x\n", (u32)addr, data);
119	writel(data, addr);
120	}
121
122	u32 msm_readl(const void __iomem *addr)
123	{
124	u32 val = readl(addr);
125	if (reglog)
126	printk(KERN_ERR "IO:R %08x %08x\n", (u32)addr, val);
127	return val;
128	}
129
130	/*
131	* DRM operations:
132	*/
133
134	static int msm_unload(struct drm_device *dev)
135	{
136	struct msm_drm_private *priv = dev->dev_private;
137	struct msm_kms *kms = priv->kms;
138
139	drm_kms_helper_poll_fini(dev);
140	drm_mode_config_cleanup(dev);
141	drm_vblank_cleanup(dev);
142
143	pm_runtime_get_sync(dev->dev);
144	drm_irq_uninstall(dev);
145	pm_runtime_put_sync(dev->dev);
146
147	flush_workqueue(priv->wq);
148	destroy_workqueue(priv->wq);
149
150	if (kms) {
151	pm_runtime_disable(dev->dev);
152	kms->funcs->destroy(kms);
153	}
154
155
156	dev->dev_private = NULL;
157
158	kfree(priv);
159
160	return 0;
161	}
162
163	static int msm_load(struct drm_device *dev, unsigned long flags)
164	{
165	struct platform_device *pdev = dev->platformdev;
166	struct msm_drm_private *priv;
167	struct msm_kms *kms;
168	int ret;
169
170	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
171	if (!priv) {
172	dev_err(dev->dev, "failed to allocate private data\n");
173	return -ENOMEM;
174	}
175
176	dev->dev_private = priv;
177
178	priv->wq = alloc_ordered_workqueue("msm", 0);
179
180	INIT_LIST_HEAD(&priv->inactive_list);
181
182	drm_mode_config_init(dev);
183
184	kms = mdp4_kms_init(dev);
185	if (IS_ERR(kms)) {
186	/*
187	* NOTE: once we have GPU support, having no kms should not
188	* be considered fatal.. ideally we would still support gpu
189	* and (for example) use dmabuf/prime to share buffers with
190	* imx drm driver on iMX5
191	*/
192	dev_err(dev->dev, "failed to load kms\n");
193	ret = PTR_ERR(priv->kms);
194	goto fail;
195	}
196
197	priv->kms = kms;
198
199	if (kms) {
200	pm_runtime_enable(dev->dev);
201	ret = kms->funcs->hw_init(kms);
202	if (ret) {
203	dev_err(dev->dev, "kms hw init failed: %d\n", ret);
204	goto fail;
205	}
206	}
207
208	dev->mode_config.min_width = 0;
209	dev->mode_config.min_height = 0;
210	dev->mode_config.max_width = 2048;
211	dev->mode_config.max_height = 2048;
212	dev->mode_config.funcs = &mode_config_funcs;
213
214	ret = drm_vblank_init(dev, 1);
215	if (ret < 0) {
216	dev_err(dev->dev, "failed to initialize vblank\n");
217	goto fail;
218	}
219
220	pm_runtime_get_sync(dev->dev);
221	ret = drm_irq_install(dev);
222	pm_runtime_put_sync(dev->dev);
223	if (ret < 0) {
224	dev_err(dev->dev, "failed to install IRQ handler\n");
225	goto fail;
226	}
227
228	platform_set_drvdata(pdev, dev);
229
230	#ifdef CONFIG_DRM_MSM_FBDEV
231	priv->fbdev = msm_fbdev_init(dev);
232	#endif
233
234	drm_kms_helper_poll_init(dev);
235
236	return 0;
237
238	fail:
239	msm_unload(dev);
240	return ret;
241	}
242
243	static void msm_preclose(struct drm_device dev, struct drm_file file)
244	{
245	struct msm_drm_private *priv = dev->dev_private;
246	struct msm_kms *kms = priv->kms;
247	if (kms)
248	kms->funcs->preclose(kms, file);
249	}
250
251	static void msm_lastclose(struct drm_device *dev)
252	{
253	struct msm_drm_private *priv = dev->dev_private;
254	if (priv->fbdev) {
255	drm_modeset_lock_all(dev);
256	drm_fb_helper_restore_fbdev_mode(priv->fbdev);
257	drm_modeset_unlock_all(dev);
258	}
259	}
260
261	static irqreturn_t msm_irq(DRM_IRQ_ARGS)
262	{
263	struct drm_device *dev = arg;
264	struct msm_drm_private *priv = dev->dev_private;
265	struct msm_kms *kms = priv->kms;
266	BUG_ON(!kms);
267	return kms->funcs->irq(kms);
268	}
269
270	static void msm_irq_preinstall(struct drm_device *dev)
271	{
272	struct msm_drm_private *priv = dev->dev_private;
273	struct msm_kms *kms = priv->kms;
274	BUG_ON(!kms);
275	kms->funcs->irq_preinstall(kms);
276	}
277
278	static int msm_irq_postinstall(struct drm_device *dev)
279	{
280	struct msm_drm_private *priv = dev->dev_private;
281	struct msm_kms *kms = priv->kms;
282	BUG_ON(!kms);
283	return kms->funcs->irq_postinstall(kms);
284	}
285
286	static void msm_irq_uninstall(struct drm_device *dev)
287	{
288	struct msm_drm_private *priv = dev->dev_private;
289	struct msm_kms *kms = priv->kms;
290	BUG_ON(!kms);
291	kms->funcs->irq_uninstall(kms);
292	}
293
294	static int msm_enable_vblank(struct drm_device *dev, int crtc_id)
295	{
296	struct msm_drm_private *priv = dev->dev_private;
297	struct msm_kms *kms = priv->kms;
298	if (!kms)
299	return -ENXIO;
300	DBG("dev=%p, crtc=%d", dev, crtc_id);
301	return kms->funcs->enable_vblank(kms, priv->crtcs[crtc_id]);
302	}
303
304	static void msm_disable_vblank(struct drm_device *dev, int crtc_id)
305	{
306	struct msm_drm_private *priv = dev->dev_private;
307	struct msm_kms *kms = priv->kms;
308	if (!kms)
309	return;
310	DBG("dev=%p, crtc=%d", dev, crtc_id);
311	kms->funcs->disable_vblank(kms, priv->crtcs[crtc_id]);
312	}
313
314	/*
315	* DRM debugfs:
316	*/
317
318	#ifdef CONFIG_DEBUG_FS
319	static int msm_gem_show(struct drm_device dev, struct seq_file m)
320	{
321	struct msm_drm_private *priv = dev->dev_private;
322
323	seq_printf(m, "All Objects:\n");
324	msm_gem_describe_objects(&priv->inactive_list, m);
325
326	return 0;
327	}
328
329	static int msm_mm_show(struct drm_device dev, struct seq_file m)
330	{
331	return drm_mm_dump_table(m, dev->mm_private);
332	}
333
334	static int msm_fb_show(struct drm_device dev, struct seq_file m)
335	{
336	struct msm_drm_private *priv = dev->dev_private;
337	struct drm_framebuffer fb, fbdev_fb = NULL;
338
339	if (priv->fbdev) {
340	seq_printf(m, "fbcon ");
341	fbdev_fb = priv->fbdev->fb;
342	msm_framebuffer_describe(fbdev_fb, m);
343	}
344
345	mutex_lock(&dev->mode_config.fb_lock);
346	list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
347	if (fb == fbdev_fb)
348	continue;
349
350	seq_printf(m, "user ");
351	msm_framebuffer_describe(fb, m);
352	}
353	mutex_unlock(&dev->mode_config.fb_lock);
354
355	return 0;
356	}
357
358	static int show_locked(struct seq_file m, void arg)
359	{
360	struct drm_info_node node = (struct drm_info_node ) m->private;
361	struct drm_device *dev = node->minor->dev;
362	int (show)(struct drm_device dev, struct seq_file *m) =
363	node->info_ent->data;
364	int ret;
365
366	ret = mutex_lock_interruptible(&dev->struct_mutex);
367	if (ret)
368	return ret;
369
370	ret = show(dev, m);
371
372	mutex_unlock(&dev->struct_mutex);
373
374	return ret;
375	}
376
377	static struct drm_info_list msm_debugfs_list[] = {
378	{"gem", show_locked, 0, msm_gem_show},
379	{ "mm", show_locked, 0, msm_mm_show },
380	{ "fb", show_locked, 0, msm_fb_show },
381	};
382
383	static int msm_debugfs_init(struct drm_minor *minor)
384	{
385	struct drm_device *dev = minor->dev;
386	int ret;
387
388	ret = drm_debugfs_create_files(msm_debugfs_list,
389	ARRAY_SIZE(msm_debugfs_list),
390	minor->debugfs_root, minor);
391
392	if (ret) {
393	dev_err(dev->dev, "could not install msm_debugfs_list\n");
394	return ret;
395	}
396
397	return ret;
398	}
399
400	static void msm_debugfs_cleanup(struct drm_minor *minor)
401	{
402	drm_debugfs_remove_files(msm_debugfs_list,
403	ARRAY_SIZE(msm_debugfs_list), minor);
404	}
405	#endif
406
407	static const struct vm_operations_struct vm_ops = {
408	.fault = msm_gem_fault,
409	.open = drm_gem_vm_open,
410	.close = drm_gem_vm_close,
411	};
412
413	static const struct file_operations fops = {
414	.owner = THIS_MODULE,
415	.open = drm_open,
416	.release = drm_release,
417	.unlocked_ioctl = drm_ioctl,
418	#ifdef CONFIG_COMPAT
419	.compat_ioctl = drm_compat_ioctl,
420	#endif
421	.poll = drm_poll,
422	.read = drm_read,
423	.llseek = no_llseek,
424	.mmap = msm_gem_mmap,
425	};
426
427	static struct drm_driver msm_driver = {
428	.driver_features = DRIVER_HAVE_IRQ \| DRIVER_GEM \| DRIVER_MODESET,
429	.load = msm_load,
430	.unload = msm_unload,
431	.preclose = msm_preclose,
432	.lastclose = msm_lastclose,
433	.irq_handler = msm_irq,
434	.irq_preinstall = msm_irq_preinstall,
435	.irq_postinstall = msm_irq_postinstall,
436	.irq_uninstall = msm_irq_uninstall,
437	.get_vblank_counter = drm_vblank_count,
438	.enable_vblank = msm_enable_vblank,
439	.disable_vblank = msm_disable_vblank,
440	.gem_free_object = msm_gem_free_object,
441	.gem_vm_ops = &vm_ops,
442	.dumb_create = msm_gem_dumb_create,
443	.dumb_map_offset = msm_gem_dumb_map_offset,
444	.dumb_destroy = msm_gem_dumb_destroy,
445	#ifdef CONFIG_DEBUG_FS
446	.debugfs_init = msm_debugfs_init,
447	.debugfs_cleanup = msm_debugfs_cleanup,
448	#endif
449	.fops = &fops,
450	.name = "msm",
451	.desc = "MSM Snapdragon DRM",
452	.date = "20130625",
453	.major = 1,
454	.minor = 0,
455	};
456
457	#ifdef CONFIG_PM_SLEEP
458	static int msm_pm_suspend(struct device *dev)
459	{
460	struct drm_device *ddev = dev_get_drvdata(dev);
461
462	drm_kms_helper_poll_disable(ddev);
463
464	return 0;
465	}
466
467	static int msm_pm_resume(struct device *dev)
468	{
469	struct drm_device *ddev = dev_get_drvdata(dev);
470
471	drm_kms_helper_poll_enable(ddev);
472
473	return 0;
474	}
475	#endif
476
477	static const struct dev_pm_ops msm_pm_ops = {
478	SET_SYSTEM_SLEEP_PM_OPS(msm_pm_suspend, msm_pm_resume)
479	};
480
481	/*
482	* Platform driver:
483	*/
484
485	static int msm_pdev_probe(struct platform_device *pdev)
486	{
487	return drm_platform_init(&msm_driver, pdev);
488	}
489
490	static int msm_pdev_remove(struct platform_device *pdev)
491	{
492	drm_platform_exit(&msm_driver, pdev);
493
494	return 0;
495	}
496
497	static const struct platform_device_id msm_id[] = {
498	{ "mdp", 0 },
499	{ }
500	};
501
502	static struct platform_driver msm_platform_driver = {
503	.probe = msm_pdev_probe,
504	.remove = msm_pdev_remove,
505	.driver = {
506	.owner = THIS_MODULE,
507	.name = "msm",
508	.pm = &msm_pm_ops,
509	},
510	.id_table = msm_id,
511	};
512
513	static int __init msm_drm_register(void)
514	{
515	DBG("init");
516	hdmi_register();
517	return platform_driver_register(&msm_platform_driver);
518	}
519
520	static void __exit msm_drm_unregister(void)
521	{
522	DBG("fini");
523	platform_driver_unregister(&msm_platform_driver);
524	hdmi_unregister();
525	}
526
527	module_init(msm_drm_register);
528	module_exit(msm_drm_unregister);
529
530	MODULE_AUTHOR("Rob Clark <robdclark@gmail.com");
531	MODULE_DESCRIPTION("MSM DRM Driver");
532	MODULE_LICENSE("GPL");