[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / ozwpan / ozcdev.c

/* -----------------------------------------------------------------------------
 * Copyright (c) 2011 Ozmo Inc
 * Released under the GNU General Public License Version 2 (GPLv2).
 * -----------------------------------------------------------------------------
 */
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include "ozconfig.h"
#include "ozprotocol.h"
#include "oztrace.h"
#include "ozappif.h"
#include "ozeltbuf.h"
#include "ozpd.h"
#include "ozproto.h"
#include "ozevent.h"
/*------------------------------------------------------------------------------
 */
#define OZ_RD_BUF_SZ	256
struct oz_cdev {
	dev_t devnum;
	struct cdev cdev;
	wait_queue_head_t rdq;
	spinlock_t lock;
	u8 active_addr[ETH_ALEN];
	struct oz_pd *active_pd;
};

/* Per PD context for the serial service stored in the PD. */
struct oz_serial_ctx {
	atomic_t ref_count;
	u8 tx_seq_num;
	u8 rx_seq_num;
	u8 rd_buf[OZ_RD_BUF_SZ];
	int rd_in;
	int rd_out;
};
/*------------------------------------------------------------------------------
 */
static struct oz_cdev g_cdev;
struct class *g_oz_class;
/*------------------------------------------------------------------------------
 * Context: process and softirq
 */
static struct oz_serial_ctx *oz_cdev_claim_ctx(struct oz_pd *pd)
{
	struct oz_serial_ctx *ctx;
	spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
	if (ctx)
		atomic_inc(&ctx->ref_count);
	spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	return ctx;
}
/*------------------------------------------------------------------------------
 * Context: softirq or process
 */
static void oz_cdev_release_ctx(struct oz_serial_ctx *ctx)
{
	if (atomic_dec_and_test(&ctx->ref_count)) {
		oz_trace("Dealloc serial context.\n");
		kfree(ctx);
	}
}
/*------------------------------------------------------------------------------
 * Context: process
 */
int oz_cdev_open(struct inode *inode, struct file *filp)
{
	struct oz_cdev *dev;
	oz_trace("oz_cdev_open()\n");
	oz_trace("major = %d minor = %d\n", imajor(inode), iminor(inode));
	dev = container_of(inode->i_cdev, struct oz_cdev, cdev);
	filp->private_data = dev;
	return 0;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
int oz_cdev_release(struct inode *inode, struct file *filp)
{
	oz_trace("oz_cdev_release()\n");
	return 0;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
ssize_t oz_cdev_read(struct file *filp, char __user *buf, size_t count,
		loff_t *fpos)
{
	int n;
	int ix;

	struct oz_pd *pd;
	struct oz_serial_ctx *ctx = 0;

	spin_lock_bh(&g_cdev.lock);
	pd = g_cdev.active_pd;
	if (pd)
		oz_pd_get(pd);
	spin_unlock_bh(&g_cdev.lock);
	if (pd == NULL)
		return -1;
	ctx = oz_cdev_claim_ctx(pd);
	if (ctx == NULL)
		goto out2;
	n = ctx->rd_in - ctx->rd_out;
	if (n < 0)
		n += OZ_RD_BUF_SZ;
	if (count > n)
		count = n;
	ix = ctx->rd_out;
	n = OZ_RD_BUF_SZ - ix;
	if (n > count)
		n = count;
	if (copy_to_user(buf, &ctx->rd_buf[ix], n)) {
		count = 0;
		goto out1;
	}
	ix += n;
	if (ix == OZ_RD_BUF_SZ)
		ix = 0;
	if (n < count) {
		if (copy_to_user(&buf[n], ctx->rd_buf, count-n)) {
			count = 0;
			goto out1;
		}
		ix = count-n;
	}
	ctx->rd_out = ix;
out1:
	oz_cdev_release_ctx(ctx);
out2:
	oz_pd_put(pd);
	return count;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
ssize_t oz_cdev_write(struct file *filp, const char __user *buf, size_t count,
		loff_t *fpos)
{
	struct oz_pd *pd;
	struct oz_elt_buf *eb;
	struct oz_elt_info *ei = 0;
	struct oz_elt *elt;
	struct oz_app_hdr *app_hdr;
	struct oz_serial_ctx *ctx;

	spin_lock_bh(&g_cdev.lock);
	pd = g_cdev.active_pd;
	if (pd)
		oz_pd_get(pd);
	spin_unlock_bh(&g_cdev.lock);
	if (pd == NULL)
		return -1;
	eb = &pd->elt_buff;
	ei = oz_elt_info_alloc(eb);
	if (ei == NULL) {
		count = 0;
		goto out;
	}
	elt = (struct oz_elt *)ei->data;
	app_hdr = (struct oz_app_hdr *)(elt+1);
	elt->length = sizeof(struct oz_app_hdr) + count;
	elt->type = OZ_ELT_APP_DATA;
	ei->app_id = OZ_APPID_SERIAL;
	ei->length = elt->length + sizeof(struct oz_elt);
	app_hdr->app_id = OZ_APPID_SERIAL;
	if (copy_from_user(app_hdr+1, buf, count))
		goto out;
	spin_lock_bh(&pd->app_lock[OZ_APPID_USB-1]);
	ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
	if (ctx) {
		app_hdr->elt_seq_num = ctx->tx_seq_num++;
		if (ctx->tx_seq_num == 0)
			ctx->tx_seq_num = 1;
		spin_lock(&eb->lock);
		if (oz_queue_elt_info(eb, 0, 0, ei) == 0)
			ei = 0;
		spin_unlock(&eb->lock);
	}
	spin_unlock_bh(&pd->app_lock[OZ_APPID_USB-1]);
out:
	if (ei) {
		count = 0;
		spin_lock_bh(&eb->lock);
		oz_elt_info_free(eb, ei);
		spin_unlock_bh(&eb->lock);
	}
	oz_pd_put(pd);
	return count;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
static int oz_set_active_pd(u8 *addr)
{
	int rc = 0;
	struct oz_pd *pd;
	struct oz_pd *old_pd;
	pd = oz_pd_find(addr);
	if (pd) {
		spin_lock_bh(&g_cdev.lock);
		memcpy(g_cdev.active_addr, addr, ETH_ALEN);
		old_pd = g_cdev.active_pd;
		g_cdev.active_pd = pd;
		spin_unlock_bh(&g_cdev.lock);
		if (old_pd)
			oz_pd_put(old_pd);
	} else {
		if (is_zero_ether_addr(addr)) {
			spin_lock_bh(&g_cdev.lock);
			pd = g_cdev.active_pd;
			g_cdev.active_pd = 0;
			memset(g_cdev.active_addr, 0,
				sizeof(g_cdev.active_addr));
			spin_unlock_bh(&g_cdev.lock);
			if (pd)
				oz_pd_put(pd);
		} else {
			rc = -1;
		}
	}
	return rc;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
long oz_cdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	int rc = 0;
	if (_IOC_TYPE(cmd) != OZ_IOCTL_MAGIC)
		return -ENOTTY;
	if (_IOC_NR(cmd) > OZ_IOCTL_MAX)
		return -ENOTTY;
	if (_IOC_DIR(cmd) & _IOC_READ)
		rc = !access_ok(VERIFY_WRITE, (void __user *)arg,
			_IOC_SIZE(cmd));
	else if (_IOC_DIR(cmd) & _IOC_WRITE)
		rc = !access_ok(VERIFY_READ, (void __user *)arg,
			_IOC_SIZE(cmd));
	if (rc)
		return -EFAULT;
	switch (cmd) {
	case OZ_IOCTL_GET_PD_LIST: {
			struct oz_pd_list list;
			oz_trace("OZ_IOCTL_GET_PD_LIST\n");
			list.count = oz_get_pd_list(list.addr, OZ_MAX_PDS);
			if (copy_to_user((void __user *)arg, &list,
				sizeof(list)))
				return -EFAULT;
		}
		break;
	case OZ_IOCTL_SET_ACTIVE_PD: {
			u8 addr[ETH_ALEN];
			oz_trace("OZ_IOCTL_SET_ACTIVE_PD\n");
			if (copy_from_user(addr, (void __user *)arg, ETH_ALEN))
				return -EFAULT;
			rc = oz_set_active_pd(addr);
		}
		break;
	case OZ_IOCTL_GET_ACTIVE_PD: {
			u8 addr[ETH_ALEN];
			oz_trace("OZ_IOCTL_GET_ACTIVE_PD\n");
			spin_lock_bh(&g_cdev.lock);
			memcpy(addr, g_cdev.active_addr, ETH_ALEN);
			spin_unlock_bh(&g_cdev.lock);
			if (copy_to_user((void __user *)arg, addr, ETH_ALEN))
				return -EFAULT;
		}
		break;
	case OZ_IOCTL_ADD_BINDING:
	case OZ_IOCTL_REMOVE_BINDING: {
			struct oz_binding_info b;
			if (copy_from_user(&b, (void __user *)arg,
				sizeof(struct oz_binding_info))) {
				return -EFAULT;
			}
			/* Make sure name is null terminated. */
			b.name[OZ_MAX_BINDING_LEN-1] = 0;
			if (cmd == OZ_IOCTL_ADD_BINDING)
				oz_binding_add(b.name);
			else
				oz_binding_remove(b.name);
		}
		break;
	}
	return rc;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
unsigned int oz_cdev_poll(struct file *filp, poll_table *wait)
{
	unsigned int ret = 0;
	struct oz_cdev *dev = filp->private_data;
	oz_trace("Poll called wait = %p\n", wait);
	spin_lock_bh(&dev->lock);
	if (dev->active_pd) {
		struct oz_serial_ctx *ctx = oz_cdev_claim_ctx(dev->active_pd);
		if (ctx) {
			if (ctx->rd_in != ctx->rd_out)
				ret |= POLLIN | POLLRDNORM;
			oz_cdev_release_ctx(ctx);
		}
	}
	spin_unlock_bh(&dev->lock);
	if (wait)
		poll_wait(filp, &dev->rdq, wait);
	return ret;
}
/*------------------------------------------------------------------------------
 */
const struct file_operations oz_fops = {
	.owner =	THIS_MODULE,
	.open =		oz_cdev_open,
	.release =	oz_cdev_release,
	.read =		oz_cdev_read,
	.write =	oz_cdev_write,
	.unlocked_ioctl = oz_cdev_ioctl,
	.poll =		oz_cdev_poll
};
/*------------------------------------------------------------------------------
 * Context: process
 */
int oz_cdev_register(void)
{
	int err;
	struct device *dev;
	memset(&g_cdev, 0, sizeof(g_cdev));
	err = alloc_chrdev_region(&g_cdev.devnum, 0, 1, "ozwpan");
	if (err < 0)
		goto out3;
	oz_trace("Alloc dev number %d:%d\n", MAJOR(g_cdev.devnum),
			MINOR(g_cdev.devnum));
	cdev_init(&g_cdev.cdev, &oz_fops);
	g_cdev.cdev.owner = THIS_MODULE;
	g_cdev.cdev.ops = &oz_fops;
	spin_lock_init(&g_cdev.lock);
	init_waitqueue_head(&g_cdev.rdq);
	err = cdev_add(&g_cdev.cdev, g_cdev.devnum, 1);
	if (err < 0) {
		oz_trace("Failed to add cdev\n");
		goto out2;
	}
	g_oz_class = class_create(THIS_MODULE, "ozmo_wpan");
	if (IS_ERR(g_oz_class)) {
		oz_trace("Failed to register ozmo_wpan class\n");
		goto out1;
	}
	dev = device_create(g_oz_class, NULL, g_cdev.devnum, NULL, "ozwpan");
	if (IS_ERR(dev)) {
		oz_trace("Failed to create sysfs entry for cdev\n");
		goto out1;
	}
	return 0;
out1:
	cdev_del(&g_cdev.cdev);
out2:
	unregister_chrdev_region(g_cdev.devnum, 1);
out3:
	return err;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
int oz_cdev_deregister(void)
{
	cdev_del(&g_cdev.cdev);
	unregister_chrdev_region(g_cdev.devnum, 1);
	if (g_oz_class) {
		device_destroy(g_oz_class, g_cdev.devnum);
		class_destroy(g_oz_class);
	}
	return 0;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
int oz_cdev_init(void)
{
	oz_event_log(OZ_EVT_SERVICE, 1, OZ_APPID_SERIAL, 0, 0);
	oz_app_enable(OZ_APPID_SERIAL, 1);
	return 0;
}
/*------------------------------------------------------------------------------
 * Context: process
 */
void oz_cdev_term(void)
{
	oz_event_log(OZ_EVT_SERVICE, 2, OZ_APPID_SERIAL, 0, 0);
	oz_app_enable(OZ_APPID_SERIAL, 0);
}
/*------------------------------------------------------------------------------
 * Context: softirq-serialized
 */
int oz_cdev_start(struct oz_pd *pd, int resume)
{
	struct oz_serial_ctx *ctx;
	struct oz_serial_ctx *old_ctx = 0;
	oz_event_log(OZ_EVT_SERVICE, 3, OZ_APPID_SERIAL, 0, resume);
	if (resume) {
		oz_trace("Serial service resumed.\n");
		return 0;
	}
	ctx = kzalloc(sizeof(struct oz_serial_ctx), GFP_ATOMIC);
	if (ctx == NULL)
		return -ENOMEM;
	atomic_set(&ctx->ref_count, 1);
	ctx->tx_seq_num = 1;
	spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	old_ctx = pd->app_ctx[OZ_APPID_SERIAL-1];
	if (old_ctx) {
		spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
		kfree(ctx);
	} else {
		pd->app_ctx[OZ_APPID_SERIAL-1] = ctx;
		spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	}
	spin_lock(&g_cdev.lock);
	if ((g_cdev.active_pd == NULL) &&
		(memcmp(pd->mac_addr, g_cdev.active_addr, ETH_ALEN) == 0)) {
		oz_pd_get(pd);
		g_cdev.active_pd = pd;
		oz_trace("Active PD arrived.\n");
	}
	spin_unlock(&g_cdev.lock);
	oz_trace("Serial service started.\n");
	return 0;
}
/*------------------------------------------------------------------------------
 * Context: softirq or process
 */
void oz_cdev_stop(struct oz_pd *pd, int pause)
{
	struct oz_serial_ctx *ctx;
	oz_event_log(OZ_EVT_SERVICE, 4, OZ_APPID_SERIAL, 0, pause);
	if (pause) {
		oz_trace("Serial service paused.\n");
		return;
	}
	spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
	pd->app_ctx[OZ_APPID_SERIAL-1] = 0;
	spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	if (ctx)
		oz_cdev_release_ctx(ctx);
	spin_lock(&g_cdev.lock);
	if (pd == g_cdev.active_pd)
		g_cdev.active_pd = 0;
	else
		pd = 0;
	spin_unlock(&g_cdev.lock);
	if (pd) {
		oz_pd_put(pd);
		oz_trace("Active PD departed.\n");
	}
	oz_trace("Serial service stopped.\n");
}
/*------------------------------------------------------------------------------
 * Context: softirq-serialized
 */
void oz_cdev_rx(struct oz_pd *pd, struct oz_elt *elt)
{
	struct oz_serial_ctx *ctx;
	struct oz_app_hdr *app_hdr;
	u8 *data;
	int len;
	int space;
	int copy_sz;
	int ix;

	ctx = oz_cdev_claim_ctx(pd);
	if (ctx == NULL) {
		oz_trace("Cannot claim serial context.\n");
		return;
	}

	app_hdr = (struct oz_app_hdr *)(elt+1);
	/* If sequence number is non-zero then check it is not a duplicate.
	 */
	if (app_hdr->elt_seq_num != 0) {
		if (((ctx->rx_seq_num - app_hdr->elt_seq_num) & 0x80) == 0) {
			/* Reject duplicate element. */
			oz_trace("Duplicate element:%02x %02x\n",
				app_hdr->elt_seq_num, ctx->rx_seq_num);
			goto out;
		}
	}
	ctx->rx_seq_num = app_hdr->elt_seq_num;
	len = elt->length - sizeof(struct oz_app_hdr);
	data = ((u8 *)(elt+1)) + sizeof(struct oz_app_hdr);
	if (len <= 0)
		goto out;
	space = ctx->rd_out - ctx->rd_in - 1;
	if (space < 0)
		space += OZ_RD_BUF_SZ;
	if (len > space) {
		oz_trace("Not enough space:%d %d\n", len, space);
		len = space;
	}
	ix = ctx->rd_in;
	copy_sz = OZ_RD_BUF_SZ - ix;
	if (copy_sz > len)
		copy_sz = len;
	memcpy(&ctx->rd_buf[ix], data, copy_sz);
	len -= copy_sz;
	ix += copy_sz;
	if (ix == OZ_RD_BUF_SZ)
		ix = 0;
	if (len) {
		memcpy(ctx->rd_buf, data+copy_sz, len);
		ix = len;
	}
	ctx->rd_in = ix;
	wake_up(&g_cdev.rdq);
out:
	oz_cdev_release_ctx(ctx);
}
/*------------------------------------------------------------------------------
 * Context: softirq
 */
void oz_cdev_heartbeat(struct oz_pd *pd)
{
}
Commit	Line	Data
23af8c2a CK	1	/* -----------------------------------------------------------------------------
	2	* Copyright (c) 2011 Ozmo Inc
	3	* Released under the GNU General Public License Version 2 (GPLv2).
	4	* -----------------------------------------------------------------------------
	5	*/
	6	#include <linux/module.h>
	7	#include <linux/fs.h>
	8	#include <linux/cdev.h>
	9	#include <linux/uaccess.h>
	10	#include <linux/netdevice.h>
07732be2	11	#include <linux/etherdevice.h>
23af8c2a CK	12	#include <linux/poll.h>
	13	#include <linux/sched.h>
	14	#include "ozconfig.h"
	15	#include "ozprotocol.h"
	16	#include "oztrace.h"
	17	#include "ozappif.h"
	18	#include "ozeltbuf.h"
	19	#include "ozpd.h"
	20	#include "ozproto.h"
23af8c2a CK	21	#include "ozevent.h"
	22	/*------------------------------------------------------------------------------
	23	*/
	24	#define OZ_RD_BUF_SZ 256
	25	struct oz_cdev {
	26	dev_t devnum;
	27	struct cdev cdev;
	28	wait_queue_head_t rdq;
	29	spinlock_t lock;
	30	u8 active_addr[ETH_ALEN];
	31	struct oz_pd *active_pd;
	32	};
	33
	34	/* Per PD context for the serial service stored in the PD. */
	35	struct oz_serial_ctx {
	36	atomic_t ref_count;
	37	u8 tx_seq_num;
	38	u8 rx_seq_num;
	39	u8 rd_buf[OZ_RD_BUF_SZ];
	40	int rd_in;
	41	int rd_out;
	42	};
23af8c2a CK	43	/*------------------------------------------------------------------------------
	44	*/
	45	static struct oz_cdev g_cdev;
ba0a7ae7	46	struct class *g_oz_class;
23af8c2a CK	47	/*------------------------------------------------------------------------------
	48	* Context: process and softirq
	49	*/
	50	static struct oz_serial_ctx oz_cdev_claim_ctx(struct oz_pd pd)
	51	{
	52	struct oz_serial_ctx *ctx;
	53	spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	54	ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
	55	if (ctx)
	56	atomic_inc(&ctx->ref_count);
	57	spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	58	return ctx;
	59	}
	60	/*------------------------------------------------------------------------------
	61	* Context: softirq or process
	62	*/
	63	static void oz_cdev_release_ctx(struct oz_serial_ctx *ctx)
	64	{
	65	if (atomic_dec_and_test(&ctx->ref_count)) {
	66	oz_trace("Dealloc serial context.\n");
1ec41a31	67	kfree(ctx);
23af8c2a CK	68	}
	69	}
	70	/*------------------------------------------------------------------------------
	71	* Context: process
	72	*/
	73	int oz_cdev_open(struct inode inode, struct file filp)
	74	{
	75	struct oz_cdev *dev;
	76	oz_trace("oz_cdev_open()\n");
	77	oz_trace("major = %d minor = %d\n", imajor(inode), iminor(inode));
	78	dev = container_of(inode->i_cdev, struct oz_cdev, cdev);
	79	filp->private_data = dev;
	80	return 0;
	81	}
	82	/*------------------------------------------------------------------------------
	83	* Context: process
	84	*/
	85	int oz_cdev_release(struct inode inode, struct file filp)
	86	{
	87	oz_trace("oz_cdev_release()\n");
	88	return 0;
	89	}
	90	/*------------------------------------------------------------------------------
	91	* Context: process
	92	*/
	93	ssize_t oz_cdev_read(struct file filp, char __user buf, size_t count,
	94	loff_t *fpos)
	95	{
	96	int n;
	97	int ix;
	98
	99	struct oz_pd *pd;
	100	struct oz_serial_ctx *ctx = 0;
	101
	102	spin_lock_bh(&g_cdev.lock);
	103	pd = g_cdev.active_pd;
	104	if (pd)
	105	oz_pd_get(pd);
	106	spin_unlock_bh(&g_cdev.lock);
3d9562a6	107	if (pd == NULL)
23af8c2a CK	108	return -1;
23af8c2a CK	109	ctx = oz_cdev_claim_ctx(pd);
3d9562a6	110	if (ctx == NULL)
23af8c2a CK	111	goto out2;
	112	n = ctx->rd_in - ctx->rd_out;
	113	if (n < 0)
	114	n += OZ_RD_BUF_SZ;
	115	if (count > n)
	116	count = n;
	117	ix = ctx->rd_out;
	118	n = OZ_RD_BUF_SZ - ix;
	119	if (n > count)
	120	n = count;
	121	if (copy_to_user(buf, &ctx->rd_buf[ix], n)) {
	122	count = 0;
	123	goto out1;
	124	}
	125	ix += n;
	126	if (ix == OZ_RD_BUF_SZ)
	127	ix = 0;
	128	if (n < count) {
	129	if (copy_to_user(&buf[n], ctx->rd_buf, count-n)) {
	130	count = 0;
	131	goto out1;
	132	}
	133	ix = count-n;
	134	}
	135	ctx->rd_out = ix;
	136	out1:
	137	oz_cdev_release_ctx(ctx);
	138	out2:
	139	oz_pd_put(pd);
	140	return count;
	141	}
	142	/*------------------------------------------------------------------------------
	143	* Context: process
	144	*/
	145	ssize_t oz_cdev_write(struct file filp, const char __user buf, size_t count,
	146	loff_t *fpos)
	147	{
	148	struct oz_pd *pd;
	149	struct oz_elt_buf *eb;
	150	struct oz_elt_info *ei = 0;
	151	struct oz_elt *elt;
	152	struct oz_app_hdr *app_hdr;
	153	struct oz_serial_ctx *ctx;
	154
	155	spin_lock_bh(&g_cdev.lock);
	156	pd = g_cdev.active_pd;
	157	if (pd)
	158	oz_pd_get(pd);
	159	spin_unlock_bh(&g_cdev.lock);
3d9562a6	160	if (pd == NULL)
23af8c2a CK	161	return -1;
	162	eb = &pd->elt_buff;
	163	ei = oz_elt_info_alloc(eb);
3d9562a6	164	if (ei == NULL) {
23af8c2a CK	165	count = 0;
	166	goto out;
	167	}
	168	elt = (struct oz_elt *)ei->data;
	169	app_hdr = (struct oz_app_hdr *)(elt+1);
	170	elt->length = sizeof(struct oz_app_hdr) + count;
	171	elt->type = OZ_ELT_APP_DATA;
	172	ei->app_id = OZ_APPID_SERIAL;
	173	ei->length = elt->length + sizeof(struct oz_elt);
	174	app_hdr->app_id = OZ_APPID_SERIAL;
	175	if (copy_from_user(app_hdr+1, buf, count))
	176	goto out;
	177	spin_lock_bh(&pd->app_lock[OZ_APPID_USB-1]);
	178	ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
	179	if (ctx) {
	180	app_hdr->elt_seq_num = ctx->tx_seq_num++;
	181	if (ctx->tx_seq_num == 0)
	182	ctx->tx_seq_num = 1;
	183	spin_lock(&eb->lock);
	184	if (oz_queue_elt_info(eb, 0, 0, ei) == 0)
	185	ei = 0;
	186	spin_unlock(&eb->lock);
	187	}
	188	spin_unlock_bh(&pd->app_lock[OZ_APPID_USB-1]);
	189	out:
	190	if (ei) {
	191	count = 0;
	192	spin_lock_bh(&eb->lock);
	193	oz_elt_info_free(eb, ei);
	194	spin_unlock_bh(&eb->lock);
	195	}
	196	oz_pd_put(pd);
	197	return count;
	198	}
	199	/*------------------------------------------------------------------------------
	200	* Context: process
	201	*/
	202	static int oz_set_active_pd(u8 *addr)
	203	{
	204	int rc = 0;
	205	struct oz_pd *pd;
	206	struct oz_pd *old_pd;
	207	pd = oz_pd_find(addr);
	208	if (pd) {
	209	spin_lock_bh(&g_cdev.lock);
	210	memcpy(g_cdev.active_addr, addr, ETH_ALEN);
	211	old_pd = g_cdev.active_pd;
	212	g_cdev.active_pd = pd;
	213	spin_unlock_bh(&g_cdev.lock);
	214	if (old_pd)
	215	oz_pd_put(old_pd);
	216	} else {
07732be2	217	if (is_zero_ether_addr(addr)) {
23af8c2a CK	218	spin_lock_bh(&g_cdev.lock);
	219	pd = g_cdev.active_pd;
	220	g_cdev.active_pd = 0;
	221	memset(g_cdev.active_addr, 0,
	222	sizeof(g_cdev.active_addr));
	223	spin_unlock_bh(&g_cdev.lock);
	224	if (pd)
	225	oz_pd_put(pd);
	226	} else {
	227	rc = -1;
	228	}
	229	}
	230	return rc;
	231	}
	232	/*------------------------------------------------------------------------------
	233	* Context: process
	234	*/
	235	long oz_cdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	236	{
	237	int rc = 0;
	238	if (_IOC_TYPE(cmd) != OZ_IOCTL_MAGIC)
	239	return -ENOTTY;
	240	if (_IOC_NR(cmd) > OZ_IOCTL_MAX)
	241	return -ENOTTY;
	242	if (_IOC_DIR(cmd) & _IOC_READ)
	243	rc = !access_ok(VERIFY_WRITE, (void __user *)arg,
	244	_IOC_SIZE(cmd));
	245	else if (_IOC_DIR(cmd) & _IOC_WRITE)
	246	rc = !access_ok(VERIFY_READ, (void __user *)arg,
	247	_IOC_SIZE(cmd));
	248	if (rc)
	249	return -EFAULT;
	250	switch (cmd) {
	251	case OZ_IOCTL_GET_PD_LIST: {
	252	struct oz_pd_list list;
	253	oz_trace("OZ_IOCTL_GET_PD_LIST\n");
	254	list.count = oz_get_pd_list(list.addr, OZ_MAX_PDS);
	255	if (copy_to_user((void __user *)arg, &list,
	256	sizeof(list)))
	257	return -EFAULT;
	258	}
	259	break;
	260	case OZ_IOCTL_SET_ACTIVE_PD: {
	261	u8 addr[ETH_ALEN];
	262	oz_trace("OZ_IOCTL_SET_ACTIVE_PD\n");
	263	if (copy_from_user(addr, (void __user *)arg, ETH_ALEN))
	264	return -EFAULT;
	265	rc = oz_set_active_pd(addr);
	266	}
	267	break;
	268	case OZ_IOCTL_GET_ACTIVE_PD: {
	269	u8 addr[ETH_ALEN];
	270	oz_trace("OZ_IOCTL_GET_ACTIVE_PD\n");
	271	spin_lock_bh(&g_cdev.lock);
	272	memcpy(addr, g_cdev.active_addr, ETH_ALEN);
	273	spin_unlock_bh(&g_cdev.lock);
	274	if (copy_to_user((void __user *)arg, addr, ETH_ALEN))
	275	return -EFAULT;
	276	}
	277	break;
23af8c2a CK	278	case OZ_IOCTL_ADD_BINDING:
	279	case OZ_IOCTL_REMOVE_BINDING: {
	280	struct oz_binding_info b;
	281	if (copy_from_user(&b, (void __user *)arg,
	282	sizeof(struct oz_binding_info))) {
	283	return -EFAULT;
	284	}
	285	/* Make sure name is null terminated. */
	286	b.name[OZ_MAX_BINDING_LEN-1] = 0;
	287	if (cmd == OZ_IOCTL_ADD_BINDING)
	288	oz_binding_add(b.name);
	289	else
	290	oz_binding_remove(b.name);
	291	}
	292	break;
	293	}
	294	return rc;
	295	}
	296	/*------------------------------------------------------------------------------
	297	* Context: process
	298	*/
	299	unsigned int oz_cdev_poll(struct file filp, poll_table wait)
	300	{
	301	unsigned int ret = 0;
	302	struct oz_cdev *dev = filp->private_data;
	303	oz_trace("Poll called wait = %p\n", wait);
	304	spin_lock_bh(&dev->lock);
	305	if (dev->active_pd) {
	306	struct oz_serial_ctx *ctx = oz_cdev_claim_ctx(dev->active_pd);
	307	if (ctx) {
	308	if (ctx->rd_in != ctx->rd_out)
	309	ret \|= POLLIN \| POLLRDNORM;
	310	oz_cdev_release_ctx(ctx);
	311	}
	312	}
	313	spin_unlock_bh(&dev->lock);
	314	if (wait)
	315	poll_wait(filp, &dev->rdq, wait);
	316	return ret;
	317	}
	318	/*------------------------------------------------------------------------------
	319	*/
	320	const struct file_operations oz_fops = {
	321	.owner = THIS_MODULE,
	322	.open = oz_cdev_open,
	323	.release = oz_cdev_release,
	324	.read = oz_cdev_read,
	325	.write = oz_cdev_write,
	326	.unlocked_ioctl = oz_cdev_ioctl,
	327	.poll = oz_cdev_poll
	328	};
	329	/*------------------------------------------------------------------------------
	330	* Context: process
	331	*/
	332	int oz_cdev_register(void)
	333	{
	334	int err;
6261c1ee	335	struct device *dev;
23af8c2a CK	336	memset(&g_cdev, 0, sizeof(g_cdev));
	337	err = alloc_chrdev_region(&g_cdev.devnum, 0, 1, "ozwpan");
	338	if (err < 0)
6261c1ee	339	goto out3;
23af8c2a CK	340	oz_trace("Alloc dev number %d:%d\n", MAJOR(g_cdev.devnum),
	341	MINOR(g_cdev.devnum));
	342	cdev_init(&g_cdev.cdev, &oz_fops);
	343	g_cdev.cdev.owner = THIS_MODULE;
	344	g_cdev.cdev.ops = &oz_fops;
	345	spin_lock_init(&g_cdev.lock);
	346	init_waitqueue_head(&g_cdev.rdq);
	347	err = cdev_add(&g_cdev.cdev, g_cdev.devnum, 1);
6261c1ee RG	348	if (err < 0) {
	349	oz_trace("Failed to add cdev\n");
	350	goto out2;
	351	}
ba0a7ae7 RG	352	g_oz_class = class_create(THIS_MODULE, "ozmo_wpan");
ba0a7ae7 RG	353	if (IS_ERR(g_oz_class)) {
6261c1ee RG	354	oz_trace("Failed to register ozmo_wpan class\n");
	355	goto out1;
	356	}
ba0a7ae7	357	dev = device_create(g_oz_class, NULL, g_cdev.devnum, NULL, "ozwpan");
6261c1ee RG	358	if (IS_ERR(dev)) {
	359	oz_trace("Failed to create sysfs entry for cdev\n");
	360	goto out1;
	361	}
23af8c2a	362	return 0;
6261c1ee RG	363	out1:
	364	cdev_del(&g_cdev.cdev);
	365	out2:
	366	unregister_chrdev_region(g_cdev.devnum, 1);
	367	out3:
	368	return err;
23af8c2a CK	369	}
	370	/*------------------------------------------------------------------------------
	371	* Context: process
	372	*/
	373	int oz_cdev_deregister(void)
	374	{
	375	cdev_del(&g_cdev.cdev);
	376	unregister_chrdev_region(g_cdev.devnum, 1);
ba0a7ae7 RG	377	if (g_oz_class) {
	378	device_destroy(g_oz_class, g_cdev.devnum);
	379	class_destroy(g_oz_class);
	380	}
23af8c2a CK	381	return 0;
	382	}
	383	/*------------------------------------------------------------------------------
	384	* Context: process
	385	*/
	386	int oz_cdev_init(void)
	387	{
	388	oz_event_log(OZ_EVT_SERVICE, 1, OZ_APPID_SERIAL, 0, 0);
	389	oz_app_enable(OZ_APPID_SERIAL, 1);
	390	return 0;
	391	}
	392	/*------------------------------------------------------------------------------
	393	* Context: process
	394	*/
	395	void oz_cdev_term(void)
	396	{
	397	oz_event_log(OZ_EVT_SERVICE, 2, OZ_APPID_SERIAL, 0, 0);
	398	oz_app_enable(OZ_APPID_SERIAL, 0);
	399	}
	400	/*------------------------------------------------------------------------------
	401	* Context: softirq-serialized
	402	*/
	403	int oz_cdev_start(struct oz_pd *pd, int resume)
	404	{
	405	struct oz_serial_ctx *ctx;
	406	struct oz_serial_ctx *old_ctx = 0;
	407	oz_event_log(OZ_EVT_SERVICE, 3, OZ_APPID_SERIAL, 0, resume);
	408	if (resume) {
	409	oz_trace("Serial service resumed.\n");
	410	return 0;
	411	}
1ec41a31	412	ctx = kzalloc(sizeof(struct oz_serial_ctx), GFP_ATOMIC);
3d9562a6	413	if (ctx == NULL)
1ec41a31	414	return -ENOMEM;
23af8c2a CK	415	atomic_set(&ctx->ref_count, 1);
	416	ctx->tx_seq_num = 1;
	417	spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	418	old_ctx = pd->app_ctx[OZ_APPID_SERIAL-1];
	419	if (old_ctx) {
	420	spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
1ec41a31	421	kfree(ctx);
23af8c2a CK	422	} else {
	423	pd->app_ctx[OZ_APPID_SERIAL-1] = ctx;
	424	spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	425	}
	426	spin_lock(&g_cdev.lock);
3d9562a6	427	if ((g_cdev.active_pd == NULL) &&
23af8c2a CK	428	(memcmp(pd->mac_addr, g_cdev.active_addr, ETH_ALEN) == 0)) {
	429	oz_pd_get(pd);
	430	g_cdev.active_pd = pd;
	431	oz_trace("Active PD arrived.\n");
	432	}
	433	spin_unlock(&g_cdev.lock);
	434	oz_trace("Serial service started.\n");
	435	return 0;
	436	}
	437	/*------------------------------------------------------------------------------
	438	* Context: softirq or process
	439	*/
	440	void oz_cdev_stop(struct oz_pd *pd, int pause)
	441	{
	442	struct oz_serial_ctx *ctx;
	443	oz_event_log(OZ_EVT_SERVICE, 4, OZ_APPID_SERIAL, 0, pause);
	444	if (pause) {
	445	oz_trace("Serial service paused.\n");
	446	return;
	447	}
	448	spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	449	ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
	450	pd->app_ctx[OZ_APPID_SERIAL-1] = 0;
	451	spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
	452	if (ctx)
	453	oz_cdev_release_ctx(ctx);
	454	spin_lock(&g_cdev.lock);
	455	if (pd == g_cdev.active_pd)
	456	g_cdev.active_pd = 0;
	457	else
	458	pd = 0;
	459	spin_unlock(&g_cdev.lock);
	460	if (pd) {
	461	oz_pd_put(pd);
	462	oz_trace("Active PD departed.\n");
	463	}
	464	oz_trace("Serial service stopped.\n");
	465	}
	466	/*------------------------------------------------------------------------------
	467	* Context: softirq-serialized
	468	*/
	469	void oz_cdev_rx(struct oz_pd pd, struct oz_elt elt)
	470	{
	471	struct oz_serial_ctx *ctx;
	472	struct oz_app_hdr *app_hdr;
	473	u8 *data;
	474	int len;
	475	int space;
	476	int copy_sz;
	477	int ix;
	478
	479	ctx = oz_cdev_claim_ctx(pd);
3d9562a6	480	if (ctx == NULL) {
23af8c2a CK	481	oz_trace("Cannot claim serial context.\n");
	482	return;
	483	}
	484
	485	app_hdr = (struct oz_app_hdr *)(elt+1);
	486	/* If sequence number is non-zero then check it is not a duplicate.
	487	*/
	488	if (app_hdr->elt_seq_num != 0) {
	489	if (((ctx->rx_seq_num - app_hdr->elt_seq_num) & 0x80) == 0) {
	490	/* Reject duplicate element. */
	491	oz_trace("Duplicate element:%02x %02x\n",
	492	app_hdr->elt_seq_num, ctx->rx_seq_num);
	493	goto out;
	494	}
	495	}
	496	ctx->rx_seq_num = app_hdr->elt_seq_num;
	497	len = elt->length - sizeof(struct oz_app_hdr);
	498	data = ((u8 *)(elt+1)) + sizeof(struct oz_app_hdr);
	499	if (len <= 0)
	500	goto out;
	501	space = ctx->rd_out - ctx->rd_in - 1;
	502	if (space < 0)
	503	space += OZ_RD_BUF_SZ;
	504	if (len > space) {
	505	oz_trace("Not enough space:%d %d\n", len, space);
	506	len = space;
	507	}
	508	ix = ctx->rd_in;
	509	copy_sz = OZ_RD_BUF_SZ - ix;
	510	if (copy_sz > len)
	511	copy_sz = len;
	512	memcpy(&ctx->rd_buf[ix], data, copy_sz);
	513	len -= copy_sz;
	514	ix += copy_sz;
	515	if (ix == OZ_RD_BUF_SZ)
	516	ix = 0;
	517	if (len) {
	518	memcpy(ctx->rd_buf, data+copy_sz, len);
	519	ix = len;
	520	}
	521	ctx->rd_in = ix;
	522	wake_up(&g_cdev.rdq);
	523	out:
	524	oz_cdev_release_ctx(ctx);
	525	}
	526	/*------------------------------------------------------------------------------
	527	* Context: softirq
	528	*/
	529	void oz_cdev_heartbeat(struct oz_pd *pd)
	530	{
	531	}