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.

 */

#undef DEBUG

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/module.h>

#include <linux/list.h>

#include <linux/miscdevice.h>

#include <linux/ioport.h>

#include <linux/kdev_t.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/types.h>

#include <linux/platform_device.h>

#include <linux/device.h>

#include <linux/interrupt.h>

#include <linux/io.h>

#include <linux/wait.h>

#include <linux/sched.h>

#include <linux/uaccess.h>

#include <linux/hugetlb.h>

#include <linux/highmem.h>

#include "mcomm.h"

#include "mcomm_compat.h"

struct mcomm_devdata {

        wait_queue_head_t wait; /* All waiting processes sleep here */

        struct cdev cdev;

        struct resource mem;

        void __iomem *mbox_mapped;

        void *platform_data;

        atomic_t refcount;

        unsigned int irq;

        unsigned int nr_mboxes;

        unsigned int mbox_size;

        unsigned int mbox_stride;

};

/* Only supports a single mcomm region. */

static struct mcomm_devdata _mcomm_devdata;

static struct mcomm_platform_ops *mcomm_platform_ops;

/* Wake up the process(es) corresponding to the mailbox(es) which just received

 * packets. */

static irqreturn_t mcomm_interrupt(int irq, void *dev_id)

{

        struct mcomm_devdata *devdata = dev_id;

        void __iomem *mbox;

        int i;

        mbox = devdata->mbox_mapped;

        for (i = 0; i < devdata->nr_mboxes; i++) {

                int active;

                switch (devdata->mbox_size) {

                case 1:

                        active = readb(mbox);

                        break;

                case 4:

                        active = readl(mbox);

                        break;

                default:

                        active = 0;

                }

                if (active) {

                        pr_debug("%s: waking mbox %d\n", __func__, i);

                        wake_up_interruptible(&devdata->wait);

                }

                mbox += devdata->mbox_stride;

        }

        if (irq != NO_IRQ)

                mcomm_platform_ops->ack();

        return IRQ_HANDLED;

}

static int mcomm_mbox_pending(struct mcomm_devdata *devdata,

                              mcomm_mbox_t mbox_id)

{

        unsigned long mbox_offset;

        int active;

        mbox_offset = devdata->mbox_stride * mbox_id;

        switch (devdata->mbox_size) {

        case 1:

                active = readb(devdata->mbox_mapped + mbox_offset);

                break;

        case 4:

                active = readl(devdata->mbox_mapped + mbox_offset);

                break;

        default:

                active = 0;

        }

        if (active)

                pr_debug("mailbox %d (0x%lx) active; value 0x%x\n", mbox_id,

                         mbox_offset, active);

        else

                pr_debug("mailbox %d (0x%lx) not active\n", mbox_id, mbox_offset);

        return active;

}

static long mcomm_fd_ioctl_wait_read(struct mcomm_devdata *devdata,

                                     mcomm_mbox_t mbox_id)

{

        if (devdata->irq == NO_IRQ)

                return 0;

        return wait_event_interruptible(devdata->wait,

                                        mcomm_mbox_pending(devdata, mbox_id));

}

static long mcomm_fd_ioctl_notify(struct mcomm_devdata *devdata,

                                  mcomm_core_t target_core)

{

        /* If the target is the local core, call the interrupt handler directly. */

        if (target_core == mcomm_platform_ops->cpuid())

                mcomm_interrupt(NO_IRQ, devdata);

        else

                mcomm_platform_ops->notify(target_core);

        return 0;

}

static long mcomm_fd_ioctl(struct file *fp, unsigned int ioctl,

                           unsigned long arg)

