[linux-2.6-block.git] / arch / powerpc / sysdev / bestcomm / bestcomm.c

/*
 * Driver for MPC52xx processor BestComm peripheral controller
 *
 *
 * Copyright (C) 2006-2007 Sylvain Munaut <tnt@246tNt.com>
 * Copyright (C) 2005      Varma Electronics Oy,
 *                         ( by Andrey Volkov <avolkov@varma-el.com> )
 * Copyright (C) 2003-2004 MontaVista, Software, Inc.
 *                         ( by Dale Farnsworth <dfarnsworth@mvista.com> )
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/mpc52xx.h>

#include "sram.h"
#include "bestcomm_priv.h"
#include "bestcomm.h"

#define DRIVER_NAME "bestcomm-core"


struct bcom_engine *bcom_eng = NULL;
EXPORT_SYMBOL_GPL(bcom_eng);	/* needed for inline functions */


/* ======================================================================== */
/* Public and private API                                                   */
/* ======================================================================== */

/* Private API */

struct bcom_task *
bcom_task_alloc(int bd_count, int bd_size, int priv_size)
{
	int i, tasknum = -1;
	struct bcom_task *tsk;

	/* Get and reserve a task num */
	spin_lock(&bcom_eng->lock);

	for (i=0; i<BCOM_MAX_TASKS; i++)
		if (!bcom_eng->tdt[i].stop) {	/* we use stop as a marker */
			bcom_eng->tdt[i].stop = 0xfffffffful; /* dummy addr */
			tasknum = i;
			break;
		}

	spin_unlock(&bcom_eng->lock);

	if (tasknum < 0)
		return NULL;

	/* Allocate our structure */
	tsk = kzalloc(sizeof(struct bcom_task) + priv_size, GFP_KERNEL);
	if (!tsk)
		goto error;

	tsk->tasknum = tasknum;
	if (priv_size)
		tsk->priv = (void*)tsk + sizeof(struct bcom_task);

	/* Get IRQ of that task */
	tsk->irq = irq_of_parse_and_map(bcom_eng->ofnode, tsk->tasknum);
	if (tsk->irq == NO_IRQ)
		goto error;

	/* Init the BDs, if needed */
	if (bd_count) {
		tsk->cookie = kmalloc(sizeof(void*) * bd_count, GFP_KERNEL);
		if (!tsk->cookie)
			goto error;

		tsk->bd = bcom_sram_alloc(bd_count * bd_size, 4, &tsk->bd_pa);
		if (!tsk->bd)
			goto error;
		memset(tsk->bd, 0x00, bd_count * bd_size);

		tsk->num_bd = bd_count;
		tsk->bd_size = bd_size;
	}

	return tsk;

error:
	if (tsk) {
		if (tsk->irq != NO_IRQ)
			irq_dispose_mapping(tsk->irq);
		bcom_sram_free(tsk->bd);
		kfree(tsk->cookie);
		kfree(tsk);
	}

	bcom_eng->tdt[tasknum].stop = 0;

	return NULL;
}
EXPORT_SYMBOL_GPL(bcom_task_alloc);

void
bcom_task_free(struct bcom_task *tsk)
{
	/* Stop the task */
	bcom_disable_task(tsk->tasknum);

	/* Clear TDT */
	bcom_eng->tdt[tsk->tasknum].start = 0;
	bcom_eng->tdt[tsk->tasknum].stop  = 0;

	/* Free everything */
	irq_dispose_mapping(tsk->irq);
	bcom_sram_free(tsk->bd);
	kfree(tsk->cookie);
	kfree(tsk);
}
EXPORT_SYMBOL_GPL(bcom_task_free);

int
bcom_load_image(int task, u32 *task_image)
{
	struct bcom_task_header *hdr = (struct bcom_task_header *)task_image;
	struct bcom_tdt *tdt;
	u32 *desc, *var, *inc;
	u32 *desc_src, *var_src, *inc_src;

	/* Safety checks */
	if (hdr->magic != BCOM_TASK_MAGIC) {
		printk(KERN_ERR DRIVER_NAME
			": Trying to load invalid microcode\n");
		return -EINVAL;
	}

	if ((task < 0) || (task >= BCOM_MAX_TASKS)) {
		printk(KERN_ERR DRIVER_NAME
			": Trying to load invalid task %d\n", task);
		return -EINVAL;
	}

	/* Initial load or reload */
	tdt = &bcom_eng->tdt[task];

	if (tdt->start) {
		desc = bcom_task_desc(task);
		if (hdr->desc_size != bcom_task_num_descs(task)) {
			printk(KERN_ERR DRIVER_NAME
				": Trying to reload wrong task image "
				"(%d size %d/%d)!\n",
				task,
				hdr->desc_size,
				bcom_task_num_descs(task));
			return -EINVAL;
		}
	} else {
		phys_addr_t start_pa;

		desc = bcom_sram_alloc(hdr->desc_size * sizeof(u32), 4, &start_pa);
		if (!desc)
			return -ENOMEM;

		tdt->start = start_pa;
		tdt->stop = start_pa + ((hdr->desc_size-1) * sizeof(u32));
	}

	var = bcom_task_var(task);
	inc = bcom_task_inc(task);

	/* Clear & copy */
	memset(var, 0x00, BCOM_VAR_SIZE);
	memset(inc, 0x00, BCOM_INC_SIZE);

	desc_src = (u32 *)(hdr + 1);
	var_src = desc_src + hdr->desc_size;
	inc_src = var_src + hdr->var_size;

	memcpy(desc, desc_src, hdr->desc_size * sizeof(u32));
	memcpy(var + hdr->first_var, var_src, hdr->var_size * sizeof(u32));
	memcpy(inc, inc_src, hdr->inc_size * sizeof(u32));

	return 0;
}
EXPORT_SYMBOL_GPL(bcom_load_image);

