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/mod_devicetable.h>
#include <linux/of_platform.h>
 
#include <asm/io.h>
#include <asm/pgtable.h>
#include <asm/prom.h>
#include <asm/of_device.h>
#include <asm/fsl_msg.h>
 
#include "mcomm.h"
 
#define MESSAGE_VAL 1
 
struct notification {
	u32 core_id;
	u32 msg_num;
};
 
static struct mcomm_mpc85xx_data {
	struct fsl_msg_unit **notifications; /* Assumes contiguous PIRs. */
	int nr_notifications;
} mcomm_mpc85xx_data;
 
 
 
static pgprot_t mcomm_mpc85xx_mmap_pgprot(struct vm_area_struct *vma)
{
	return pgprot_cached(vma->vm_page_prot);
}
 
static void __iomem *mcomm_mpc85xx_ioremap(unsigned long phys_addr, size_t size)
{
	return ioremap_prot(phys_addr, size, _PAGE_COHERENT);
}
 
static void mcomm_mpc85xx_notify(u32 core_id)
{
	fsl_send_msg(mcomm_mpc85xx_data.notifications[core_id], MESSAGE_VAL);
}
 
static unsigned long mcomm_mpc85xx_cpuid(void)
{
	return mfspr(SPRN_PIR);
}
 
static void mcomm_mpc85xx_ack(void)
{
	fsl_clear_msg(mcomm_mpc85xx_data.notifications[mcomm_mpc85xx_cpuid()]);
}
 
static struct mcomm_platform_ops mcomm_mpc85xx_ops = {
	.mmap_pgprot = mcomm_mpc85xx_mmap_pgprot,
	.map = mcomm_mpc85xx_ioremap,
	.notify = mcomm_mpc85xx_notify,
	.ack = mcomm_mpc85xx_ack,
	.cpuid = mcomm_mpc85xx_cpuid,
};
 
static void mcomm_mpc85xx_hwuninit(void)
{
	int i;
 
	for (i = 0; i < mcomm_mpc85xx_data.nr_notifications; i++) {
		/* XXX leaves MER enabled? */
		fsl_release_msg_unit(mcomm_mpc85xx_data.notifications[i]);
	}
}
 
static int mcomm_mpc85xx_hwinit(const struct notification notifications[],
                                 int nr_notifications)
{
	struct mcomm_mpc85xx_data *data = &mcomm_mpc85xx_data;
	unsigned int cur_cpu = mcomm_mpc85xx_cpuid();
	struct fsl_msg_unit *self;
	int i;
 
	for (i = 0; i < nr_notifications; i++) {
		u32 core_id = notifications[i].core_id;
		u32 msg_num = notifications[i].msg_num;
		struct fsl_msg_unit *msgunit;
 
		msgunit = fsl_request_msg(msg_num);
		BUG_ON(IS_ERR(msgunit));
		data->notifications[core_id] = msgunit;
	}
 
	self = data->notifications[cur_cpu];
 
	/* Set our MIDR and enable ourselves in in MER. */
	fsl_set_msg_dest(self, cur_cpu);
	fsl_enable_msg(self);
 
	return self->irq;
}
 
static int mcomm_mpc85xx_remove(struct of_device *odev)
{
	struct mcomm_mpc85xx_data *data = &mcomm_mpc85xx_data;
 
	mcomm_remove_region(&odev->dev);
 
	mcomm_mpc85xx_hwuninit();
 
	kfree(data->notifications);
 
	return 0;
}
 
static int mcomm_mpc85xx_probe(struct of_device *odev,
                               const struct of_device_id *match)
{
	struct resource mem;
	struct resource irq;
	struct mcomm_mpc85xx_data *data = &mcomm_mpc85xx_data;
	const u32 *prop;
	int len;
	int rc;
	static int initialized;
 
	if (initialized++)
		return -EEXIST;
 
	rc = of_address_to_resource(odev->node, 0, &mem);
	if (rc < 0) {
		dev_err(&odev->dev, "invalid address\n");
		rc = -EINVAL;
		goto out1;
	}
 
	prop = of_get_property(odev->node, "notifications", &len);
	if (!prop) {
		dev_err(&odev->dev, "no message index\n");
		rc = -EINVAL;
		goto out1;
	}
	data->nr_notifications = len / sizeof(u32) / 2;
	data->notifications =
	            kmalloc(sizeof(data->notifications[0]) * data->nr_notifications,
	            GFP_KERNEL);
	if (!data->notifications) {
		rc = -ENOMEM;
		goto out1;
	}
 
	irq.start = mcomm_mpc85xx_hwinit((struct notification *)prop,
	                                  data->nr_notifications);
 
	rc = mcomm_new_region(&odev->dev, &mem, &irq);
	/* XXX check error path */
	if (rc)
		goto out2;
 
	return 0;
 
out2:
	mcomm_mpc85xx_remove(odev);
out1:
	return rc;
}
 
 
static const struct of_device_id mcomm_match_table[] = {
	{ .compatible	= "ment,mcomm", },
	{}
};
 
static struct of_platform_driver mcomm_of_driver = {
	.name = "mcomm",
	.match_table = mcomm_match_table,
 
	.probe = mcomm_mpc85xx_probe,
	.remove = mcomm_mpc85xx_remove,
};
 
/* Because our node isn't under the localbus or soc nodes, platform code won't
 * automatically create an of_device for it, so we have to do it ourselves. */
static void mcomm_mpc85xx_devices_find(void)
{
	struct device_node *node = NULL;
	int i = 0;
 
	for (node = NULL;
		 (node = of_find_compatible_node(node, NULL, "ment,mcomm")) != NULL;) {
		char bus_id[32];
		sprintf(bus_id, "%s.%d", node->name, i++);
		of_platform_device_create(node, bus_id, NULL);
	}
}
 
static void mcomm_mpc85xx_devices_remove(void)
{
	struct device_node *node = NULL;
 
	for (node = NULL;
		 (node = of_find_compatible_node(node, NULL, "ment,mcomm")) != NULL;) {
		struct of_device *odev = of_find_device_by_node(node);
 
		if (odev)
			of_device_unregister(odev);
	}
}
 
static int __init mcomm_mpc85xx_modinit(void)
{
	int rc;
 
	rc = mcomm_init(&mcomm_mpc85xx_ops, THIS_MODULE);
	if (rc) {
		printk(KERN_ERR "%s: mcomm_init failed\n", __func__);
		goto out1;
	}
 
	rc = of_register_platform_driver(&mcomm_of_driver);
	if (rc) {
		printk(KERN_ERR "%s: failed to register platform driver\n", __func__);
		goto out2;
	}
 
	mcomm_mpc85xx_devices_find();
 
	return 0;
 
out2:
	mcomm_exit();
out1:
	return rc;
}
module_init(mcomm_mpc85xx_modinit);
 
static void mcomm_mpc85xx_modexit(void)
{
	mcomm_mpc85xx_devices_remove();
	mcomm_exit();
	return of_unregister_platform_driver(&mcomm_of_driver);
}
module_exit(mcomm_mpc85xx_modexit);
 
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Hollis Blanchard <hollis_blanchard@mentor.com>");
MODULE_DESCRIPTION("Shared memory platform support for multi-core e500 processors using MPIC");