{

        struct mcomm_devdata *devdata = &_mcomm_devdata;

        void __user *userptr = (void __user *)arg;

        long rc;

        switch (ioctl) {

        case MCOMM_CPUID: {

                u32 cpuid = mcomm_platform_ops->cpuid();

                rc = -EFAULT;

                if (copy_to_user(userptr, &cpuid, sizeof(cpuid)) == 0)

                        rc = 0;

                break;

        }

        case MCOMM_WAIT_READ: {

                mcomm_mbox_t mbox_id;

                rc = -EFAULT;

                if (copy_from_user(&mbox_id, userptr, sizeof(mbox_id)) == 0) {

                        pr_debug("%s: sleeping mbox %d\n", __func__, mbox_id);

                        rc = mcomm_fd_ioctl_wait_read(devdata, mbox_id);

                        pr_debug("%s: mbox %d woke up\n", __func__, mbox_id);

                }

                break;

        }

        case MCOMM_NOTIFY: {

                mcomm_core_t core_id;

                rc = -EFAULT;

                if (copy_from_user(&core_id, userptr, sizeof(core_id)) == 0) {

                        pr_debug("%s: waking core %d\n", __func__, core_id);

                        rc = mcomm_fd_ioctl_notify(devdata, core_id);

                }

                break;

        }

        default:

                rc = -EINVAL;

        }

        return rc;

}

static int __mcomm_follow_pte(struct mm_struct *mm, unsigned long address,

                pte_t **ptepp, spinlock_t **ptlp)

{

        pgd_t *pgd;

        pud_t *pud;

        pmd_t *pmd;

        pte_t *ptep;

        pgd = pgd_offset(mm, address);

        if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd)))

                goto out;

        pud = pud_offset(pgd, address);

        if (pud_none(*pud) || unlikely(pud_bad(*pud)))

                goto out;

        pmd = pmd_offset(pud, address);

        VM_BUG_ON(pmd_trans_huge(*pmd));

        if (pmd_none(*pmd) || unlikely(pmd_bad(*pmd)))

                goto out;

        /* We cannot handle huge page PFN maps. Luckily they don't exist. */

        if (pmd_huge(*pmd))

                goto out;

        ptep = pte_offset_map_lock(mm, pmd, address, ptlp);

        if (!ptep)

                goto out;

        if (!pte_present(*ptep))

                goto unlock;

        *ptepp = ptep;

        return 0;

unlock:

        pte_unmap_unlock(ptep, *ptlp);

out:

        return -EINVAL;

}

static inline int mcomm_follow_pte(struct mm_struct *mm, unsigned long address,

                             pte_t **ptepp, spinlock_t **ptlp)

{

        int res;

        /* (void) is needed to make gcc happy */

        (void) __cond_lock(*ptlp,

                           !(res = __mcomm_follow_pte(mm, address, ptepp, ptlp)));

        return res;

}

#ifdef CONFIG_HAVE_IOREMAP_PROT

static int mcomm_follow_phys(struct vm_area_struct *vma,

                unsigned long address, unsigned int flags,

                unsigned long *prot, resource_size_t *phys)

{

        int ret = -EINVAL;

        pte_t *ptep, pte;

        spinlock_t *ptl;

        if (!(vma->vm_flags & (VM_IO | VM_PFNMAP)))

                goto out;

        if (mcomm_follow_pte(vma->vm_mm, address, &ptep, &ptl))

                goto out;

        pte = *ptep;

        if ((flags & FOLL_WRITE) && !pte_write(pte))

                goto unlock;

        *prot = pgprot_val(pte_pgprot(pte));

        *phys = (resource_size_t)pte_pfn(pte) << PAGE_SHIFT;

        ret = 0;

unlock:

        pte_unmap_unlock(ptep, ptl);

out:

        return ret;

}

static int mcomm_access_phys(struct vm_area_struct *vma, unsigned long addr,

                             void *buf, int len, int write)

{

        resource_size_t phys_addr = 0;

        unsigned long prot = 0;

        void __iomem *maddr;

        int offset = addr & (PAGE_SIZE-1);

        if (mcomm_follow_phys(vma, addr, write, &prot, &phys_addr))

                return -EINVAL;

        maddr = ioremap_prot(phys_addr, PAGE_SIZE, prot);

        if (write)

                memcpy_toio(maddr + offset, buf, len);

        else

                memcpy_fromio(buf, maddr + offset, len);

        iounmap(maddr);

        return len;

}

#endif

static const struct vm_operations_struct mmap_mcomm_ops = {

#ifdef CONFIG_HAVE_IOREMAP_PROT

        .access = mcomm_access_phys

#endif

};

static int mcomm_mmap(struct file *file, struct vm_area_struct *vma)

