i2c-dev: Split i2cdev_ioctl

Split the handling of the I2C_RDWR and I2C_SMBUS ioctls to their own
functions. This limits the stack usage, saves one level of indentation
and makes the code more readable.

Signed-off-by: Jean Delvare <khali@linux-fr.org>

diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index 393e679d9faac4f1a8351b69376ffc656474871d..d34c14c81c291e9beabf7100530307b8a42e8914 100644 (file)
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -200,16 +200,176 @@ static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
        return device_for_each_child(&adapter->dev, &addr, i2cdev_check);
 }
 
-static int i2cdev_ioctl(struct inode *inode, struct file *file,
-               unsigned int cmd, unsigned long arg)
+static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
+               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 __user **data_ptrs;
-       int i,datasize,res;
+       int i, res;
+
+       if (copy_from_user(&rdwr_arg,
+                          (struct i2c_rdwr_ioctl_data __user *)arg,
+                          sizeof(rdwr_arg)))
+               return -EFAULT;
+
+       /* Put an arbitrary limit on the number of messages that can
+        * be sent at once */
+       if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
+               return -EINVAL;
+
+       rdwr_pa = (struct i2c_msg *)
+               kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
+               GFP_KERNEL);
+       if (!rdwr_pa)
+               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 = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), 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;
+                * and don't let length change either. */
+               if ((rdwr_pa[i].len > 8192) ||
+                   (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
+                       res = -EINVAL;
+                       break;
+               }
+               data_ptrs[i] = (u8 __user *)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;
+}
+
+static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
+               unsigned long arg)
+{
+       struct i2c_smbus_ioctl_data data_arg;
+       union i2c_smbus_data temp;
+       int datasize, res;
+
+       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_BROKEN) &&
+           (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
+           (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
+               dev_dbg(&client->adapter->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->adapter->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->adapter->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.size == I2C_SMBUS_I2C_BLOCK_DATA) ||
+           (data_arg.read_write == I2C_SMBUS_WRITE)) {
+               if (copy_from_user(&temp, data_arg.data, datasize))
+                       return -EFAULT;
+       }
+       if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
+               /* Convert old I2C block commands to the new
+                  convention. This preserves binary compatibility. */
+               data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA;
+               if (data_arg.read_write == I2C_SMBUS_READ)
+                       temp.block[0] = I2C_SMBUS_BLOCK_MAX;
+       }
+       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;
+}
+
+static 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;
        unsigned long funcs;
 
        dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
@@ -253,164 +413,11 @@ static int i2cdev_ioctl(struct inode *inode, struct file *file,
                return put_user(funcs, (unsigned long __user *)arg);
 
        case I2C_RDWR:
-               if (copy_from_user(&rdwr_arg,
-                                  (struct i2c_rdwr_ioctl_data __user *)arg,
-                                  sizeof(rdwr_arg)))
-                       return -EFAULT;
-
-               /* Put an arbitrary limit on the number of messages that can
-                * be sent at once */
-               if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
-                       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 = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), 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;
-                        * and don't let length change either. */
-                       if ((rdwr_pa[i].len > 8192) ||
-                           (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
-                               res = -EINVAL;
-                               break;
-                       }
-                       data_ptrs[i] = (u8 __user *)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;
+               return i2cdev_ioctl_rdrw(client, arg);
 
        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_BROKEN) &&
-                   (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
-                   (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
-                       dev_dbg(&client->adapter->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->adapter->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->adapter->dev,
-                               "data is NULL pointer in ioctl I2C_SMBUS.\n");
-                       return -EINVAL;
-               }
+               return i2cdev_ioctl_smbus(client, arg);
 
-               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.size == I2C_SMBUS_I2C_BLOCK_DATA) ||
-                   (data_arg.read_write == I2C_SMBUS_WRITE)) {
-                       if (copy_from_user(&temp, data_arg.data, datasize))
-                               return -EFAULT;
-               }
-               if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
-                       /* Convert old I2C block commands to the new
-                          convention. This preserves binary compatibility. */
-                       data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA;
-                       if (data_arg.read_write == I2C_SMBUS_READ)
-                               temp.block[0] = I2C_SMBUS_BLOCK_MAX;
-               }
-               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;
        case I2C_RETRIES:
                client->adapter->retries = arg;
                break;