void
bcom_set_initiator(int task, int initiator)
{
	int i;
	int num_descs;
	u32 *desc;
	int next_drd_has_initiator;

	bcom_set_tcr_initiator(task, initiator);

	/* Just setting tcr is apparently not enough due to some problem */
	/* with it. So we just go thru all the microcode and replace in  */
	/* the DRD directly */

	desc = bcom_task_desc(task);
	next_drd_has_initiator = 1;
	num_descs = bcom_task_num_descs(task);

	for (i=0; i<num_descs; i++, desc++) {
		if (!bcom_desc_is_drd(*desc))
			continue;
		if (next_drd_has_initiator)
			if (bcom_desc_initiator(*desc) != BCOM_INITIATOR_ALWAYS)
				bcom_set_desc_initiator(desc, initiator);
		next_drd_has_initiator = !bcom_drd_is_extended(*desc);
	}
}
EXPORT_SYMBOL_GPL(bcom_set_initiator);


/* Public API */

void
bcom_enable(struct bcom_task *tsk)
{
	bcom_enable_task(tsk->tasknum);
}
EXPORT_SYMBOL_GPL(bcom_enable);

void
bcom_disable(struct bcom_task *tsk)
{
	bcom_disable_task(tsk->tasknum);
}
EXPORT_SYMBOL_GPL(bcom_disable);


/* ======================================================================== */
/* Engine init/cleanup                                                      */
/* ======================================================================== */

/* Function Descriptor table */
/* this will need to be updated if Freescale changes their task code FDT */
static u32 fdt_ops[] = {
	0xa0045670,	/* FDT[48] - load_acc()	  */
	0x80045670,	/* FDT[49] - unload_acc() */
	0x21800000,	/* FDT[50] - and()        */
	0x21e00000,	/* FDT[51] - or()         */
	0x21500000,	/* FDT[52] - xor()        */
	0x21400000,	/* FDT[53] - andn()       */
	0x21500000,	/* FDT[54] - not()        */
	0x20400000,	/* FDT[55] - add()        */
	0x20500000,	/* FDT[56] - sub()        */
	0x20800000,	/* FDT[57] - lsh()        */
	0x20a00000,	/* FDT[58] - rsh()        */
	0xc0170000,	/* FDT[59] - crc8()       */
	0xc0145670,	/* FDT[60] - crc16()      */
	0xc0345670,	/* FDT[61] - crc32()      */
	0xa0076540,	/* FDT[62] - endian32()   */
	0xa0000760,	/* FDT[63] - endian16()   */
};


