Subversion Repositories shark

/*
    i2c-dev.c - i2c-bus driver, char device interface  

    Copyright (C) 1995-97 Simon G. Vogl
    Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
    Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>

    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.
*/

/* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
   But I have used so much of his original code and ideas that it seems
   only fair to recognize him as co-author -- Frodo */

/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */

/* The devfs code is contributed by Philipp Matthias Hahn
   <pmhahn@titan.lahn.de> */

/* If you want debugging uncomment: */
#define DEBUG 1

#include <linuxcomp.h>

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/smp_lock.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <asm/uaccess.h>

static struct i2c_client i2cdev_client_template;

struct i2c_dev {
        int minor;
        struct i2c_adapter *adap;
        struct class_device class_dev;
        struct completion released;     /* FIXME, we need a class_device_unregister() */
};
#define to_i2c_dev(d) container_of(d, struct i2c_dev, class_dev)

#define I2C_MINORS      256
static struct i2c_dev *i2c_dev_array[I2C_MINORS];
static spinlock_t i2c_dev_array_lock = SPIN_LOCK_UNLOCKED;

struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
{
        struct i2c_dev *i2c_dev;

        spin_lock(&i2c_dev_array_lock);
        i2c_dev = i2c_dev_array[index];
        spin_unlock(&i2c_dev_array_lock);
        return i2c_dev;
}

struct i2c_dev *i2c_dev_get_by_adapter(struct i2c_adapter *adap)
{
        struct i2c_dev *i2c_dev = NULL;
        int i;

        spin_lock(&i2c_dev_array_lock);
        for (i = 0; i < I2C_MINORS; ++i) {
                if ((i2c_dev_array[i]) &&
                    (i2c_dev_array[i]->adap == adap)) {
                        i2c_dev = i2c_dev_array[i];
                        break;
                }
        }
        spin_unlock(&i2c_dev_array_lock);
        return i2c_dev;
}

static struct i2c_dev *get_free_i2c_dev(void)
{
        struct i2c_dev *i2c_dev;
        unsigned int i;

        i2c_dev = kmalloc(sizeof(*i2c_dev), GFP_KERNEL);
        if (!i2c_dev)
                return ERR_PTR(-ENOMEM);
        memset(i2c_dev, 0x00, sizeof(*i2c_dev));

        spin_lock(&i2c_dev_array_lock);
        for (i = 0; i < I2C_MINORS; ++i) {
                if (i2c_dev_array[i])
                        continue;
                i2c_dev->minor = i;
                i2c_dev_array[i] = i2c_dev;
                spin_unlock(&i2c_dev_array_lock);
                return i2c_dev;
        }
        spin_unlock(&i2c_dev_array_lock);
        kfree(i2c_dev);
        return ERR_PTR(-ENODEV);
}

static void return_i2c_dev(struct i2c_dev *i2c_dev)
{
        spin_lock(&i2c_dev_array_lock);
        i2c_dev_array[i2c_dev->minor] = NULL;
        spin_unlock(&i2c_dev_array_lock);
}

static ssize_t show_dev(struct class_device *class_dev, char *buf)
{
        struct i2c_dev *i2c_dev = to_i2c_dev(class_dev);
        return print_dev_t(buf, MKDEV(I2C_MAJOR, i2c_dev->minor));
}
static CLASS_DEVICE_ATTR(dev, S_IRUGO, show_dev, NULL);

static ssize_t i2cdev_read (struct file *file, char __user *buf, size_t count,
                            loff_t *offset)
{
        char *tmp;
        int ret;

        struct i2c_client *client = (struct i2c_client *)file->private_data;

        if (count > 8192)
                count = 8192;

        tmp = kmalloc(count,GFP_KERNEL);
        if (tmp==NULL)
                return -ENOMEM;

        pr_debug("i2c-dev.o: i2c-%d reading %d bytes.\n",
                (int)iminor(file->f_dentry->d_inode), (int)count);

        ret = i2c_master_recv(client,tmp,count);
        if (ret >= 0)
                ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
        kfree(tmp);
        return ret;
}

