1 files changed, 428 insertions, 0 deletions

diff --git a/drivers/input/touchscreen/rmi4/rmi_dev.c b/drivers/input/touchscreen/rmi4/rmi_dev.c
new file mode 100644
index 00000000000..fa21ef9b20f
--- /dev/null
+++ b/drivers/input/touchscreen/rmi4/rmi_dev.c
@@ -0,0 +1,428 @@
+/*
+ * Copyright (c) 2011 Synaptics Incorporated
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/delay.h>
+#include <linux/uaccess.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/syscalls.h>
+
+#include <linux/rmi.h>
+#include "rmi_driver.h"
+
+#define CHAR_DEVICE_NAME "rmi"
+
+#define REG_ADDR_LIMIT 0xFFFF
+
+/*store dynamically allocated major number of char device*/
+static int rmi_char_dev_major_num;
+
+
+/* file operations for RMI char device */
+
+/*
+ * rmi_char_dev_llseek: - use to setup register address
+ *
+ * @filp: file structure for seek
+ * @off: offset
+ *       if whence == SEEK_SET,
+ *       high 16 bits: page address
+ *       low 16 bits: register address
+ *
+ *       if whence == SEEK_CUR,
+ *       offset from current position
+ *
+ *       if whence == SEEK_END,
+ *       offset from END(0xFFFF)
+ *
+ * @whence: SEEK_SET , SEEK_CUR or SEEK_END
+ */
+static loff_t rmi_char_dev_llseek(struct file *filp, loff_t off, int whence)
+{
+        loff_t newpos;
+        struct rmi_char_dev *my_char_dev = filp->private_data;
+
+        if (IS_ERR(my_char_dev)) {
+                pr_err("%s: pointer of char device is invalid", __func__);
+                return -EBADF;
+        }
+
+        mutex_lock(&(my_char_dev->mutex_file_op));
+
+        switch (whence) {
+        case SEEK_SET:
+                newpos = off;
+                break;
+
+        case SEEK_CUR:
+                newpos = filp->f_pos + off;
+                break;
+
+        case SEEK_END:
+                newpos = REG_ADDR_LIMIT + off;
+                break;
+
+        default:                /* can't happen */
+                newpos = -EINVAL;
+                goto clean_up;
+        }
+
+        if (newpos < 0 || newpos > REG_ADDR_LIMIT) {
+                dev_err(my_char_dev->phys->dev, "newpos 0x%04x is invalid.\n",
+                        (unsigned int)newpos);
+                newpos = -EINVAL;
+                goto clean_up;
+        }
+
+        filp->f_pos = newpos;
+
+clean_up:
+        mutex_unlock(&(my_char_dev->mutex_file_op));
+        return newpos;
+}
+
+/*
+ *  rmi_char_dev_read: - use to read data from RMI stream
+ *
+ *  @filp: file structure for read
+ *  @buf: user-level buffer pointer
+ *
+ *  @count: number of byte read
+ *  @f_pos: offset (starting register address)
+ *
+ *      @return number of bytes read into user buffer (buf) if succeeds
+ *          negative number if error occurs.
+ */
+static ssize_t rmi_char_dev_read(struct file *filp, char __user *buf,
+                size_t count, loff_t *f_pos)
+{
+        struct rmi_char_dev *my_char_dev = filp->private_data;
+        ssize_t ret_value  = 0;
+        unsigned char tmpbuf[count+1];
+        struct rmi_phys_device *phys;
+
+        /* limit offset to REG_ADDR_LIMIT-1 */
+        if (count > (REG_ADDR_LIMIT - *f_pos))
+                count = REG_ADDR_LIMIT - *f_pos;
+
+        if (count == 0)
+                return 0;
+
+        if (IS_ERR(my_char_dev)) {
+                pr_err("%s: pointer of char device is invalid", __func__);
+                ret_value = -EBADF;
+                return ret_value;
+        }
+
+        mutex_lock(&(my_char_dev->mutex_file_op));
+
+        phys = my_char_dev->phys;
+        /*
+         * just let it go through , because we do not know the register is FIFO
+         * register or not
+         */
+
+        ret_value = phys->read_block(phys, *f_pos, tmpbuf, count);
+
+        if (ret_value < 0)
+                goto clean_up;
+        else
+                *f_pos += ret_value;
+
+        if (copy_to_user(buf, tmpbuf, count))
+                ret_value = -EFAULT;
+
+clean_up:
+
+        mutex_unlock(&(my_char_dev->mutex_file_op));
+
+        return ret_value;
+}
+
+/*
+ * rmi_char_dev_write: - use to write data into RMI stream
+ *
+ * @filep : file structure for write
+ * @buf: user-level buffer pointer contains data to be written
+ * @count: number of byte be be written
+ * @f_pos: offset (starting register address)
+ *
+ * @return number of bytes written from user buffer (buf) if succeeds
+ *         negative number if error occurs.
+ */
+static ssize_t rmi_char_dev_write(struct file *filp, const char __user *buf,
+                size_t count, loff_t *f_pos)
+{
+        struct rmi_char_dev *my_char_dev = filp->private_data;
+        ssize_t ret_value  = 0;
+        unsigned char tmpbuf[count+1];
+        struct rmi_phys_device *phys;
+
+        /* limit offset to REG_ADDR_LIMIT-1 */
+        if (count > (REG_ADDR_LIMIT - *f_pos))
+                count = REG_ADDR_LIMIT - *f_pos;
+
+        if (count == 0)
+                return 0;
+
+        if (IS_ERR(my_char_dev)) {
+                pr_err("%s: pointer of char device is invalid", __func__);
+                ret_value = -EBADF;
+                return ret_value;
+        }
+
+        if (copy_from_user(tmpbuf, buf, count)) {
+                ret_value = -EFAULT;
+                return ret_value;
+        }
+
+        mutex_lock(&(my_char_dev->mutex_file_op));
+
+        phys = my_char_dev->phys;
+        /*
+         * just let it go through , because we do not know the register is FIFO
+         * register or not
+         */
+
+        ret_value = phys->write_block(phys, *f_pos, tmpbuf, count);
+
+        if (ret_value >= 0)
+                *f_pos += count;
+
+        mutex_unlock(&(my_char_dev->mutex_file_op));
+
+        return ret_value;
+}
+
+/*
+ * rmi_char_dev_open: - get a new handle for from RMI stream
+ * @inp : inode struture
+ * @filp: file structure for read/write
+ *
+ * @return 0 if succeeds
+ */
+static int rmi_char_dev_open(struct inode *inp, struct file *filp)
+{
+        /* store the device pointer to file structure */
+        struct rmi_char_dev *my_dev = container_of(inp->i_cdev,
+                        struct rmi_char_dev, main_dev);
+        struct rmi_phys_device *phys = my_dev->phys;
+        int ret_value = 0;
+
+        filp->private_data = my_dev;
+
+        if (!phys)
+                return -EACCES;
+
+        mutex_lock(&(my_dev->mutex_file_op));
+        if (my_dev->ref_count < 1)
+                my_dev->ref_count++;
+        else
+                ret_value = -EACCES;
+
+        mutex_unlock(&(my_dev->mutex_file_op));
+
+        return ret_value;
+}
+
+/*
+ *  rmi_char_dev_release: - release an existing handle
+ *  @inp: inode structure
+ *  @filp: file structure for read/write
+ *
+ *  @return 0 if succeeds
+ */
+static int rmi_char_dev_release(struct inode *inp, struct file *filp)
+{
+        struct rmi_char_dev *my_dev = container_of(inp->i_cdev,
+                        struct rmi_char_dev, main_dev);
+        struct rmi_phys_device *phys = my_dev->phys;
+
+        if (!phys)
+                return -EACCES;
+
+        mutex_lock(&(my_dev->mutex_file_op));
+
+        my_dev->ref_count--;
+        if (my_dev->ref_count < 0)
+                my_dev->ref_count = 0;
+
+        mutex_unlock(&(my_dev->mutex_file_op));
+
+        return 0;
+}
+
+static const struct file_operations rmi_char_dev_fops = {
+        .owner =    THIS_MODULE,
+        .llseek =   rmi_char_dev_llseek,
+        .read =     rmi_char_dev_read,
+        .write =    rmi_char_dev_write,
+        .open =     rmi_char_dev_open,
+        .release =  rmi_char_dev_release,
+};
+
+/*
+ * rmi_char_dev_clean_up - release memory or unregister driver
+ * @rmi_char_dev: rmi_char_dev structure
+ *
+ */
+static void rmi_char_dev_clean_up(struct rmi_char_dev *char_dev,
+                        struct class *char_device_class)
+{
+        dev_t devno;
+
+        /* Get rid of our char dev entries */
+        if (char_dev) {
+                devno = char_dev->main_dev.dev;
+
+                cdev_del(&char_dev->main_dev);
+                kfree(char_dev);
+
+                if (char_device_class) {
+                        device_destroy(char_device_class, devno);
+                        class_unregister(char_device_class);
+                        class_destroy(char_device_class);
+                }
+
+                /* cleanup_module is never called if registering failed */
+                unregister_chrdev_region(devno, 1);
+                pr_debug("%s: rmi_char_dev is removed\n", __func__);
+        }
+}
+
+/*
+ * rmi_char_devnode - return device permission
+ *
+ * @dev: char device structure
+ * @mode: file permission
+ *
+ */
+static char *rmi_char_devnode(struct device *dev, mode_t *mode)
+{
+        if (!mode)
+                return NULL;
+        /* rmi** */
+        /**mode = 0666*/
+        *mode = (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
+
+        return kasprintf(GFP_KERNEL, "rmi/%s", dev_name(dev));
+}
+
+/*
+ * rmi_char_dev_register - register char device (called from up-level)
+ *
+ * @phy: a pointer to an rmi_phys_devices structure
+ *
+ * @return: zero if suceeds
+ */
+int rmi_char_dev_register(struct rmi_phys_device *phys)
+{
+        struct rmi_char_dev *char_dev;
+        dev_t dev_no;
+        int err;
+        int result;
+        struct device *device_ptr;
+
+        if (rmi_char_dev_major_num) {
+                dev_no = MKDEV(rmi_char_dev_major_num, 0);
+                result = register_chrdev_region(dev_no, 1, CHAR_DEVICE_NAME);
+        } else {
+                result = alloc_chrdev_region(&dev_no, 0, 1, CHAR_DEVICE_NAME);
+                /* let kernel allocate a major for us */
+                rmi_char_dev_major_num = MAJOR(dev_no);
+                dev_info(phys->dev, "Major number of rmi_char_dev: %d\n",
+                                 rmi_char_dev_major_num);
+        }
+        if (result < 0)
+                return result;
+
+        char_dev = kzalloc(sizeof(struct rmi_char_dev), GFP_KERNEL);
+        if (!char_dev) {
+                dev_err(phys->dev, "Failed to allocate rmi_char_dev.\n");
+                /* unregister the char device region */
+                __unregister_chrdev(rmi_char_dev_major_num, MINOR(dev_no), 1,
+                                CHAR_DEVICE_NAME);
+                return -ENOMEM;
+        }
+
+        mutex_init(&char_dev->mutex_file_op);
+
+        phys->char_dev = char_dev;
+        char_dev->phys = phys;
+
+        cdev_init(&char_dev->main_dev, &rmi_char_dev_fops);
+
+        err = cdev_add(&char_dev->main_dev, dev_no, 1);
+        if (err) {
+                dev_err(phys->dev, "Error %d adding rmi_char_dev.\n", err);
+                rmi_char_dev_clean_up(phys->char_dev,
+                                 phys->rmi_char_device_class);
+                return err;
+        }
+
+        /* create device node */
+        phys->rmi_char_device_class =
+                class_create(THIS_MODULE, CHAR_DEVICE_NAME);
+
+        if (IS_ERR(phys->rmi_char_device_class)) {
+                dev_err(phys->dev, "Failed to create /dev/%s.\n",
+                        CHAR_DEVICE_NAME);
+                rmi_char_dev_clean_up(phys->char_dev,
+                                 phys->rmi_char_device_class);
+                return -ENODEV;
+        }
+        /* setup permission */
+        phys->rmi_char_device_class->devnode = rmi_char_devnode;
+
+        /* class creation */
+        device_ptr = device_create(
+                        phys->rmi_char_device_class,
+                        NULL, dev_no, NULL,
+                        CHAR_DEVICE_NAME"%d",
+                        MINOR(dev_no));
+
+        if (IS_ERR(device_ptr)) {
+                dev_err(phys->dev, "Failed to create rmi device.\n");
+                rmi_char_dev_clean_up(phys->char_dev,
+                                 phys->rmi_char_device_class);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(rmi_char_dev_register);
+
+/* rmi_char_dev_unregister - unregister char device (called from up-level)
+ *
+ * @phys: pointer to an rmi_phys_device structure
+ */
+
+void rmi_char_dev_unregister(struct rmi_phys_device *phys)
+{
+        /* clean up */
+        if (phys)
+                rmi_char_dev_clean_up(phys->char_dev,
+                                 phys->rmi_char_device_class);
+}
+EXPORT_SYMBOL(rmi_char_dev_unregister);
+
+MODULE_AUTHOR("Synaptics, Inc.");
+MODULE_DESCRIPTION("RMI4 Char Device");
+MODULE_LICENSE("GPL");