path: root/arch/arm/mach-msm/smd_rpcrouter_device.c

/* arch/arm/mach-msm/smd_rpcrouter_device.c
 *
 * Copyright (C) 2007 Google, Inc.
 * Copyright (c) 2007-2011, The Linux Foundation. All rights reserved.
 * 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/slab.h>
#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 <mach/peripheral-loader.h>
#include "smd_rpcrouter.h"

/* Support 64KB of data plus some space for headers */
#define SAFETY_MEM_SIZE (65536 + sizeof(struct rpc_request_hdr))

/* modem load timeout */
#define MODEM_LOAD_TIMEOUT (10 * HZ)

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

struct class *msm_rpcrouter_class;
dev_t msm_rpcrouter_devno;

static struct cdev rpcrouter_cdev;
static struct device *rpcrouter_device;

struct rpcrouter_file_info {
	struct msm_rpc_endpoint *ept;
	void *modem_pil;
};

static void msm_rpcrouter_unload_modem(void *pil)
{
	if (pil)
		pil_put(pil);
}

static void *msm_rpcrouter_load_modem(void)
{
	void *pil;
	int rc;

	pil = pil_get("modem");
	if (IS_ERR(pil))
		pr_err("%s: modem load failed\n", __func__);
	else {
		rc = wait_for_completion_interruptible_timeout(
						&rpc_remote_router_up,
						MODEM_LOAD_TIMEOUT);
		if (!rc)
			rc = -ETIMEDOUT;
		if (rc < 0) {
			pr_err("%s: wait for remote router failed %d\n",
			       __func__, rc);
			msm_rpcrouter_unload_modem(pil);
			pil = ERR_PTR(rc);
		}
	}

	return pil;
}

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

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

	file_info = kzalloc(sizeof(*file_info), GFP_KERNEL);
	if (!file_info)
		return -ENOMEM;

	ept = msm_rpcrouter_create_local_endpoint(inode->i_rdev);
	if (!ept) {
		kfree(file_info);
		return -ENOMEM;
	}
	file_info->ept = ept;

	/* if router device, load the modem */
	if (inode->i_rdev == msm_rpcrouter_devno) {
		pil = msm_rpcrouter_load_modem();
		if (IS_ERR(pil)) {
			kfree(file_info);
			msm_rpcrouter_destroy_local_endpoint(ept);
			return PTR_ERR(pil);
		}
		file_info->modem_pil = pil;
	}

	filp->private_data = file_info;
	return 0;
}

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

	ept = (struct msm_rpc_endpoint *) file_info->ept;

	/* A user program with many files open when ends abruptly,
	 * will cause a flood of REMOVE_CLIENT messages to the
	 * remote processor.  This will cause remote processors
	 * internal queue to overflow. Inserting a sleep here
	 * regularly is the effecient option.
	 */
	if (rpcrouter_release_cnt++ % 2)
		msleep(1);

	/* if router device, unload the modem */
	if (inode->i_rdev == msm_rpcrouter_devno)
		msm_rpcrouter_unload_modem(file_info->modem_pil);

	kfree(file_info);
	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 rpcrouter_file_info *file_info = filp->private_data;
	struct msm_rpc_endpoint *ept;
	struct rr_fragment *frag, *next;
	int rc;

	ept = (struct msm_rpc_endpoint *) file_info->ept;

	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 rpcrouter_file_info *file_info = filp->private_data;
	struct msm_rpc_endpoint	*ept;
	int rc = 0;
	void *k_buffer;

	ept = (struct msm_rpc_endpoint *) file_info->ept;

	/* 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;
}

/* RPC VFS Poll Implementation
 *
 * POLLRDHUP - restart in progress
 * POLLOUT - writes accepted (without blocking)
 * POLLIN - data ready to read
 *
 * The restart state consists of several different phases including a client
 * notification and a server restart.  If the server has been restarted, then
 * reads and writes can be performed and the POLLOUT bit will be set.  If a
 * restart is in progress, but the server hasn't been restarted, then only the
 * POLLRDHUP is active and reads and writes will block.  See the table
 * below for a summary.  POLLRDHUP is cleared once a call to msm_rpc_write_pkt
 * or msm_rpc_read_pkt returns ENETRESET.
 *
 * POLLOUT	POLLRDHUP
 *    1         0       Normal operation
 *    0         1       Restart in progress and server hasn't restarted yet
 *    1         1       Server has been restarted, but client has
 *                      not been notified of a restart by a return code
 *                      of ENETRESET from msm_rpc_write_pkt or
 *                      msm_rpc_read_pkt.
 */
static unsigned int rpcrouter_poll(struct file *filp,
				   struct poll_table_struct *wait)
{
	struct rpcrouter_file_info *file_info = filp->private_data;
	struct msm_rpc_endpoint *ept;
	unsigned mask = 0;

	ept = (struct msm_rpc_endpoint *) file_info->ept;

	poll_wait(filp, &ept->wait_q, wait);
	poll_wait(filp, &ept->restart_wait, wait);

	if (!list_empty(&ept->read_q))
		mask |= POLLIN;
	if (!(ept->restart_state & RESTART_PEND_SVR))
		mask |= POLLOUT;
	if (ept->restart_state != 0)
		mask |= POLLRDHUP;

	return mask;
}

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

	ept = (struct msm_rpc_endpoint *) file_info->ept;
	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_CLEAR_NETRESET:
		msm_rpc_clear_netreset(ept);
		break;

	case RPC_ROUTER_IOCTL_GET_CURR_PKT_SIZE:
		rc = msm_rpc_get_curr_pkt_size(ept);
		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;
	unsigned long flags;

	spin_lock_irqsave(&server_cdev_lock, flags);
	if (next_minor == RPCROUTER_MAX_REMOTE_SERVERS) {
		spin_unlock_irqrestore(&server_cdev_lock, flags);
		printk(KERN_ERR
		       "rpcrouter: Minor numbers exhausted - Increase "
		       "RPCROUTER_MAX_REMOTE_SERVERS\n");
		return -ENOBUFS;
	}

	/* 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 & 0x80000000))
		dev_vers = server->vers;
	else
		dev_vers = server->vers & 0xffff0000;

	server->device_number =
		MKDEV(MAJOR(msm_rpcrouter_devno), next_minor++);
	spin_unlock_irqrestore(&server_cdev_lock, flags);

	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)
{
	server->p_device.base.id = (server->vers & RPC_VERSION_MODE_MASK) ?
				   server->vers :
				   (server->vers & RPC_VERSION_MAJOR_MASK);
	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);
}