sound/soc/samsung/seiren/seiren-dma.c - LeafOS-Devices/android_kernel_samsung_universal7904 - Gitiles

 /* sound/soc/samsung/seiren/seiren-dma.c
  *
  * Exynos Seiren DMA driver for Exynos5430
  *
  * Copyright (c) 2014 Samsung Electronics
  * http://www.samsungsemi.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.
  */

 #include <linux/slab.h>
 #include <linux/dma-mapping.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/clk.h>
 #include <linux/mutex.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
 #include <linux/pm_runtime.h>
 #include <linux/iommu.h>
 #include <linux/dma/dma-pl330.h>

 #include <sound/soc.h>
 #include <sound/pcm_params.h>
 #include <sound/exynos.h>

 #include <asm/dma.h>

 #include "seiren.h"
 #include "seiren-dma.h"
 #include "../dma.h"

 /* DMAC source/destination addr */
 #define _SA			0x400
 #define SA(n)			(_SA + (n)*0x20)

 #define _DA			0x404
 #define DA(n)			(_DA + (n)*0x20)

 static struct seiren_dma_info {
 	struct platform_device	*pdev;
 	spinlock_t		lock;
 	void __iomem		*regs;
 #ifdef CONFIG_SND_SAMSUNG_IOMMU
 	struct iommu_domain	*domain;
 #endif
 	struct runtime		*rtd[DMA_CH_MAX];
 } sdi;

 struct runtime {
 	int			ch;
 	u32			peri;
 	void __iomem		*regs;
 	void __iomem		*reg_ack;
 	void __iomem		*reg_sa;
 	void __iomem		*reg_da;
 };

 static int of_dma_match_channel(struct device_node *np, const char *name,
 				int index, struct of_phandle_args *dma_spec)
 {
 	const char *s;

 	if (of_property_read_string_index(np, "dma-names", index, &s))
 		return -ENODEV;

 	if (strcmp(name, s))
 		return -ENODEV;

 	if (of_parse_phandle_with_args(np, "dmas", "#dma-cells", index,
 				       dma_spec))
 		return -ENODEV;

 	return 0;
 }

 static unsigned long esa_dma_request(enum dma_ch dma_ch,
 				struct samsung_dma_req *param,
 				struct device *dev, char *ch_name)
 {
 	struct device_node *np;
 	struct of_phandle_args dma_spec;
 	struct runtime *rtd = NULL;
 	int ch, count, n;

 	ch = esa_dma_open();
 	if (ch < 0) {
 		esa_err("%s: dma ch alloc fails!!!\n", __func__);
 		return -EIO;
 	}

 	rtd = kzalloc(sizeof(struct runtime), GFP_KERNEL);
 	if (!rtd) {
 		esa_err("%s: runtime data alloc fails!!!\n", __func__);
 		esa_dma_close(ch);
 		return -EIO;
 	}

 	pm_runtime_get_sync(&sdi.pdev->dev);

 	sdi.rtd[ch] = rtd;
 	rtd->ch = ch;
 	rtd->regs = esa_dma_get_mem() + (ch * DMA_PARAM_SIZE);
 	rtd->reg_ack = rtd->regs + DMA_ACK;
 	rtd->reg_sa = sdi.regs + SA(ch);
 	rtd->reg_da = sdi.regs + DA(ch);
 	memset(rtd->regs, 0, DMA_PARAM_SIZE);

 	np = dev->of_node;
 	if (!np) {
 		esa_err("%s: of_node not found!!!\n", __func__);
 		goto err;
 	}

 	count = of_property_count_strings(np, "dma-names");
 	if (count < 0) {
 		esa_err("%s: dma-names property missing\n", __func__);
 		goto err;
 	}

 	for (n = 0; n < count; n++) {
 		if (!of_dma_match_channel(np, ch_name, n, &dma_spec)) {
 			of_property_read_u32_index(np, "dmas",
 					n * 2 + 1, &rtd->peri);
 			esa_debug("%s: ch %d (peri %d)\n",
 					__func__, rtd->ch, rtd->peri);
 			writel(rtd->peri, rtd->regs + DMA_PERI);

 			return (unsigned long)ch;
 		}
 	}
 	esa_err("%s: dmas property of %s missing\n", __func__, ch_name);

 err:
 	esa_dma_close(ch);
 	kfree(rtd);
 	sdi.rtd[ch] = NULL;
 	pm_runtime_put_sync(&sdi.pdev->dev);

 	return -EIO;
 }

 static int esa_dma_release(unsigned  long ch, void *param)
 {
 	struct runtime *rtd = sdi.rtd[ch];

 	esa_dma_close(rtd->ch);
 	kfree(rtd);
 	sdi.rtd[ch] = NULL;
 	pm_runtime_put_sync(&sdi.pdev->dev);

 	return 0;
 }

 static int esa_dma_config(unsigned long ch, struct samsung_dma_config *param)
 {
 	struct runtime *rtd = sdi.rtd[ch];
 	void __iomem *regs = rtd->regs;
 	u32 mode_1 = DMA_MODE_NOP;
 	u32 src_pa = 0;
 	u32 dst_pa = 0;

 	if (param->direction == DMA_MEM_TO_DEV) {
 		mode_1 = DMA_MODE_MEM2DEV;
 		dst_pa = param->fifo;
 	} else if (param->direction == DMA_DEV_TO_MEM) {
 		mode_1 = DMA_MODE_DEV2MEM;
 		src_pa = param->fifo;
 	}

 	writel(mode_1, regs + DMA_MODE_1);
 	writel(src_pa, regs + DMA_SRC_PA);
 	writel(dst_pa, regs + DMA_DST_PA);

 	return 0;
 }

 static int esa_dma_prepare(unsigned long ch, struct samsung_dma_prep *param)
 {
 	struct runtime *rtd = sdi.rtd[ch];
 	void __iomem *regs = rtd->regs;
 	u32 mode_2;

 	mode_2 = (param->infiniteloop) ? DMA_MODE_LOOP : DMA_MODE_ONCE;
 	writel(mode_2, regs + DMA_MODE_2);

 	if (param->direction == DMA_MEM_TO_DEV)
 		writel(param->buf, regs + DMA_SRC_PA);
 	else if (param->direction == DMA_DEV_TO_MEM)
 		writel(param->buf, regs + DMA_DST_PA);

 	writel(param->period, regs + DMA_PERIOD);
 	writel(param->len / param->period, regs + DMA_PERIOD_CNT);

 	esa_dma_set_callback(param->fp, param->fp_param, rtd->ch);
 	esa_dma_send_cmd(CMD_DMA_PREPARE, rtd->ch, rtd->reg_ack);

 	return 0;
 }

 static int esa_dma_trigger(unsigned long ch)
 {
 	struct runtime *rtd = sdi.rtd[ch];

 	esa_dma_send_cmd(CMD_DMA_START, rtd->ch, rtd->reg_ack);

 	return 0;
 }

 static int esa_dma_getposition(unsigned long ch, dma_addr_t *src, dma_addr_t *dst)
 {
 	struct runtime *rtd = sdi.rtd[ch];

 	*src = readl(rtd->reg_sa);
 	*dst = readl(rtd->reg_da);

 	return 0;
 }

 static int esa_dma_flush(unsigned long ch)
 {
 	struct runtime *rtd = sdi.rtd[ch];

 	esa_dma_send_cmd(CMD_DMA_STOP, rtd->ch, rtd->reg_ack);

 	return 0;
 }

 static struct samsung_dma_ops esa_dma_ops = {
 	.request	= esa_dma_request,
 	.release	= esa_dma_release,
 	.config		= esa_dma_config,
 	.prepare	= esa_dma_prepare,
 	.trigger	= esa_dma_trigger,
 	.started	= NULL,
 	.getposition	= esa_dma_getposition,
 	.flush		= esa_dma_flush,
 	.stop		= esa_dma_flush,
 };

 void *samsung_esa_dma_get_ops(void)
 {
 	return &esa_dma_ops;
 }
 EXPORT_SYMBOL_GPL(samsung_esa_dma_get_ops);

 static const char banner[] =
 	KERN_INFO "Exynos Seiren ADMA driver, (c)2014 Samsung Electronics\n";

 static int esa_dma_probe(struct platform_device *pdev)
 {
 	struct resource *res;
 	struct device *dev = &pdev->dev;
 	struct device_node *np = pdev->dev.of_node;

 	printk(banner);

 	spin_lock_init(&sdi.lock);

 	sdi.pdev = pdev;

 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res) {
 		dev_err(dev, "Unable to get LPASS SFRs\n");
 		return -ENXIO;
 	}

 	sdi.regs = devm_ioremap_resource(&pdev->dev, res);
 	if (!sdi.regs) {
 		dev_err(dev, "SFR ioremap failed\n");
 		return -ENOMEM;
 	}
 	esa_debug("regs_base = %08X (%08X bytes)\n",
 			(unsigned int)res->start, (unsigned int)resource_size(res));

 	if (np) {
 		if (of_find_property(np, "samsung,lpass-subip", NULL))
 			lpass_register_subip(dev, "dmac");
 	}

 #ifdef CONFIG_SND_SAMSUNG_IOMMU
 	sdi.domain = lpass_get_iommu_domain();
 	if (!sdi.domain) {
 		dev_err(dev, "iommu not available\n");
 		goto err;
 	}
 #else
 	dev_err(dev, "iommu not available\n");
 	goto err;
 #endif

 #ifdef CONFIG_PM_RUNTIME
 	pm_runtime_enable(dev);
 	pm_runtime_get_sync(dev);
 	pm_runtime_put_sync(dev);
 #else
 	esa_dma_do_resume(dev);
 #endif

 	return 0;

 err:
 	return -ENODEV;
 }

 static int esa_dma_remove(struct platform_device *pdev)
 {
 	int ret = 0;

 #ifndef CONFIG_PM_RUNTIME
 	lpass_put_sync(&pdev->dev);
 #endif

 	return ret;
 }

 static int esa_dma_do_suspend(struct device *dev)
 {
 	lpass_put_sync(dev);

 	return 0;
 }

 static int esa_dma_do_resume(struct device *dev)
 {
 	lpass_get_sync(dev);

 	return 0;
 }

 #if !defined(CONFIG_PM_RUNTIME) && defined(CONFIG_PM_SLEEP)
 static int esa_dma_suspend(struct device *dev)
 {
 	esa_debug("%s entered\n", __func__);

 	return esa_dma_do_suspend(dev);
 }

 static int esa_dma_resume(struct device *dev)
 {
 	esa_debug("%s entered\n", __func__);

 	return esa_dma_do_resume(dev);
 }
 #else
 #define esa_dma_suspend	NULL
 #define esa_dma_resume	NULL
 #endif

 #ifdef CONFIG_PM_RUNTIME
 static int esa_dma_runtime_suspend(struct device *dev)
 {
 	esa_debug("%s entered\n", __func__);

 	return esa_dma_do_suspend(dev);
 }

 static int esa_dma_runtime_resume(struct device *dev)
 {
 	esa_debug("%s entered\n", __func__);

 	return esa_dma_do_resume(dev);
 }
 #endif

 static struct platform_device_id esa_dma_driver_ids[] = {
 	{
 		.name	= "samsung-seiren-dma",
 	},
 	{},
 };
 MODULE_DEVICE_TABLE(platform, esa_dma_driver_ids);

 #ifdef CONFIG_OF
 static const struct of_device_id exynos_esa_dma_match[] = {
 	{
 		.compatible = "samsung,exynos5430-seiren-dma",
 	},
 	{},
 };
 MODULE_DEVICE_TABLE(of, exynos_esa_dma_match);
 #endif

 static const struct dev_pm_ops esa_dma_pmops = {
 	SET_SYSTEM_SLEEP_PM_OPS(
 		esa_dma_suspend,
 		esa_dma_resume
 	)
 	SET_RUNTIME_PM_OPS(
 		esa_dma_runtime_suspend,
 		esa_dma_runtime_resume,
 		NULL
 	)
 };

 static struct platform_driver esa_dma_driver = {
 	.probe		= esa_dma_probe,
 	.remove		= esa_dma_remove,
 	.id_table	= esa_dma_driver_ids,
 	.driver		= {
 		.name	= "samsung-seiren-dma",
 		.owner	= THIS_MODULE,
 		.of_match_table = of_match_ptr(exynos_esa_dma_match),
 		.pm	= &esa_dma_pmops,
 	},
 };

 module_platform_driver(esa_dma_driver);

 MODULE_AUTHOR("Yeongman Seo <yman.seo@samsung.com>");
 MODULE_DESCRIPTION("Exynos Seiren DMA Driver");
 MODULE_LICENSE("GPL");
	/* sound/soc/samsung/seiren/seiren-dma.c
	*
	* Exynos Seiren DMA driver for Exynos5430
	*
	* Copyright (c) 2014 Samsung Electronics
	* http://www.samsungsemi.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.
	*/

	#include <linux/slab.h>
	#include <linux/dma-mapping.h>
	#include <linux/module.h>
	#include <linux/of.h>
	#include <linux/clk.h>
	#include <linux/mutex.h>
	#include <linux/delay.h>
	#include <linux/kthread.h>
	#include <linux/pm_runtime.h>
	#include <linux/iommu.h>
	#include <linux/dma/dma-pl330.h>

	#include <sound/soc.h>
	#include <sound/pcm_params.h>
	#include <sound/exynos.h>

	#include <asm/dma.h>

	#include "seiren.h"
	#include "seiren-dma.h"
	#include "../dma.h"

	/* DMAC source/destination addr */
	#define _SA 0x400
	#define SA(n) (_SA + (n)*0x20)

	#define _DA 0x404
	#define DA(n) (_DA + (n)*0x20)

	static struct seiren_dma_info {
	struct platform_device *pdev;
	spinlock_t lock;
	void __iomem *regs;
	#ifdef CONFIG_SND_SAMSUNG_IOMMU
	struct iommu_domain *domain;
	#endif
	struct runtime *rtd[DMA_CH_MAX];
	} sdi;

	struct runtime {
	int ch;
	u32 peri;
	void __iomem *regs;
	void __iomem *reg_ack;
	void __iomem *reg_sa;
	void __iomem *reg_da;
	};

	static int of_dma_match_channel(struct device_node np, const char name,
	int index, struct of_phandle_args *dma_spec)
	{
	const char *s;

	if (of_property_read_string_index(np, "dma-names", index, &s))
	return -ENODEV;

	if (strcmp(name, s))
	return -ENODEV;

	if (of_parse_phandle_with_args(np, "dmas", "#dma-cells", index,
	dma_spec))
	return -ENODEV;

	return 0;
	}

	static unsigned long esa_dma_request(enum dma_ch dma_ch,
	struct samsung_dma_req *param,
	struct device dev, char ch_name)
	{
	struct device_node *np;
	struct of_phandle_args dma_spec;
	struct runtime *rtd = NULL;
	int ch, count, n;

	ch = esa_dma_open();
	if (ch < 0) {
	esa_err("%s: dma ch alloc fails!!!\n", __func__);
	return -EIO;
	}

	rtd = kzalloc(sizeof(struct runtime), GFP_KERNEL);
	if (!rtd) {
	esa_err("%s: runtime data alloc fails!!!\n", __func__);
	esa_dma_close(ch);
	return -EIO;
	}

	pm_runtime_get_sync(&sdi.pdev->dev);

	sdi.rtd[ch] = rtd;
	rtd->ch = ch;
	rtd->regs = esa_dma_get_mem() + (ch * DMA_PARAM_SIZE);
	rtd->reg_ack = rtd->regs + DMA_ACK;
	rtd->reg_sa = sdi.regs + SA(ch);
	rtd->reg_da = sdi.regs + DA(ch);
	memset(rtd->regs, 0, DMA_PARAM_SIZE);

	np = dev->of_node;
	if (!np) {
	esa_err("%s: of_node not found!!!\n", __func__);
	goto err;
	}

	count = of_property_count_strings(np, "dma-names");
	if (count < 0) {
	esa_err("%s: dma-names property missing\n", __func__);
	goto err;
	}

	for (n = 0; n < count; n++) {
	if (!of_dma_match_channel(np, ch_name, n, &dma_spec)) {
	of_property_read_u32_index(np, "dmas",
	n * 2 + 1, &rtd->peri);
	esa_debug("%s: ch %d (peri %d)\n",
	__func__, rtd->ch, rtd->peri);
	writel(rtd->peri, rtd->regs + DMA_PERI);

	return (unsigned long)ch;
	}
	}
	esa_err("%s: dmas property of %s missing\n", __func__, ch_name);

	err:
	esa_dma_close(ch);
	kfree(rtd);
	sdi.rtd[ch] = NULL;
	pm_runtime_put_sync(&sdi.pdev->dev);

	return -EIO;
	}

	static int esa_dma_release(unsigned long ch, void *param)
	{
	struct runtime *rtd = sdi.rtd[ch];

	esa_dma_close(rtd->ch);
	kfree(rtd);
	sdi.rtd[ch] = NULL;
	pm_runtime_put_sync(&sdi.pdev->dev);

	return 0;
	}

	static int esa_dma_config(unsigned long ch, struct samsung_dma_config *param)
	{
	struct runtime *rtd = sdi.rtd[ch];
	void __iomem *regs = rtd->regs;
	u32 mode_1 = DMA_MODE_NOP;
	u32 src_pa = 0;
	u32 dst_pa = 0;

	if (param->direction == DMA_MEM_TO_DEV) {
	mode_1 = DMA_MODE_MEM2DEV;
	dst_pa = param->fifo;
	} else if (param->direction == DMA_DEV_TO_MEM) {
	mode_1 = DMA_MODE_DEV2MEM;
	src_pa = param->fifo;
	}

	writel(mode_1, regs + DMA_MODE_1);
	writel(src_pa, regs + DMA_SRC_PA);
	writel(dst_pa, regs + DMA_DST_PA);

	return 0;
	}

	static int esa_dma_prepare(unsigned long ch, struct samsung_dma_prep *param)
	{
	struct runtime *rtd = sdi.rtd[ch];
	void __iomem *regs = rtd->regs;
	u32 mode_2;

	mode_2 = (param->infiniteloop) ? DMA_MODE_LOOP : DMA_MODE_ONCE;
	writel(mode_2, regs + DMA_MODE_2);

	if (param->direction == DMA_MEM_TO_DEV)
	writel(param->buf, regs + DMA_SRC_PA);
	else if (param->direction == DMA_DEV_TO_MEM)
	writel(param->buf, regs + DMA_DST_PA);

	writel(param->period, regs + DMA_PERIOD);
	writel(param->len / param->period, regs + DMA_PERIOD_CNT);

	esa_dma_set_callback(param->fp, param->fp_param, rtd->ch);
	esa_dma_send_cmd(CMD_DMA_PREPARE, rtd->ch, rtd->reg_ack);

	return 0;
	}

	static int esa_dma_trigger(unsigned long ch)
	{
	struct runtime *rtd = sdi.rtd[ch];

	esa_dma_send_cmd(CMD_DMA_START, rtd->ch, rtd->reg_ack);

	return 0;
	}

	static int esa_dma_getposition(unsigned long ch, dma_addr_t src, dma_addr_t dst)
	{
	struct runtime *rtd = sdi.rtd[ch];

	*src = readl(rtd->reg_sa);
	*dst = readl(rtd->reg_da);

	return 0;
	}

	static int esa_dma_flush(unsigned long ch)
	{
	struct runtime *rtd = sdi.rtd[ch];

	esa_dma_send_cmd(CMD_DMA_STOP, rtd->ch, rtd->reg_ack);

	return 0;
	}

	static struct samsung_dma_ops esa_dma_ops = {
	.request = esa_dma_request,
	.release = esa_dma_release,
	.config = esa_dma_config,
	.prepare = esa_dma_prepare,
	.trigger = esa_dma_trigger,
	.started = NULL,
	.getposition = esa_dma_getposition,
	.flush = esa_dma_flush,
	.stop = esa_dma_flush,
	};

	void *samsung_esa_dma_get_ops(void)
	{
	return &esa_dma_ops;
	}
	EXPORT_SYMBOL_GPL(samsung_esa_dma_get_ops);

	static const char banner[] =
	KERN_INFO "Exynos Seiren ADMA driver, (c)2014 Samsung Electronics\n";

	static int esa_dma_probe(struct platform_device *pdev)
	{
	struct resource *res;
	struct device *dev = &pdev->dev;
	struct device_node *np = pdev->dev.of_node;

	printk(banner);

	spin_lock_init(&sdi.lock);

	sdi.pdev = pdev;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
	dev_err(dev, "Unable to get LPASS SFRs\n");
	return -ENXIO;
	}

	sdi.regs = devm_ioremap_resource(&pdev->dev, res);
	if (!sdi.regs) {
	dev_err(dev, "SFR ioremap failed\n");
	return -ENOMEM;
	}
	esa_debug("regs_base = %08X (%08X bytes)\n",
	(unsigned int)res->start, (unsigned int)resource_size(res));

	if (np) {
	if (of_find_property(np, "samsung,lpass-subip", NULL))
	lpass_register_subip(dev, "dmac");
	}

	#ifdef CONFIG_SND_SAMSUNG_IOMMU
	sdi.domain = lpass_get_iommu_domain();
	if (!sdi.domain) {
	dev_err(dev, "iommu not available\n");
	goto err;
	}
	#else
	dev_err(dev, "iommu not available\n");
	goto err;
	#endif

	#ifdef CONFIG_PM_RUNTIME
	pm_runtime_enable(dev);
	pm_runtime_get_sync(dev);
	pm_runtime_put_sync(dev);
	#else
	esa_dma_do_resume(dev);
	#endif

	return 0;

	err:
	return -ENODEV;
	}

	static int esa_dma_remove(struct platform_device *pdev)
	{
	int ret = 0;

	#ifndef CONFIG_PM_RUNTIME
	lpass_put_sync(&pdev->dev);
	#endif

	return ret;
	}

	static int esa_dma_do_suspend(struct device *dev)
	{
	lpass_put_sync(dev);

	return 0;
	}

	static int esa_dma_do_resume(struct device *dev)
	{
	lpass_get_sync(dev);

	return 0;
	}

	#if !defined(CONFIG_PM_RUNTIME) && defined(CONFIG_PM_SLEEP)
	static int esa_dma_suspend(struct device *dev)
	{
	esa_debug("%s entered\n", __func__);

	return esa_dma_do_suspend(dev);
	}

	static int esa_dma_resume(struct device *dev)
	{
	esa_debug("%s entered\n", __func__);

	return esa_dma_do_resume(dev);
	}
	#else
	#define esa_dma_suspend NULL
	#define esa_dma_resume NULL
	#endif

	#ifdef CONFIG_PM_RUNTIME
	static int esa_dma_runtime_suspend(struct device *dev)
	{
	esa_debug("%s entered\n", __func__);

	return esa_dma_do_suspend(dev);
	}

	static int esa_dma_runtime_resume(struct device *dev)
	{
	esa_debug("%s entered\n", __func__);

	return esa_dma_do_resume(dev);
	}
	#endif

	static struct platform_device_id esa_dma_driver_ids[] = {
	{
	.name = "samsung-seiren-dma",
	},
	{},
	};
	MODULE_DEVICE_TABLE(platform, esa_dma_driver_ids);

	#ifdef CONFIG_OF
	static const struct of_device_id exynos_esa_dma_match[] = {
	{
	.compatible = "samsung,exynos5430-seiren-dma",
	},
	{},
	};
	MODULE_DEVICE_TABLE(of, exynos_esa_dma_match);
	#endif

	static const struct dev_pm_ops esa_dma_pmops = {
	SET_SYSTEM_SLEEP_PM_OPS(
	esa_dma_suspend,
	esa_dma_resume
	)
	SET_RUNTIME_PM_OPS(
	esa_dma_runtime_suspend,
	esa_dma_runtime_resume,
	NULL
	)
	};

	static struct platform_driver esa_dma_driver = {
	.probe = esa_dma_probe,
	.remove = esa_dma_remove,
	.id_table = esa_dma_driver_ids,
	.driver = {
	.name = "samsung-seiren-dma",
	.owner = THIS_MODULE,
	.of_match_table = of_match_ptr(exynos_esa_dma_match),
	.pm = &esa_dma_pmops,
	},
	};

	module_platform_driver(esa_dma_driver);

	MODULE_AUTHOR("Yeongman Seo <yman.seo@samsung.com>");
	MODULE_DESCRIPTION("Exynos Seiren DMA Driver");
	MODULE_LICENSE("GPL");