{

        struct mcomm_devdata *devdata = &_mcomm_devdata;

        unsigned long start_page;

        if ((vma->vm_end - vma->vm_start) > resource_size(&devdata->mem))

                return -ENOMEM;

        vma->vm_page_prot = mcomm_platform_ops->mmap_pgprot(vma);

        vma->vm_ops = &mmap_mcomm_ops;

        start_page = devdata->mem.start >> PAGE_SHIFT;

        return remap_pfn_range(vma, vma->vm_start,

                               start_page + vma->vm_pgoff,

                               vma->vm_end - vma->vm_start,

                               vma->vm_page_prot);

}

static int mcomm_fd_release(struct inode *inode, struct file *fp)

{

        struct mcomm_devdata *devdata = &_mcomm_devdata;

        /* XXX what happens to a thread blocked in ioctl? */

        if (atomic_dec_and_test(&devdata->refcount)) {

                if (devdata->irq != NO_IRQ)

                        free_irq(devdata->irq, devdata);

                iounmap(devdata->mbox_mapped);

        }

        return 0;

}

static struct file_operations mcomm_fd_fops = {

        .release        = mcomm_fd_release,

        .unlocked_ioctl = mcomm_fd_ioctl,

        .compat_ioctl   = mcomm_fd_ioctl,

        .mmap           = mcomm_mmap,

};

static long mcomm_dev_initialize(struct mcomm_devdata *devdata, u32 offset,

                                 mcomm_mbox_t nr_mboxes, u32 mbox_size,

                                 u32 mbox_stride)

{

        resource_size_t mbox_paddr;

        long rc;

        if (offset + nr_mboxes * mbox_stride >= resource_size(&devdata->mem)) {

                printk(KERN_ERR "%s: mailboxes exceed memory area.\n", __func__);

                rc = -E2BIG;

                goto out1;

        }

        switch (mbox_size) {

        case 1:

        case 4:

                break;

        default:

                printk(KERN_ERR "%s: unsupported mailbox size %d\n", __func__,

                       mbox_size);

                rc = -EINVAL;

                goto out1;

        }

        /* Map only the memory encompassing the mailboxes. */

        mbox_paddr = devdata->mem.start + offset;

        devdata->mbox_mapped = mcomm_platform_ops->map(mbox_paddr,

                                                       nr_mboxes * mbox_stride);

        if (devdata->mbox_mapped == NULL) {

                printk(KERN_ERR "%s: failed to map the mailboxes.\n", __func__);

                rc = -EFAULT;

                goto out1;

        }

        devdata->mbox_size = mbox_size;

        devdata->mbox_stride = mbox_stride;

        devdata->nr_mboxes = nr_mboxes;

        if (devdata->irq != NO_IRQ) {

                rc = request_irq(devdata->irq, mcomm_interrupt, 0, "mcomm",

                                                 devdata);

                if (rc) {

                        printk(KERN_ERR "%s: failed to reserve irq %d\n", __func__,

                                   devdata->irq);

                        goto out2;

                }

        }

        return 0;

out2:

        iounmap(devdata->mbox_mapped);

out1:

        return rc;

}

static long mcomm_dev_ioctl_init(struct mcomm_devdata *devdata, u32 offset,

                                 mcomm_mbox_t nr_mboxes, u32 mbox_size,

                                 u32 mbox_stride)

{

        long rc;

        if (atomic_inc_return(&devdata->refcount) > 1) {

                if ( (nr_mboxes != devdata->nr_mboxes) ||

                     (mbox_size != devdata->mbox_size) ||

                     (mbox_stride != devdata->mbox_stride)) {

                        printk(KERN_ERR "%s: new configuration doesn't match old configuration.\n", __func__);

                        rc = -EBUSY;

                        goto out1;

                }

        } else {

                rc = mcomm_dev_initialize(devdata, offset, nr_mboxes, mbox_size,

                                          mbox_stride);

                if (rc)

                        goto out1;

        }

        return mcomm_anon_inode_getfd("mcomm", &mcomm_fd_fops, devdata, O_RDWR);

out1:

        atomic_dec(&devdata->refcount);

        return rc;

}