static ssize_t i2cdev_write (struct file *file, const char __user *buf, size_t count,
                             loff_t *offset)
{
        int ret;
        char *tmp;
        struct i2c_client *client = (struct i2c_client *)file->private_data;

        if (count > 8192)
                count = 8192;

        tmp = kmalloc(count,GFP_KERNEL);
        if (tmp==NULL)
                return -ENOMEM;
        if (copy_from_user(tmp,buf,count)) {
                kfree(tmp);
                return -EFAULT;
        }

        pr_debug("i2c-dev.o: i2c-%d writing %d bytes.\n",
                (int)iminor(file->f_dentry->d_inode), (int)count);

        ret = i2c_master_send(client,tmp,count);
        kfree(tmp);
        return ret;
}

int i2cdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
                  unsigned long arg)
{
        struct i2c_client *client = (struct i2c_client *)file->private_data;
        struct i2c_rdwr_ioctl_data rdwr_arg;
        struct i2c_smbus_ioctl_data data_arg;
        union i2c_smbus_data temp;
        struct i2c_msg *rdwr_pa;
        u8 **data_ptrs;
        int i,datasize,res;
        unsigned long funcs;

        dev_dbg(&client->dev, "i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n",
                iminor(inode),cmd, arg);

        switch ( cmd ) {
        case I2C_SLAVE:
        case I2C_SLAVE_FORCE:
                if ((arg > 0x3ff) ||
                    (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
                        return -EINVAL;
                if ((cmd == I2C_SLAVE) && i2c_check_addr(client->adapter,arg))
                        return -EBUSY;
                client->addr = arg;
                return 0;
        case I2C_TENBIT:
                if (arg)
                        client->flags |= I2C_M_TEN;
                else
                        client->flags &= ~I2C_M_TEN;
                return 0;
        case I2C_PEC:
                if (arg)
                        client->flags |= I2C_CLIENT_PEC;
                else
                        client->flags &= ~I2C_CLIENT_PEC;
                return 0;
        case I2C_FUNCS:
                funcs = i2c_get_functionality(client->adapter);
                return (copy_to_user((unsigned long __user *)arg, &funcs,
                                     sizeof(unsigned long)))?-EFAULT:0;

        case I2C_RDWR:
                if (copy_from_user(&rdwr_arg,
                                   (struct i2c_rdwr_ioctl_data __user *)arg,
                                   sizeof(rdwr_arg)))
                        return -EFAULT;

                /* Put an arbritrary limit on the number of messages that can
                 * be sent at once */
                if (rdwr_arg.nmsgs > 42)
                        return -EINVAL;
               
                rdwr_pa = (struct i2c_msg *)
                        kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
                        GFP_KERNEL);

                if (rdwr_pa == NULL) return -ENOMEM;

                if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
                                   rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
                        kfree(rdwr_pa);
                        return -EFAULT;
                }

                data_ptrs = (u8 **) kmalloc(rdwr_arg.nmsgs * sizeof(u8 *),
                                            GFP_KERNEL);
                if (data_ptrs == NULL) {
                        kfree(rdwr_pa);
                        return -ENOMEM;
                }

                res = 0;
                for( i=0; i<rdwr_arg.nmsgs; i++ ) {
                        /* Limit the size of the message to a sane amount */
                        if (rdwr_pa[i].len > 8192) {
                                res = -EINVAL;
                                break;
                        }
                        data_ptrs[i] = rdwr_pa[i].buf;
                        rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
                        if(rdwr_pa[i].buf == NULL) {
                                res = -ENOMEM;
                                break;
                        }
                        if(copy_from_user(rdwr_pa[i].buf,
                                data_ptrs[i],
                                rdwr_pa[i].len)) {
                                        ++i; /* Needs to be kfreed too */
                                        res = -EFAULT;
                                break;
                        }
                }
                if (res < 0) {
                        int j;
                        for (j = 0; j < i; ++j)
                                kfree(rdwr_pa[j].buf);
                        kfree(data_ptrs);
                        kfree(rdwr_pa);
                        return res;
                }

                res = i2c_transfer(client->adapter,
                        rdwr_pa,
                        rdwr_arg.nmsgs);
                while(i-- > 0) {
                        if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD)) {
                                if(copy_to_user(
                                        data_ptrs[i],
                                        rdwr_pa[i].buf,
                                        rdwr_pa[i].len)) {
                                        res = -EFAULT;
                                }
                        }
                        kfree(rdwr_pa[i].buf);
                }
                kfree(data_ptrs);
                kfree(rdwr_pa);
                return res;

        case I2C_SMBUS:
                if (copy_from_user(&data_arg,
                                   (struct i2c_smbus_ioctl_data __user *) arg,
                                   sizeof(struct i2c_smbus_ioctl_data)))
                        return -EFAULT;
                if ((data_arg.size != I2C_SMBUS_BYTE) &&
                    (data_arg.size != I2C_SMBUS_QUICK) &&
                    (data_arg.size != I2C_SMBUS_BYTE_DATA) &&
                    (data_arg.size != I2C_SMBUS_WORD_DATA) &&
                    (data_arg.size != I2C_SMBUS_PROC_CALL) &&
                    (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
                    (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
                    (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
                        dev_dbg(&client->dev,
                                "size out of range (%x) in ioctl I2C_SMBUS.\n",
                                data_arg.size);
                        return -EINVAL;
                }
                /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
                   so the check is valid if size==I2C_SMBUS_QUICK too. */
                if ((data_arg.read_write != I2C_SMBUS_READ) &&
                    (data_arg.read_write != I2C_SMBUS_WRITE)) {
                        dev_dbg(&client->dev,
                                "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
                                data_arg.read_write);
                        return -EINVAL;
                }

                /* Note that command values are always valid! */

                if ((data_arg.size == I2C_SMBUS_QUICK) ||
                    ((data_arg.size == I2C_SMBUS_BYTE) &&
                    (data_arg.read_write == I2C_SMBUS_WRITE)))
                        /* These are special: we do not use data */
                        return i2c_smbus_xfer(client->adapter, client->addr,
                                              client->flags,
                                              data_arg.read_write,
                                              data_arg.command,
                                              data_arg.size, NULL);

                if (data_arg.data == NULL) {
                        dev_dbg(&client->dev,
                                "data is NULL pointer in ioctl I2C_SMBUS.\n");
                        return -EINVAL;
                }

                if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
                    (data_arg.size == I2C_SMBUS_BYTE))
                        datasize = sizeof(data_arg.data->byte);
                else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||
                         (data_arg.size == I2C_SMBUS_PROC_CALL))
                        datasize = sizeof(data_arg.data->word);
                else /* size == smbus block, i2c block, or block proc. call */
                        datasize = sizeof(data_arg.data->block);

                if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
                    (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
                    (data_arg.read_write == I2C_SMBUS_WRITE)) {
                        if (copy_from_user(&temp, data_arg.data, datasize))
                                return -EFAULT;
                }
                res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,
                      data_arg.read_write,
                      data_arg.command,data_arg.size,&temp);
                if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
                              (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
                              (data_arg.read_write == I2C_SMBUS_READ))) {
                        if (copy_to_user(data_arg.data, &temp, datasize))
                                return -EFAULT;
                }
                return res;

        default:
                return i2c_control(client,cmd,arg);
        }
        return 0;
}