static int __devinit
bcom_engine_init(void)
{
	int task;
	phys_addr_t tdt_pa, ctx_pa, var_pa, fdt_pa;
	unsigned int tdt_size, ctx_size, var_size, fdt_size;
	u16 regval;

	/* Allocate & clear SRAM zones for FDT, TDTs, contexts and vars/incs */
	tdt_size = BCOM_MAX_TASKS * sizeof(struct bcom_tdt);
	ctx_size = BCOM_MAX_TASKS * BCOM_CTX_SIZE;
	var_size = BCOM_MAX_TASKS * (BCOM_VAR_SIZE + BCOM_INC_SIZE);
	fdt_size = BCOM_FDT_SIZE;

	bcom_eng->tdt = bcom_sram_alloc(tdt_size, sizeof(u32), &tdt_pa);
	bcom_eng->ctx = bcom_sram_alloc(ctx_size, BCOM_CTX_ALIGN, &ctx_pa);
	bcom_eng->var = bcom_sram_alloc(var_size, BCOM_VAR_ALIGN, &var_pa);
	bcom_eng->fdt = bcom_sram_alloc(fdt_size, BCOM_FDT_ALIGN, &fdt_pa);

	if (!bcom_eng->tdt || !bcom_eng->ctx || !bcom_eng->var || !bcom_eng->fdt) {
		printk(KERN_ERR "DMA: SRAM alloc failed in engine init !\n");

		bcom_sram_free(bcom_eng->tdt);
		bcom_sram_free(bcom_eng->ctx);
		bcom_sram_free(bcom_eng->var);
		bcom_sram_free(bcom_eng->fdt);

		return -ENOMEM;
	}

	memset(bcom_eng->tdt, 0x00, tdt_size);
	memset(bcom_eng->ctx, 0x00, ctx_size);
	memset(bcom_eng->var, 0x00, var_size);
	memset(bcom_eng->fdt, 0x00, fdt_size);

	/* Copy the FDT for the EU#3 */
	memcpy(&bcom_eng->fdt[48], fdt_ops, sizeof(fdt_ops));

	/* Initialize Task base structure */
	for (task=0; task<BCOM_MAX_TASKS; task++)
	{
		out_be16(&bcom_eng->regs->tcr[task], 0);
		out_8(&bcom_eng->regs->ipr[task], 0);

		bcom_eng->tdt[task].context	= ctx_pa;
		bcom_eng->tdt[task].var	= var_pa;
		bcom_eng->tdt[task].fdt	= fdt_pa;

		var_pa += BCOM_VAR_SIZE + BCOM_INC_SIZE;
		ctx_pa += BCOM_CTX_SIZE;
	}

	out_be32(&bcom_eng->regs->taskBar, tdt_pa);

	/* Init 'always' initiator */
	out_8(&bcom_eng->regs->ipr[BCOM_INITIATOR_ALWAYS], BCOM_IPR_ALWAYS);

	/* Disable COMM Bus Prefetch on the original 5200; it's broken */
	if ((mfspr(SPRN_SVR) & MPC5200_SVR_MASK) == MPC5200_SVR) {
		regval = in_be16(&bcom_eng->regs->PtdCntrl);
		out_be16(&bcom_eng->regs->PtdCntrl,  regval | 1);
	}

	/* Init lock */
	spin_lock_init(&bcom_eng->lock);

	return 0;
}

static void
bcom_engine_cleanup(void)
{
	int task;

	/* Stop all tasks */
	for (task=0; task<BCOM_MAX_TASKS; task++)
	{
		out_be16(&bcom_eng->regs->tcr[task], 0);
		out_8(&bcom_eng->regs->ipr[task], 0);
	}

	out_be32(&bcom_eng->regs->taskBar, 0ul);

	/* Release the SRAM zones */
	bcom_sram_free(bcom_eng->tdt);
	bcom_sram_free(bcom_eng->ctx);
	bcom_sram_free(bcom_eng->var);
	bcom_sram_free(bcom_eng->fdt);
}


/* ======================================================================== */
/* OF platform driver                                                       */
/* ======================================================================== */

static int __devinit
mpc52xx_bcom_probe(struct of_device *op, const struct of_device_id *match)
{
	struct device_node *ofn_sram;
	struct resource res_bcom;

	int rv;

	/* Inform user we're ok so far */
	printk(KERN_INFO "DMA: MPC52xx BestComm driver\n");

	/* Get the bestcomm node */
	of_node_get(op->node);

	/* Prepare SRAM */
	ofn_sram = of_find_compatible_node(NULL, "sram", "mpc5200-sram");
	if (!ofn_sram) {
		printk(KERN_ERR DRIVER_NAME ": "
			"No SRAM found in device tree\n");
		rv = -ENODEV;
		goto error_ofput;
	}
	rv = bcom_sram_init(ofn_sram, DRIVER_NAME);
	of_node_put(ofn_sram);

	if (rv) {
		printk(KERN_ERR DRIVER_NAME ": "
			"Error in SRAM init\n");
		goto error_ofput;
	}

	/* Get a clean struct */
	bcom_eng = kzalloc(sizeof(struct bcom_engine), GFP_KERNEL);
	if (!bcom_eng) {
		printk(KERN_ERR DRIVER_NAME ": "
			"Can't allocate state structure\n");
		rv = -ENOMEM;
		goto error_sramclean;
	}

	/* Save the node */
	bcom_eng->ofnode = op->node;

	/* Get, reserve & map io */
	if (of_address_to_resource(op->node, 0, &res_bcom)) {
		printk(KERN_ERR DRIVER_NAME ": "
			"Can't get resource\n");
		rv = -EINVAL;
		goto error_sramclean;
	}

	if (!request_mem_region(res_bcom.start, sizeof(struct mpc52xx_sdma),
				DRIVER_NAME)) {
		printk(KERN_ERR DRIVER_NAME ": "
			"Can't request registers region\n");
		rv = -EBUSY;
		goto error_sramclean;
	}

	bcom_eng->regs_base = res_bcom.start;
	bcom_eng->regs = ioremap(res_bcom.start, sizeof(struct mpc52xx_sdma));
	if (!bcom_eng->regs) {
		printk(KERN_ERR DRIVER_NAME ": "
			"Can't map registers\n");
		rv = -ENOMEM;
		goto error_release;
	}

	/* Now, do the real init */
	rv = bcom_engine_init();
	if (rv)
		goto error_unmap;

	/* Done ! */
	printk(KERN_INFO "DMA: MPC52xx BestComm engine @%08lx ok !\n",
		bcom_eng->regs_base);

	return 0;

	/* Error path */
error_unmap:
	iounmap(bcom_eng->regs);
error_release:
	release_mem_region(res_bcom.start, sizeof(struct mpc52xx_sdma));
error_sramclean:
	kfree(bcom_eng);
	bcom_sram_cleanup();
error_ofput:
	of_node_put(op->node);

	printk(KERN_ERR "DMA: MPC52xx BestComm init failed !\n");

	return rv;
}


