/* arch/arm/mach-msm/smd_rpcrouter_device.c
 *
 * Copyright (C) 2007 Google, Inc.
 * Copyright (c) 2007-2009 QUALCOMM Incorporated.
 * Author: San Mehat <san@android.com>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/cdev.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/err.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/platform_device.h>
#include <linux/msm_rpcrouter.h>

#include <asm/uaccess.h>
#include <asm/byteorder.h>

#include "smd_rpcrouter.h"

#define SAFETY_MEM_SIZE 65536

/* Next minor # available for a remote server */
static int next_minor = 1;

struct class *msm_rpcrouter_class;
dev_t msm_rpcrouter_devno;

static struct cdev rpcrouter_cdev;
static struct device *rpcrouter_device;

static int rpcrouter_open(struct inode *inode, struct file *filp)
{
        int rc;
        struct msm_rpc_endpoint *ept;

        rc = nonseekable_open(inode, filp);
        if (rc < 0)
                return rc;

        ept = msm_rpcrouter_create_local_endpoint(inode->i_rdev);
        if (!ept)
                return -ENOMEM;

        filp->private_data = ept;
        return 0;
}

static int rpcrouter_release(struct inode *inode, struct file *filp)
{
        struct msm_rpc_endpoint *ept;
        ept = (struct msm_rpc_endpoint *) filp->private_data;

        return msm_rpcrouter_destroy_local_endpoint(ept);
}

static ssize_t rpcrouter_read(struct file *filp, char __user *buf,
                              size_t count, loff_t *ppos)
{
        struct msm_rpc_endpoint *ept;
        struct rr_fragment *frag, *next;
        int rc;

        ept = (struct msm_rpc_endpoint *) filp->private_data;

        rc = __msm_rpc_read(ept, &frag, count, -1);
        if (rc < 0)
                return rc;

        count = rc;

        while (frag != NULL) {
                if (copy_to_user(buf, frag->data, frag->length)) {
                        printk(KERN_ERR
                               "rpcrouter: could not copy all read data to user!\n");
                        rc = -EFAULT;
                }
                buf += frag->length;
                next = frag->next;
                kfree(frag);
                frag = next;
        }

        return rc;
}

static ssize_t rpcrouter_write(struct file *filp, const char __user *buf,
                                size_t count, loff_t *ppos)
{
        struct msm_rpc_endpoint *ept;
        int rc = 0;
        void *k_buffer;

        ept = (struct msm_rpc_endpoint *) filp->private_data;

        /* A check for safety, this seems non-standard */
        if (count > SAFETY_MEM_SIZE)
                return -EINVAL;

        k_buffer = kmalloc(count, GFP_KERNEL);
        if (!k_buffer)
                return -ENOMEM;

        if (copy_from_user(k_buffer, buf, count)) {
                rc = -EFAULT;
                goto write_out_free;
        }

        rc = msm_rpc_write(ept, k_buffer, count);
        if (rc < 0)
                goto write_out_free;

        rc = count;
write_out_free:
        kfree(k_buffer);
        return rc;
}

static unsigned int rpcrouter_poll(struct file *filp,
                                   struct poll_table_struct *wait)
{
        struct msm_rpc_endpoint *ept;
        unsigned mask = 0;
        ept = (struct msm_rpc_endpoint *) filp->private_data;

        /* If there's data already in the read queue, return POLLIN.
         * Else, wait for the requested amount of time, and check again.
         */

        if (!list_empty(&ept->read_q))
                mask |= POLLIN;

        if (!mask) {
                poll_wait(filp, &ept->wait_q, wait);
                if (!list_empty(&ept->read_q))
                        mask |= POLLIN;
        }

        return mask;
}

static long rpcrouter_ioctl(struct file *filp, unsigned int cmd,
                            unsigned long arg)
{
        struct msm_rpc_endpoint *ept;
        struct rpcrouter_ioctl_server_args server_args;
        int rc = 0;
        uint32_t n;

        ept = (struct msm_rpc_endpoint *) filp->private_data;
        switch (cmd) {

        case RPC_ROUTER_IOCTL_GET_VERSION:
                n = RPC_ROUTER_VERSION_V1;
                rc = put_user(n, (unsigned int *) arg);
                break;

        case RPC_ROUTER_IOCTL_GET_MTU:
                /* the pacmark word reduces the actual payload
                 * possible per message
                 */
                n = RPCROUTER_MSGSIZE_MAX - sizeof(uint32_t);
                rc = put_user(n, (unsigned int *) arg);
                break;

        case RPC_ROUTER_IOCTL_REGISTER_SERVER:
                rc = copy_from_user(&server_args, (void *) arg,
                                    sizeof(server_args));
                if (rc < 0)
                        break;
                msm_rpc_register_server(ept,
                                        server_args.prog,
                                        server_args.vers);
                break;

        case RPC_ROUTER_IOCTL_UNREGISTER_SERVER:
                rc = copy_from_user(&server_args, (void *) arg,
                                    sizeof(server_args));
                if (rc < 0)
                        break;

                msm_rpc_unregister_server(ept,
                                          server_args.prog,
                                          server_args.vers);
                break;

        case RPC_ROUTER_IOCTL_GET_MINOR_VERSION:
                n = MSM_RPC_GET_MINOR(msm_rpc_get_vers(ept));
                rc = put_user(n, (unsigned int *)arg);
                break;

        default:
                rc = -EINVAL;
                break;
        }

        return rc;
}

