staging: ozwpan: Added character device support

The character device provides a management interface to the driver
and also provides an additional service to the protocol for side
band communication with the device.

Signed-off-by: Chris Kelly <ckelly@ozmodevices.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

3 files changed, 588 insertions, 0 deletions

diff --git a/drivers/staging/ozwpan/ozappif.h b/drivers/staging/ozwpan/ozappif.h
new file mode 100644
index 00000000000..af027329387
--- /dev/null
+++ b/drivers/staging/ozwpan/ozappif.h
@@ -0,0 +1,46 @@
+/* -----------------------------------------------------------------------------
+ * Copyright (c) 2011 Ozmo Inc
+ * Released under the GNU General Public License Version 2 (GPLv2).
+ * -----------------------------------------------------------------------------
+ */
+#ifndef _OZAPPIF_H
+#define _OZAPPIF_H
+
+#include "ozeventdef.h"
+
+#define OZ_IOCTL_MAGIC  0xf4
+
+struct oz_mac_addr {
+        unsigned char a[6];
+};
+
+#define OZ_MAX_PDS      8
+
+struct oz_pd_list {
+        int count;
+        struct oz_mac_addr addr[OZ_MAX_PDS];
+};
+
+#define OZ_MAX_BINDING_LEN      32
+
+struct oz_binding_info {
+        char name[OZ_MAX_BINDING_LEN];
+};
+
+struct oz_test {
+        int action;
+};
+
+#define OZ_IOCTL_GET_PD_LIST    _IOR(OZ_IOCTL_MAGIC, 0, struct oz_pd_list)
+#define OZ_IOCTL_SET_ACTIVE_PD  _IOW(OZ_IOCTL_MAGIC, 1, struct oz_mac_addr)
+#define OZ_IOCTL_GET_ACTIVE_PD  _IOR(OZ_IOCTL_MAGIC, 2, struct oz_mac_addr)
+#define OZ_IOCTL_CLEAR_EVENTS   _IO(OZ_IOCTL_MAGIC, 3)
+#define OZ_IOCTL_GET_EVENTS     _IOR(OZ_IOCTL_MAGIC, 4, struct oz_evtlist)
+#define OZ_IOCTL_ADD_BINDING    _IOW(OZ_IOCTL_MAGIC, 5, struct oz_binding_info)
+#define OZ_IOCTL_TEST           _IOWR(OZ_IOCTL_MAGIC, 6, struct oz_test)
+#define OZ_IOCTL_SET_EVENT_MASK _IOW(OZ_IOCTL_MAGIC, 7, unsigned long)
+#define OZ_IOCTL_REMOVE_BINDING _IOW(OZ_IOCTL_MAGIC, 8, struct oz_binding_info)
+#define OZ_IOCTL_MAX            9
+
+
+#endif /* _OZAPPIF_H */
diff --git a/drivers/staging/ozwpan/ozcdev.c b/drivers/staging/ozwpan/ozcdev.c
new file mode 100644
index 00000000000..912c964cb55
--- /dev/null
+++ b/drivers/staging/ozwpan/ozcdev.c
@@ -0,0 +1,524 @@
+/* -----------------------------------------------------------------------------
+ * 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/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 "ozalloc.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;
+};
+/*------------------------------------------------------------------------------
+ */
+int g_taction;
+/*------------------------------------------------------------------------------
+ */
+static struct oz_cdev g_cdev;
+/*------------------------------------------------------------------------------
+ * 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");
+                oz_free(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 == 0)
+                return -1;
+        ctx = oz_cdev_claim_ctx(pd);
+        if (ctx == 0)
+                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 == 0)
+                return -1;
+        eb = &pd->elt_buff;
+        ei = oz_elt_info_alloc(eb);
+        if (ei == 0) {
+                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 (!memcmp(addr, "\0\0\0\0\0\0", sizeof(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;
+#ifdef WANT_EVENT_TRACE
+        case OZ_IOCTL_CLEAR_EVENTS:
+                oz_events_clear();
+                break;
+        case OZ_IOCTL_GET_EVENTS:
+                rc = oz_events_copy((void __user *)arg);
+                break;
+        case OZ_IOCTL_SET_EVENT_MASK:
+                if (copy_from_user(&g_evt_mask, (void __user *)arg,
+                        sizeof(unsigned long))) {
+                        return -EFAULT;
+                }
+                break;
+#endif /* WANT_EVENT_TRACE */
+        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;
+        memset(&g_cdev, 0, sizeof(g_cdev));
+        err = alloc_chrdev_region(&g_cdev.devnum, 0, 1, "ozwpan");
+        if (err < 0)
+                return err;
+        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);
+        return 0;
+}
+/*------------------------------------------------------------------------------
+ * Context: process
+ */
+int oz_cdev_deregister(void)
+{
+        cdev_del(&g_cdev.cdev);
+        unregister_chrdev_region(g_cdev.devnum, 1);
+        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 = (struct oz_serial_ctx *)
+                oz_alloc(sizeof(struct oz_serial_ctx), GFP_ATOMIC);
+        if (ctx == 0)
+                return -1;
+        memset(ctx, 0, sizeof(struct oz_serial_ctx));
+        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]);
+                oz_free(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 == 0) &&
+                (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 == 0) {
+                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)
+{
+}
diff --git a/drivers/staging/ozwpan/ozcdev.h b/drivers/staging/ozwpan/ozcdev.h
new file mode 100644
index 00000000000..698014bb8d7
--- /dev/null
+++ b/drivers/staging/ozwpan/ozcdev.h
@@ -0,0 +1,18 @@
+/* -----------------------------------------------------------------------------
+ * Copyright (c) 2011 Ozmo Inc
+ * Released under the GNU General Public License Version 2 (GPLv2).
+ * -----------------------------------------------------------------------------
+ */
+#ifndef _OZCDEV_H
+#define _OZCDEV_H
+
+int oz_cdev_register(void);
+int oz_cdev_deregister(void);
+int oz_cdev_init(void);
+void oz_cdev_term(void);
+int oz_cdev_start(struct oz_pd *pd, int resume);
+void oz_cdev_stop(struct oz_pd *pd, int pause);
+void oz_cdev_rx(struct oz_pd *pd, struct oz_elt *elt);
+void oz_cdev_heartbeat(struct oz_pd *pd);
+
+#endif /* _OZCDEV_H */