Subversion Repositories funbase_ip_library

/*
 * Copyright (c) 2010, Mentor Graphics Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. Neither the name of the <ORGANIZATION> nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/platform_device.h>
 
#include <asm/io.h>
#include <asm/pgtable.h>
 
#include "mcomm.h"
#include "mcomm_dev.h"
 
/* extracted from the bowels of Marvell's arch/arm/mach-feroceon-mv78xx0 */
/* XXX add these to appropriate Linux headers */
#define CPU_IF_BASE(cpu)		(0xF1020000 + ((cpu) << 14))
#define AHB_TO_MBUS_BASE          	CPU_IF_BASE
#define INBOUND_DOORBELL(cpu)	(AHB_TO_MBUS_BASE(cpu) + 0x400)
#define INBOUND_DOORBELL_MASK(cpu)	(AHB_TO_MBUS_BASE(cpu) + 0x404)
 
#define DOORBELL_NR 0
#define DOORBELL_VAL (1<<DOORBELL_NR)
 
static struct mcomm_mv78xx0_data {
	void __iomem *dbell[2]; /* "inbound" doorbells */
	void __iomem *dbell_mask;
	unsigned int cpu_nr;
} mcomm_mv78xx0_data;
 
/* MV78xx0 is a dual-core ARMv5 processor. It does not provide implicit data
 * cache coherence between the two cores, so to simplify software we map the
 * shared memory non-cacheable in both user and kernel space. */
 
static pgprot_t mcomm_mv78xx0_mmap_pgprot(struct vm_area_struct *vma)
{
	return pgprot_noncached(vma->vm_page_prot);
}
 
static void __iomem *mcomm_mv78xx0_ioremap(unsigned long phys_addr, size_t size)
{
	return ioremap_nocache(phys_addr, size);
}
 
static void mcomm_mv78xx0_notify(u32 core_nr)
{
	BUG_ON(core_nr > 1);
 
	/* set the other core's inbound doorbell */
	writel(DOORBELL_VAL, mcomm_mv78xx0_data.dbell[core_nr]);
}
 
static void mcomm_mv78xx0_ack(void)
{
	/* clear this core's inbound doorbell */
	writel(0x0, mcomm_mv78xx0_data.dbell[mcomm_mv78xx0_data.cpu_nr]);
}
 
static unsigned long mcomm_mv78xx0_cpuid(void)
{
	return mcomm_mv78xx0_data.cpu_nr;
}
 
static struct mcomm_platform_ops mcomm_mv78xx0_ops = {
	.mmap_pgprot = mcomm_mv78xx0_mmap_pgprot,
	.map = mcomm_mv78xx0_ioremap,
	.notify = mcomm_mv78xx0_notify,
	.ack = mcomm_mv78xx0_ack,
	.cpuid = mcomm_mv78xx0_cpuid,
};
 
 
static void mcomm_mv78xx0_hwinit(void)
{
	unsigned int cpu_nr;
	u32 reg;
 
	__asm__ __volatile__ (
		"mrc p15, 1, %0, c15, c1, 0 @ read control reg\n"
		: "=r" (reg)
	);
 
	cpu_nr = (reg >> 14) & 0x1;
 
	mcomm_mv78xx0_data.cpu_nr = cpu_nr;
	mcomm_mv78xx0_data.dbell[0] = ioremap(INBOUND_DOORBELL(0), 4);
	mcomm_mv78xx0_data.dbell[1] = ioremap(INBOUND_DOORBELL(1), 4);
	mcomm_mv78xx0_data.dbell_mask = ioremap(INBOUND_DOORBELL_MASK(cpu_nr), 4);
 
	/* Clear any pending interrupts. */
	writel(0x0, mcomm_mv78xx0_data.dbell[cpu_nr]);
 
	/* Enable IRQs for our doorbell bits. */
	writel(DOORBELL_VAL, mcomm_mv78xx0_data.dbell_mask);
}
 
static int __devinit mcomm_probe(struct platform_device *pdev)
{
	struct resource *mem;
	struct resource *irq;
 
	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!mem)
		return -EINVAL;
 
	irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (!irq)
		return -EINVAL;
 
	mcomm_mv78xx0_hwinit();
 
	return mcomm_new_region(&pdev->dev, mem, irq);
}
 
static void mcomm_mv78xx0_hwuninit(void)
{
	iounmap(mcomm_mv78xx0_data.dbell[0]);
	iounmap(mcomm_mv78xx0_data.dbell[1]);
 
	/* Disable doorbell IRQ again. */
	writel(0x0, mcomm_mv78xx0_data.dbell_mask);
	iounmap(mcomm_mv78xx0_data.dbell_mask);
}
 
static int mcomm_remove(struct platform_device *pdev)
{
	mcomm_remove_region(&pdev->dev);
	mcomm_mv78xx0_hwuninit();
 
	return 0;
}
 
static struct platform_driver mcomm_driver = {
	.probe = mcomm_probe,
	.remove = mcomm_remove,
	.driver = {
		   .name = "mcomm",
	}
};
 
 
static int __init mcomm_mv78xx0_modinit(void)
{
	int rc;
 
	rc = mcomm_init(&mcomm_mv78xx0_ops, THIS_MODULE);
	if (rc) {
		printk(KERN_ERR "%s: Failed to initialize mcomm driver.\n", __func__);
		goto out1;
	}
 
	rc = platform_driver_register(&mcomm_driver);
	if (rc) {
		printk(KERN_ERR "%s: Failed to register platform driver.\n", __func__);
		goto out2;
	}
 
	/* Finally, register an mcomm device. We can only have one, so if there's
	 * an error we should just give up. */
	rc = mcomm_pdev_add();
	if (rc)
		goto out3;
 
	return 0;
 
out3:
	platform_driver_unregister(&mcomm_driver);
out2:
	mcomm_exit();
out1:
	return rc;
}
module_init(mcomm_mv78xx0_modinit);
 
static void mcomm_mv78xx0_modexit(void)
{
	mcomm_pdev_release();
	platform_driver_unregister(&mcomm_driver);
	mcomm_exit();
}
module_exit(mcomm_mv78xx0_modexit);
 
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Hollis Blanchard <hollis_blanchard@mentor.com>");
MODULE_DESCRIPTION("Marvell 78xx0 platform support for multi-core shared memory channel");