static int i2cdev_open(struct inode *inode, struct file *file)
{
        unsigned int minor = iminor(inode);
        struct i2c_client *client;
        struct i2c_adapter *adap;
        struct i2c_dev *i2c_dev;

        i2c_dev = i2c_dev_get_by_minor(minor);
        if (!i2c_dev)
                return -ENODEV;

        adap = i2c_get_adapter(i2c_dev->adap->nr);
        if (!adap)
                return -ENODEV;

        client = kmalloc(sizeof(*client), GFP_KERNEL);
        if (!client) {
                i2c_put_adapter(adap);
                return -ENOMEM;
        }
        memcpy(client, &i2cdev_client_template, sizeof(*client));

        /* registered with adapter, passed as client to user */
        client->adapter = adap;
        file->private_data = client;

        return 0;
}

static int i2cdev_release(struct inode *inode, struct file *file)
{
        struct i2c_client *client = file->private_data;

        i2c_put_adapter(client->adapter);
        kfree(client);
        file->private_data = NULL;

        return 0;
}

static struct file_operations i2cdev_fops = {
        .owner          = THIS_MODULE,
        .llseek         = NULL,//no_llseek,
        .read           = i2cdev_read,
        .write          = i2cdev_write,
        .ioctl          = i2cdev_ioctl,
        .open           = i2cdev_open,
        .release        = i2cdev_release,
};

