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.

 */

/*

 * This file exists only to provide a driver for testing userspace code on

 * single-core platforms.

 *

 * The interrupt functions won't even be called. Instead of calling

 * ops->notify() for the single core, the higher level code directly calls its

 * interrupt handler instead.

 */

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/io.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include "mcomm.h"

#include "mcomm_dev.h"

static pgprot_t mcomm_loop_mmap_pgprot(struct vm_area_struct *vma)

{

        return vma->vm_page_prot;

}

static void __iomem *mcomm_loop_ioremap(unsigned long phys_addr, size_t size)

{

#if defined(CONFIG_ARM)

        return ioremap_cached(phys_addr, size);

#elif defined(CONFIG_X86)

        return ioremap_cache(phys_addr, size);

#endif

        return ioremap(phys_addr, size);

}

static void mcomm_loop_notify(u32 core_nr)

{

        BUG();

}

static void mcomm_loop_ack(void)

{

        BUG();

}

static unsigned long mcomm_loop_cpuid(void)

{

        return 0;

}

static struct mcomm_platform_ops mcomm_loop_ops = {

        .mmap_pgprot = mcomm_loop_mmap_pgprot,

        .map = mcomm_loop_ioremap,

        .notify = mcomm_loop_notify,

        .ack = mcomm_loop_ack,

        .cpuid = mcomm_loop_cpuid,

};

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;

        return mcomm_new_region(&pdev->dev, mem, irq);

}

static int mcomm_remove(struct platform_device *pdev)

{

        mcomm_remove_region(&pdev->dev);

        return 0;

}

static struct platform_driver mcomm_driver = {

        .probe = mcomm_probe,

        .remove = mcomm_remove,

        .driver = {

                   .name = "mcomm",

        }

};

static int __init mcomm_loop_modinit(void)

{

        int rc;

        rc = mcomm_init(&mcomm_loop_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 out2;

        return 0;

out2:

        mcomm_exit();

out1:

        return rc;

}

module_init(mcomm_loop_modinit);

static void mcomm_loop_modexit(void)

{

        mcomm_pdev_release();

        platform_driver_unregister(&mcomm_driver);

        mcomm_exit();

}

module_exit(mcomm_loop_modexit);

MODULE_LICENSE("GPL v2");

MODULE_AUTHOR("Hollis Blanchard <hollis_blanchard@mentor.com>");

MODULE_DESCRIPTION("Loopback driver for testing multi-core communications driver");