static int
mpc52xx_bcom_remove(struct of_device *op)
{
	/* Clean up the engine */
	bcom_engine_cleanup();

	/* Cleanup SRAM */
	bcom_sram_cleanup();

	/* Release regs */
	iounmap(bcom_eng->regs);
	release_mem_region(bcom_eng->regs_base, sizeof(struct mpc52xx_sdma));

	/* Release the node */
	of_node_put(bcom_eng->ofnode);

	/* Release memory */
	kfree(bcom_eng);
	bcom_eng = NULL;

	return 0;
}

static struct of_device_id mpc52xx_bcom_of_match[] = {
	{
		.type		= "dma-controller",
		.compatible	= "mpc5200-bestcomm",
	},
	{},
};

MODULE_DEVICE_TABLE(of, mpc52xx_bcom_of_match);


static struct of_platform_driver mpc52xx_bcom_of_platform_driver = {
	.owner		= THIS_MODULE,
	.name		= DRIVER_NAME,
	.match_table	= mpc52xx_bcom_of_match,
	.probe		= mpc52xx_bcom_probe,
	.remove		= mpc52xx_bcom_remove,
	.driver		= {
		.name	= DRIVER_NAME,
		.owner	= THIS_MODULE,
	},
};


/* ======================================================================== */
/* Module                                                                   */
/* ======================================================================== */

static int __init
mpc52xx_bcom_init(void)
{
	return of_register_platform_driver(&mpc52xx_bcom_of_platform_driver);
}

static void __exit
mpc52xx_bcom_exit(void)
{
	of_unregister_platform_driver(&mpc52xx_bcom_of_platform_driver);
}

/* If we're not a module, we must make sure everything is setup before  */
/* anyone tries to use us ... that's why we use subsys_initcall instead */
/* of module_init. */
subsys_initcall(mpc52xx_bcom_init);
module_exit(mpc52xx_bcom_exit);