static long mcomm_dev_ioctl(struct file *fp, unsigned int ioctl,

                            unsigned long arg)

{

        struct mcomm_devdata *devdata = &_mcomm_devdata;

        void __user *userptr = (void __user *)arg;

        long rc;

        switch (ioctl) {

        case MCOMM_INIT: {

                struct mcomm_init_device args;

                rc = -EFAULT;

                if (copy_from_user(&args, userptr, sizeof(args)) == 0)

                        rc = mcomm_dev_ioctl_init(devdata, args.offset, args.nr_mboxes,

                                                  args.mbox_size, args.mbox_stride);

                break;

        }

        default:

                rc = -EINVAL;

        }

        return rc;

}

static int mcomm_dev_open(struct inode *inode, struct file *fp)

{

        return 0;

}

static struct file_operations mcomm_dev_fops = {

        .open           = mcomm_dev_open,

        .unlocked_ioctl = mcomm_dev_ioctl,

        .compat_ioctl   = mcomm_dev_ioctl,

        .mmap           = mcomm_mmap,

};

static ssize_t mcomm_show_region_addr(struct device *dev,

                                      struct device_attribute *attr,

                                      char *buf)

{

        struct mcomm_devdata *devdata = &_mcomm_devdata;

        return sprintf(buf, "0x%llx\n", (unsigned long long)devdata->mem.start);

}

static DEVICE_ATTR(address, 0444, mcomm_show_region_addr, NULL);

static ssize_t mcomm_show_region_size(struct device *dev,

                                      struct device_attribute *attr,

                                      char *buf)

{

        struct mcomm_devdata *devdata = &_mcomm_devdata;

        return sprintf(buf, "0x%llx\n",

                       (unsigned long long)resource_size(&devdata->mem));

}

static DEVICE_ATTR(size, 0444, mcomm_show_region_size, NULL);

static struct attribute *mcomm_attributes[] = {

        &dev_attr_size.attr,

        &dev_attr_address.attr,

        NULL

};

static struct attribute_group mcomm_attr_group = {

        .attrs = mcomm_attributes,

};

struct miscdevice mcomm_misc_dev = {

        .fops = &mcomm_dev_fops,

        .minor = MISC_DYNAMIC_MINOR,

        .name = "mcomm0",

};

int mcomm_new_region(struct device *dev, struct resource *mem,

                     struct resource *irq)

{

        struct mcomm_devdata *devdata = &_mcomm_devdata;

        int rc;

        static int initialized;

        if (initialized++)

                return -EEXIST;

        init_waitqueue_head(&devdata->wait);

        devdata->mem = *mem;

        devdata->irq = irq->start;

        rc = sysfs_create_group(&dev->kobj, &mcomm_attr_group);

        if (rc) {

                printk(KERN_WARNING "%s: Failed to register sysfs attributes.\n",

                       __func__);

                goto out1;

        }

        rc = misc_register(&mcomm_misc_dev);

        if (rc) {

                printk("%s misc_register error %d\n", __func__, rc);

                goto out2;

        }

        return 0;

out2:

        sysfs_remove_group(&dev->kobj, &mcomm_attr_group);

out1:

        return rc;

}

EXPORT_SYMBOL(mcomm_new_region);

void mcomm_remove_region(struct device *dev)

{

        misc_deregister(&mcomm_misc_dev);

        sysfs_remove_group(&dev->kobj, &mcomm_attr_group);

}

EXPORT_SYMBOL(mcomm_remove_region);

int mcomm_init(struct mcomm_platform_ops *ops, struct module *module)

{

        int rc;

        rc = mcomm_init_anon_inodes();

        if (rc)

                goto out1;

        mcomm_platform_ops = ops;

        mcomm_dev_fops.owner = module;

        mcomm_fd_fops.owner = module;

        return 0;

out1:

        return rc;

}

EXPORT_SYMBOL(mcomm_init);

void mcomm_exit(void)

{

        mcomm_exit_anon_inodes();

}

EXPORT_SYMBOL(mcomm_exit);

MODULE_LICENSE("GPL v2");

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

MODULE_DESCRIPTION("Shared memory communications channel");