static void release_i2c_dev(struct class_device *dev)
{
        struct i2c_dev *i2c_dev = to_i2c_dev(dev);
        complete(&i2c_dev->released);
}

static struct class i2c_dev_class = {
        .name           = "i2c-dev",
        .release        = &release_i2c_dev,
};

static int i2cdev_attach_adapter(struct i2c_adapter *adap)
{
        struct i2c_dev *i2c_dev;
        int retval;

        i2c_dev = get_free_i2c_dev();
        if (IS_ERR(i2c_dev))
                return PTR_ERR(i2c_dev);

        devfs_mk_cdev(MKDEV(I2C_MAJOR, i2c_dev->minor),
                        S_IFCHR|S_IRUSR|S_IWUSR, "i2c/%d", i2c_dev->minor);
        dev_dbg(&adap->dev, "Registered as minor %d\n", i2c_dev->minor);

        /* register this i2c device with the driver core */
        i2c_dev->adap = adap;
        if (adap->dev.parent == &legacy_bus)
                i2c_dev->class_dev.dev = &adap->dev;
        else
                i2c_dev->class_dev.dev = adap->dev.parent;
        i2c_dev->class_dev.class = &i2c_dev_class;
        snprintf26(i2c_dev->class_dev.class_id, BUS_ID_SIZE, "i2c-%d", i2c_dev->minor);
        retval = class_device_register(&i2c_dev->class_dev);
        if (retval)
                goto error;
        class_device_create_file(&i2c_dev->class_dev, &class_device_attr_dev);
        return 0;
error:
        return_i2c_dev(i2c_dev);
        kfree(i2c_dev);
        return retval;
}

static int i2cdev_detach_adapter(struct i2c_adapter *adap)
{
        struct i2c_dev *i2c_dev;

        i2c_dev = i2c_dev_get_by_adapter(adap);
        if (!i2c_dev)
                return -ENODEV;

        init_completion(&i2c_dev->released);
        devfs_remove("i2c/%d", i2c_dev->minor);
        return_i2c_dev(i2c_dev);
        class_device_unregister(&i2c_dev->class_dev);
        wait_for_completion(&i2c_dev->released);
        kfree(i2c_dev);

        dev_dbg(&adap->dev, "Adapter unregistered\n");
        return 0;
}

static int i2cdev_detach_client(struct i2c_client *client)
{
        return 0;
}

static int i2cdev_command(struct i2c_client *client, unsigned int cmd,
                           void *arg)
{
        return -1;
}

static struct i2c_driver i2cdev_driver = {
        .owner          = THIS_MODULE,
        .name           = "dev_driver",
        .id             = I2C_DRIVERID_I2CDEV,
        .flags          = I2C_DF_NOTIFY,
        .attach_adapter = i2cdev_attach_adapter,
        .detach_adapter = i2cdev_detach_adapter,
        .detach_client  = i2cdev_detach_client,
        .command        = i2cdev_command,
};

static struct i2c_client i2cdev_client_template = {
        .name           = "I2C /dev entry",
        .id             = 1,
        .addr           = -1,
        .driver         = &i2cdev_driver,
};

int __init i2c_dev_init(void)
{
        int res;

        printk(KERN_INFO "i2c /dev entries driver\n");

        if (register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops)) {
                printk(KERN_ERR "i2c-dev.o: unable to get major %d for i2c bus\n",
                       I2C_MAJOR);
                return -EIO;
        }
        devfs_mk_dir("i2c");
        class_register(&i2c_dev_class);
        if ((res = i2c_add_driver(&i2cdev_driver))) {
                printk(KERN_ERR "i2c-dev.o: Driver registration failed, module not inserted.\n");
                devfs_remove("i2c");
                unregister_chrdev(I2C_MAJOR,"i2c");
                return res;
        }
        return 0;
}

static void __exit i2c_dev_exit(void)
{
        i2c_del_driver(&i2cdev_driver);
        class_unregister(&i2c_dev_class);
        devfs_remove("i2c");
        unregister_chrdev(I2C_MAJOR,"i2c");
}

MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
                "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
MODULE_DESCRIPTION("I2C /dev entries driver");
MODULE_LICENSE("GPL");

module_init(i2c_dev_init);
module_exit(i2c_dev_exit);