MODULE_DESCRIPTION("Freescale MPC52xx BestComm DMA");
MODULE_AUTHOR("Sylvain Munaut <tnt@246tNt.com>");
MODULE_AUTHOR("Andrey Volkov <avolkov@varma-el.com>");
MODULE_AUTHOR("Dale Farnsworth <dfarnsworth@mvista.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
2f9ea1bd SM	1	/*
	2	* Driver for MPC52xx processor BestComm peripheral controller
	3	*
	4	*
	5	* Copyright (C) 2006-2007 Sylvain Munaut <tnt@246tNt.com>
	6	* Copyright (C) 2005 Varma Electronics Oy,
	7	* ( by Andrey Volkov <avolkov@varma-el.com> )
	8	* Copyright (C) 2003-2004 MontaVista, Software, Inc.
	9	* ( by Dale Farnsworth <dfarnsworth@mvista.com> )
	10	*
	11	* This file is licensed under the terms of the GNU General Public License
	12	* version 2. This program is licensed "as is" without any warranty of any
	13	* kind, whether express or implied.
	14	*/
	15
	16	#include <linux/module.h>
	17	#include <linux/kernel.h>
	18	#include <linux/slab.h>
	19	#include <linux/of.h>
	20	#include <linux/of_device.h>
	21	#include <linux/of_platform.h>
	22	#include <asm/io.h>
	23	#include <asm/irq.h>
	24	#include <asm/mpc52xx.h>
	25
	26	#include "sram.h"
	27	#include "bestcomm_priv.h"
	28	#include "bestcomm.h"
	29
	30	#define DRIVER_NAME "bestcomm-core"
	31
	32
	33	struct bcom_engine *bcom_eng = NULL;
	34	EXPORT_SYMBOL_GPL(bcom_eng); /* needed for inline functions */
	35
	36
	37	/* ======================================================================== */
	38	/* Public and private API */
	39	/* ======================================================================== */
	40
	41	/* Private API */
	42
	43	struct bcom_task *
	44	bcom_task_alloc(int bd_count, int bd_size, int priv_size)
	45	{
	46	int i, tasknum = -1;
	47	struct bcom_task *tsk;
	48
	49	/* Get and reserve a task num */
	50	spin_lock(&bcom_eng->lock);
	51
	52	for (i=0; i<BCOM_MAX_TASKS; i++)
	53	if (!bcom_eng->tdt[i].stop) { /* we use stop as a marker */
	54	bcom_eng->tdt[i].stop = 0xfffffffful; /* dummy addr */
	55	tasknum = i;
	56	break;
	57	}
	58
	59	spin_unlock(&bcom_eng->lock);
	60
	61	if (tasknum < 0)
	62	return NULL;
	63
	64	/* Allocate our structure */
65	tsk = kzalloc(sizeof(struct bcom_task) + priv_size, GFP_KERNEL);
66	if (!tsk)
67	goto error;
68
69	tsk->tasknum = tasknum;
70	if (priv_size)
71	tsk->priv = (void*)tsk + sizeof(struct bcom_task);
72
73	/* Get IRQ of that task */
74	tsk->irq = irq_of_parse_and_map(bcom_eng->ofnode, tsk->tasknum);
75	if (tsk->irq == NO_IRQ)
76	goto error;
77
78	/* Init the BDs, if needed */
79	if (bd_count) {
80	tsk->cookie = kmalloc(sizeof(void) bd_count, GFP_KERNEL);
81	if (!tsk->cookie)
82	goto error;
83
84	tsk->bd = bcom_sram_alloc(bd_count * bd_size, 4, &tsk->bd_pa);
85	if (!tsk->bd)
86	goto error;
87	memset(tsk->bd, 0x00, bd_count * bd_size);
88
89	tsk->num_bd = bd_count;
90	tsk->bd_size = bd_size;
91	}
92
93	return tsk;
94
95	error:
96	if (tsk) {
97	if (tsk->irq != NO_IRQ)
98	irq_dispose_mapping(tsk->irq);
99	bcom_sram_free(tsk->bd);
100	kfree(tsk->cookie);
101	kfree(tsk);
102	}
103
104	bcom_eng->tdt[tasknum].stop = 0;
105
106	return NULL;
107	}
108	EXPORT_SYMBOL_GPL(bcom_task_alloc);
109
110	void
111	bcom_task_free(struct bcom_task *tsk)
112	{
113	/* Stop the task */
114	bcom_disable_task(tsk->tasknum);
115
116	/* Clear TDT */
117	bcom_eng->tdt[tsk->tasknum].start = 0;
118	bcom_eng->tdt[tsk->tasknum].stop = 0;
119
120	/* Free everything */
121	irq_dispose_mapping(tsk->irq);
122	bcom_sram_free(tsk->bd);
123	kfree(tsk->cookie);
124	kfree(tsk);
125	}
126	EXPORT_SYMBOL_GPL(bcom_task_free);
127
128	int
129	bcom_load_image(int task, u32 *task_image)
130	{
131	struct bcom_task_header hdr = (struct bcom_task_header )task_image;
132	struct bcom_tdt *tdt;
133	u32 desc, var, *inc;
134	u32 desc_src, var_src, *inc_src;
135
136	/* Safety checks */
137	if (hdr->magic != BCOM_TASK_MAGIC) {
138	printk(KERN_ERR DRIVER_NAME
139	": Trying to load invalid microcode\n");
140	return -EINVAL;
141	}
142
143	if ((task < 0) \|\| (task >= BCOM_MAX_TASKS)) {
144	printk(KERN_ERR DRIVER_NAME
145	": Trying to load invalid task %d\n", task);
146	return -EINVAL;
147	}
148
149	/* Initial load or reload */
150	tdt = &bcom_eng->tdt[task];
151
152	if (tdt->start) {
153	desc = bcom_task_desc(task);
154	if (hdr->desc_size != bcom_task_num_descs(task)) {
155	printk(KERN_ERR DRIVER_NAME
156	": Trying to reload wrong task image "
157	"(%d size %d/%d)!\n",
158	task,
159	hdr->desc_size,
160	bcom_task_num_descs(task));
161	return -EINVAL;
162	}
163	} else {
164	phys_addr_t start_pa;
165
166	desc = bcom_sram_alloc(hdr->desc_size * sizeof(u32), 4, &start_pa);
167	if (!desc)
168	return -ENOMEM;
169
170	tdt->start = start_pa;
171	tdt->stop = start_pa + ((hdr->desc_size-1) * sizeof(u32));
172	}
173
174	var = bcom_task_var(task);
175	inc = bcom_task_inc(task);
176
177	/* Clear & copy */
178	memset(var, 0x00, BCOM_VAR_SIZE);
179	memset(inc, 0x00, BCOM_INC_SIZE);
180
181	desc_src = (u32 *)(hdr + 1);
182	var_src = desc_src + hdr->desc_size;
183	inc_src = var_src + hdr->var_size;
184
185	memcpy(desc, desc_src, hdr->desc_size * sizeof(u32));
186	memcpy(var + hdr->first_var, var_src, hdr->var_size * sizeof(u32));
187	memcpy(inc, inc_src, hdr->inc_size * sizeof(u32));
188
189	return 0;
190	}
191	EXPORT_SYMBOL_GPL(bcom_load_image);
192
193	void
194	bcom_set_initiator(int task, int initiator)
195	{
196	int i;
197	int num_descs;
198	u32 *desc;
199	int next_drd_has_initiator;
200
201	bcom_set_tcr_initiator(task, initiator);
202
203	/* Just setting tcr is apparently not enough due to some problem */
204	/* with it. So we just go thru all the microcode and replace in */
205	/* the DRD directly */
206
207	desc = bcom_task_desc(task);
208	next_drd_has_initiator = 1;
209	num_descs = bcom_task_num_descs(task);
210
211	for (i=0; i<num_descs; i++, desc++) {
212	if (!bcom_desc_is_drd(*desc))
213	continue;
214	if (next_drd_has_initiator)
215	if (bcom_desc_initiator(*desc) != BCOM_INITIATOR_ALWAYS)
216	bcom_set_desc_initiator(desc, initiator);
217	next_drd_has_initiator = !bcom_drd_is_extended(*desc);
218	}
219	}
220	EXPORT_SYMBOL_GPL(bcom_set_initiator);
221
222
223	/* Public API */
224
225	void
226	bcom_enable(struct bcom_task *tsk)
227	{
228	bcom_enable_task(tsk->tasknum);
229	}
230	EXPORT_SYMBOL_GPL(bcom_enable);
231
232	void
233	bcom_disable(struct bcom_task *tsk)
234	{
235	bcom_disable_task(tsk->tasknum);
236	}
237	EXPORT_SYMBOL_GPL(bcom_disable);
238
239
240	/* ======================================================================== */
241	/* Engine init/cleanup */
242	/* ======================================================================== */
243
244	/* Function Descriptor table */
245	/* this will need to be updated if Freescale changes their task code FDT */
246	static u32 fdt_ops[] = {
247	0xa0045670, /* FDT[48] - load_acc() */
248	0x80045670, /* FDT[49] - unload_acc() */
249	0x21800000, /* FDT[50] - and() */
250	0x21e00000, /* FDT[51] - or() */
251	0x21500000, /* FDT[52] - xor() */
252	0x21400000, /* FDT[53] - andn() */
253	0x21500000, /* FDT[54] - not() */
254	0x20400000, /* FDT[55] - add() */
255	0x20500000, /* FDT[56] - sub() */
256	0x20800000, /* FDT[57] - lsh() */
257	0x20a00000, /* FDT[58] - rsh() */
258	0xc0170000, /* FDT[59] - crc8() */
259	0xc0145670, /* FDT[60] - crc16() */
260	0xc0345670, /* FDT[61] - crc32() */
261	0xa0076540, /* FDT[62] - endian32() */
262	0xa0000760, /* FDT[63] - endian16() */
263	};
264
265
266	static int __devinit
267	bcom_engine_init(void)
268	{
269	int task;
270	phys_addr_t tdt_pa, ctx_pa, var_pa, fdt_pa;
271	unsigned int tdt_size, ctx_size, var_size, fdt_size;
c052a22e	272	u16 regval;
2f9ea1bd SM	273
	274	/* Allocate & clear SRAM zones for FDT, TDTs, contexts and vars/incs */
	275	tdt_size = BCOM_MAX_TASKS * sizeof(struct bcom_tdt);
	276	ctx_size = BCOM_MAX_TASKS * BCOM_CTX_SIZE;
	277	var_size = BCOM_MAX_TASKS * (BCOM_VAR_SIZE + BCOM_INC_SIZE);
	278	fdt_size = BCOM_FDT_SIZE;
	279
	280	bcom_eng->tdt = bcom_sram_alloc(tdt_size, sizeof(u32), &tdt_pa);
	281	bcom_eng->ctx = bcom_sram_alloc(ctx_size, BCOM_CTX_ALIGN, &ctx_pa);
	282	bcom_eng->var = bcom_sram_alloc(var_size, BCOM_VAR_ALIGN, &var_pa);
	283	bcom_eng->fdt = bcom_sram_alloc(fdt_size, BCOM_FDT_ALIGN, &fdt_pa);
	284
	285	if (!bcom_eng->tdt \|\| !bcom_eng->ctx \|\| !bcom_eng->var \|\| !bcom_eng->fdt) {
	286	printk(KERN_ERR "DMA: SRAM alloc failed in engine init !\n");
	287
	288	bcom_sram_free(bcom_eng->tdt);
	289	bcom_sram_free(bcom_eng->ctx);
	290	bcom_sram_free(bcom_eng->var);
	291	bcom_sram_free(bcom_eng->fdt);
	292
	293	return -ENOMEM;
	294	}
	295
	296	memset(bcom_eng->tdt, 0x00, tdt_size);
	297	memset(bcom_eng->ctx, 0x00, ctx_size);
	298	memset(bcom_eng->var, 0x00, var_size);
	299	memset(bcom_eng->fdt, 0x00, fdt_size);
	300
	301	/* Copy the FDT for the EU#3 */
	302	memcpy(&bcom_eng->fdt[48], fdt_ops, sizeof(fdt_ops));
	303
	304	/* Initialize Task base structure */
	305	for (task=0; task<BCOM_MAX_TASKS; task++)
	306	{
	307	out_be16(&bcom_eng->regs->tcr[task], 0);
	308	out_8(&bcom_eng->regs->ipr[task], 0);
	309
	310	bcom_eng->tdt[task].context = ctx_pa;
	311	bcom_eng->tdt[task].var = var_pa;
	312	bcom_eng->tdt[task].fdt = fdt_pa;
	313
	314	var_pa += BCOM_VAR_SIZE + BCOM_INC_SIZE;
	315	ctx_pa += BCOM_CTX_SIZE;
	316	}
	317
	318	out_be32(&bcom_eng->regs->taskBar, tdt_pa);
	319
	320	/* Init 'always' initiator */
	321	out_8(&bcom_eng->regs->ipr[BCOM_INITIATOR_ALWAYS], BCOM_IPR_ALWAYS);
	322
c052a22e GL	323	/* Disable COMM Bus Prefetch on the original 5200; it's broken */
	324	if ((mfspr(SPRN_SVR) & MPC5200_SVR_MASK) == MPC5200_SVR) {
	325	regval = in_be16(&bcom_eng->regs->PtdCntrl);
	326	out_be16(&bcom_eng->regs->PtdCntrl, regval \| 1);
	327	}
2f9ea1bd SM	328
	329	/* Init lock */
	330	spin_lock_init(&bcom_eng->lock);
	331
	332	return 0;
	333	}
	334
	335	static void
	336	bcom_engine_cleanup(void)
	337	{
	338	int task;
	339
	340	/* Stop all tasks */
	341	for (task=0; task<BCOM_MAX_TASKS; task++)
	342	{
	343	out_be16(&bcom_eng->regs->tcr[task], 0);
	344	out_8(&bcom_eng->regs->ipr[task], 0);
	345	}
	346
	347	out_be32(&bcom_eng->regs->taskBar, 0ul);
	348
	349	/* Release the SRAM zones */
	350	bcom_sram_free(bcom_eng->tdt);
	351	bcom_sram_free(bcom_eng->ctx);
	352	bcom_sram_free(bcom_eng->var);
	353	bcom_sram_free(bcom_eng->fdt);
	354	}
	355
	356
	357	/* ======================================================================== */
	358	/* OF platform driver */
	359	/* ======================================================================== */
	360
	361	static int __devinit
	362	mpc52xx_bcom_probe(struct of_device op, const struct of_device_id match)
	363	{
	364	struct device_node *ofn_sram;
	365	struct resource res_bcom;
	366
	367	int rv;
	368
	369	/* Inform user we're ok so far */
	370	printk(KERN_INFO "DMA: MPC52xx BestComm driver\n");
	371
	372	/* Get the bestcomm node */
	373	of_node_get(op->node);
	374
	375	/* Prepare SRAM */
	376	ofn_sram = of_find_compatible_node(NULL, "sram", "mpc5200-sram");
	377	if (!ofn_sram) {
	378	printk(KERN_ERR DRIVER_NAME ": "
	379	"No SRAM found in device tree\n");
	380	rv = -ENODEV;
	381	goto error_ofput;
	382	}
	383	rv = bcom_sram_init(ofn_sram, DRIVER_NAME);
	384	of_node_put(ofn_sram);
	385
	386	if (rv) {
	387	printk(KERN_ERR DRIVER_NAME ": "
	388	"Error in SRAM init\n");
	389	goto error_ofput;
	390	}
	391
392	/* Get a clean struct */
393	bcom_eng = kzalloc(sizeof(struct bcom_engine), GFP_KERNEL);
394	if (!bcom_eng) {
395	printk(KERN_ERR DRIVER_NAME ": "
396	"Can't allocate state structure\n");
397	rv = -ENOMEM;
398	goto error_sramclean;
399	}
400
401	/* Save the node */
402	bcom_eng->ofnode = op->node;
403
404	/* Get, reserve & map io */
405	if (of_address_to_resource(op->node, 0, &res_bcom)) {
406	printk(KERN_ERR DRIVER_NAME ": "
407	"Can't get resource\n");
408	rv = -EINVAL;
409	goto error_sramclean;
410	}
411
412	if (!request_mem_region(res_bcom.start, sizeof(struct mpc52xx_sdma),
413	DRIVER_NAME)) {
414	printk(KERN_ERR DRIVER_NAME ": "
415	"Can't request registers region\n");
416	rv = -EBUSY;
417	goto error_sramclean;
418	}
419
420	bcom_eng->regs_base = res_bcom.start;
421	bcom_eng->regs = ioremap(res_bcom.start, sizeof(struct mpc52xx_sdma));
422	if (!bcom_eng->regs) {
423	printk(KERN_ERR DRIVER_NAME ": "
424	"Can't map registers\n");
425	rv = -ENOMEM;
426	goto error_release;
427	}
428
429	/* Now, do the real init */
430	rv = bcom_engine_init();
431	if (rv)
432	goto error_unmap;
433
434	/* Done ! */
435	printk(KERN_INFO "DMA: MPC52xx BestComm engine @%08lx ok !\n",
436	bcom_eng->regs_base);
437
438	return 0;
439
440	/* Error path */
441	error_unmap:
442	iounmap(bcom_eng->regs);
443	error_release:
444	release_mem_region(res_bcom.start, sizeof(struct mpc52xx_sdma));
445	error_sramclean:
446	kfree(bcom_eng);
447	bcom_sram_cleanup();
448	error_ofput:
449	of_node_put(op->node);
450
451	printk(KERN_ERR "DMA: MPC52xx BestComm init failed !\n");
452
453	return rv;
454	}
455
456
457	static int
458	mpc52xx_bcom_remove(struct of_device *op)
459	{
460	/* Clean up the engine */
461	bcom_engine_cleanup();
462
463	/* Cleanup SRAM */
464	bcom_sram_cleanup();
465
466	/* Release regs */
467	iounmap(bcom_eng->regs);
468	release_mem_region(bcom_eng->regs_base, sizeof(struct mpc52xx_sdma));
469
470	/* Release the node */
471	of_node_put(bcom_eng->ofnode);
472
473	/* Release memory */
474	kfree(bcom_eng);
475	bcom_eng = NULL;
476
477	return 0;
478	}
479
480	static struct of_device_id mpc52xx_bcom_of_match[] = {
481	{
482	.type = "dma-controller",
483	.compatible = "mpc5200-bestcomm",
484	},
485	{},
486	};
487
488	MODULE_DEVICE_TABLE(of, mpc52xx_bcom_of_match);
489
490
491	static struct of_platform_driver mpc52xx_bcom_of_platform_driver = {
492	.owner = THIS_MODULE,
493	.name = DRIVER_NAME,
494	.match_table = mpc52xx_bcom_of_match,
495	.probe = mpc52xx_bcom_probe,
496	.remove = mpc52xx_bcom_remove,
497	.driver = {
498	.name = DRIVER_NAME,
499	.owner = THIS_MODULE,
500	},
501	};
502
503
504	/* ======================================================================== */
505	/* Module */
506	/* ======================================================================== */
507
508	static int __init
509	mpc52xx_bcom_init(void)
510	{
511	return of_register_platform_driver(&mpc52xx_bcom_of_platform_driver);
512	}
513
514	static void __exit
515	mpc52xx_bcom_exit(void)
516	{
517	of_unregister_platform_driver(&mpc52xx_bcom_of_platform_driver);
518	}
519
520	/* If we're not a module, we must make sure everything is setup before */
521	/* anyone tries to use us ... that's why we use subsys_initcall instead */
522	/* of module_init. */
523	subsys_initcall(mpc52xx_bcom_init);
524	module_exit(mpc52xx_bcom_exit);
525
526	MODULE_DESCRIPTION("Freescale MPC52xx BestComm DMA");
527	MODULE_AUTHOR("Sylvain Munaut <tnt@246tNt.com>");
528	MODULE_AUTHOR("Andrey Volkov <avolkov@varma-el.com>");
529	MODULE_AUTHOR("Dale Farnsworth <dfarnsworth@mvista.com>");
530	MODULE_LICENSE("GPL v2");
531