static struct file_operations rpcrouter_server_fops = {
        .owner   = THIS_MODULE,
        .open    = rpcrouter_open,
        .release = rpcrouter_release,
        .read    = rpcrouter_read,
        .write   = rpcrouter_write,
        .poll    = rpcrouter_poll,
        .unlocked_ioctl  = rpcrouter_ioctl,
};

static struct file_operations rpcrouter_router_fops = {
        .owner   = THIS_MODULE,
        .open    = rpcrouter_open,
        .release = rpcrouter_release,
        .read    = rpcrouter_read,
        .write   = rpcrouter_write,
        .poll    = rpcrouter_poll,
        .unlocked_ioctl = rpcrouter_ioctl,
};

int msm_rpcrouter_create_server_cdev(struct rr_server *server)
{
        int rc;
        uint32_t dev_vers;

        if (next_minor == RPCROUTER_MAX_REMOTE_SERVERS) {
                printk(KERN_ERR
                       "rpcrouter: Minor numbers exhausted - Increase "
                       "RPCROUTER_MAX_REMOTE_SERVERS\n");
                return -ENOBUFS;
        }

#if CONFIG_MSM_AMSS_VERSION >= 6350
        /* Servers with bit 31 set are remote msm servers with hashkey version.
         * Servers with bit 31 not set are remote msm servers with
         * backwards compatible version type in which case the minor number
         * (lower 16 bits) is set to zero.
         *
         */
        if ((server->vers & RPC_VERSION_MODE_MASK))
                dev_vers = server->vers;
        else
                dev_vers = server->vers & RPC_VERSION_MAJOR_MASK;
#else
        dev_vers = server->vers;
#endif

        server->device_number =
                MKDEV(MAJOR(msm_rpcrouter_devno), next_minor++);

        server->device =
                device_create(msm_rpcrouter_class, rpcrouter_device,
                              server->device_number, NULL, "%.8x:%.8x",
                              server->prog, dev_vers);
        if (IS_ERR(server->device)) {
                printk(KERN_ERR
                       "rpcrouter: Unable to create device (%ld)\n",
                       PTR_ERR(server->device));
                return PTR_ERR(server->device);;
        }

        cdev_init(&server->cdev, &rpcrouter_server_fops);
        server->cdev.owner = THIS_MODULE;

        rc = cdev_add(&server->cdev, server->device_number, 1);
        if (rc < 0) {
                printk(KERN_ERR
                       "rpcrouter: Unable to add chrdev (%d)\n", rc);
                device_destroy(msm_rpcrouter_class, server->device_number);
                return rc;
        }
        return 0;
}

/* for backward compatible version type (31st bit cleared)
 * clearing minor number (lower 16 bits) in device name
 * is neccessary for driver binding
 */
int msm_rpcrouter_create_server_pdev(struct rr_server *server)
{
        sprintf(server->pdev_name, "rs%.8x:%.8x",
                server->prog,
#if CONFIG_MSM_AMSS_VERSION >= 6350
                (server->vers & RPC_VERSION_MODE_MASK) ? server->vers :
                (server->vers & RPC_VERSION_MAJOR_MASK));
#else
                server->vers);
#endif

        server->p_device.base.id = -1;
        server->p_device.base.name = server->pdev_name;

        server->p_device.prog = server->prog;
        server->p_device.vers = server->vers;

        platform_device_register(&server->p_device.base);
        return 0;
}

int msm_rpcrouter_init_devices(void)
{
        int rc;
        int major;

        /* Create the device nodes */
        msm_rpcrouter_class = class_create(THIS_MODULE, "oncrpc");
        if (IS_ERR(msm_rpcrouter_class)) {
                rc = -ENOMEM;
                printk(KERN_ERR
                       "rpcrouter: failed to create oncrpc class\n");
                goto fail;
        }

        rc = alloc_chrdev_region(&msm_rpcrouter_devno, 0,
                                 RPCROUTER_MAX_REMOTE_SERVERS + 1,
                                 "oncrpc");
        if (rc < 0) {
                printk(KERN_ERR
                       "rpcrouter: Failed to alloc chardev region (%d)\n", rc);
                goto fail_destroy_class;
        }

        major = MAJOR(msm_rpcrouter_devno);
        rpcrouter_device = device_create(msm_rpcrouter_class, NULL,
                                         msm_rpcrouter_devno, NULL, "%.8x:%d",
                                         0, 0);
        if (IS_ERR(rpcrouter_device)) {
                rc = -ENOMEM;
                goto fail_unregister_cdev_region;
        }

        cdev_init(&rpcrouter_cdev, &rpcrouter_router_fops);
        rpcrouter_cdev.owner = THIS_MODULE;

        rc = cdev_add(&rpcrouter_cdev, msm_rpcrouter_devno, 1);
        if (rc < 0)
                goto fail_destroy_device;

        return 0;

fail_destroy_device:
        device_destroy(msm_rpcrouter_class, msm_rpcrouter_devno);
fail_unregister_cdev_region:
        unregister_chrdev_region(msm_rpcrouter_devno,
                                 RPCROUTER_MAX_REMOTE_SERVERS + 1);
fail_destroy_class:
        class_destroy(msm_rpcrouter_class);
fail:
        return rc;
}

void msm_rpcrouter_exit_devices(void)
{
        cdev_del(&rpcrouter_cdev);
        device_destroy(msm_rpcrouter_class, msm_rpcrouter_devno);
        unregister_chrdev_region(msm_rpcrouter_devno,
                                 RPCROUTER_MAX_REMOTE_SERVERS + 1);
        class_destroy(msm_rpcrouter_class);
}