drivers/i2c/i2c-dev.c

   1 /*
   2     i2c-dev.c - i2c-bus driver, char device interface
   3
   4     Copyright (C) 1995-97 Simon G. Vogl
   5     Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 /* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
  23    But I have used so much of his original code and ideas that it seems
  24    only fair to recognize him as co-author -- Frodo */
  25
  26 /* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
  27
  28 /* The devfs code is contributed by Philipp Matthias Hahn
  29    <pmhahn@titan.lahn.de> */
  30
  31 /* $Id: i2c-dev.c,v 1.40 2001/08/25 01:28:01 mds Exp $ */
  32
  33 #include <linux/config.h>
  34 #include <linux/kernel.h>
  35 #include <linux/module.h>
  36 #include <linux/fs.h>
  37 #include <linux/slab.h>
  38 #include <linux/smp_lock.h>
  39 #ifdef CONFIG_DEVFS_FS
  40 #include <linux/devfs_fs_kernel.h>
  41 #endif
  42 #include <linux/init.h>
  43 #include <linux/i2c.h>
  44 #include <linux/i2c-dev.h>
  45 #include <asm/uaccess.h>
  46
  47 /* If you want debugging uncomment: */
  48 /* #define DEBUG */
  49
  50
  51 #ifdef MODULE
  52 extern int init_module(void);
  53 extern int cleanup_module(void);
  54 #endif /* def MODULE */
  55
  56 /* struct file_operations changed too often in the 2.1 series for nice code */
  57
  58 static ssize_t i2cdev_read (struct file *file, char *buf, size_t count,
  59                             loff_t *offset);
  60 static ssize_t i2cdev_write (struct file *file, const char *buf, size_t count,
  61                              loff_t *offset);
  62
  63 static int i2cdev_ioctl (struct inode *inode, struct file *file,
  64                          unsigned int cmd, unsigned long arg);
  65 static int i2cdev_open (struct inode *inode, struct file *file);
  66
  67 static int i2cdev_release (struct inode *inode, struct file *file);
  68
  69 static int i2cdev_attach_adapter(struct i2c_adapter *adap);
  70 static int i2cdev_detach_client(struct i2c_client *client);
  71 static int i2cdev_command(struct i2c_client *client, unsigned int cmd,
  72                            void *arg);
  73
  74 #ifdef MODULE
  75 static
  76 #else
  77 extern
  78 #endif
  79        int __init i2c_dev_init(void);
  80 static int i2cdev_cleanup(void);
  81
  82 static struct file_operations i2cdev_fops = {
  83         .owner          = THIS_MODULE,
  84         .llseek         = no_llseek,
  85         .read           = i2cdev_read,
  86         .write          = i2cdev_write,
  87         .ioctl          = i2cdev_ioctl,
  88         .open           = i2cdev_open,
  89         .release        = i2cdev_release,
  90 };
  91
  92 #define I2CDEV_ADAPS_MAX I2C_ADAP_MAX
  93 static struct i2c_adapter *i2cdev_adaps[I2CDEV_ADAPS_MAX];
  94 #ifdef CONFIG_DEVFS_FS
  95 static devfs_handle_t devfs_i2c[I2CDEV_ADAPS_MAX];
  96 static devfs_handle_t devfs_handle = NULL;
  97 #endif
  98
  99 static struct i2c_driver i2cdev_driver = {
 100         .name           = "i2c-dev dummy driver",
 101         .id             = I2C_DRIVERID_I2CDEV,
 102         .flags          = I2C_DF_DUMMY,
 103         .attach_adapter = i2cdev_attach_adapter,
 104         .detach_client  = i2cdev_detach_client,
 105         .command        = i2cdev_command,
 106 };
 107
 108 static struct i2c_client i2cdev_client_template = {
 109         .name           = "I2C /dev entry",
 110         .id             = 1,
 111         .flags          = 0,
 112         .addr           = -1,
 113         .driver         = &i2cdev_driver,
 114 };
 115
 116 static int i2cdev_initialized;
 117
 118 static ssize_t i2cdev_read (struct file *file, char *buf, size_t count,
 119                             loff_t *offset)
 120 {
 121         char *tmp;
 122         int ret;
 123
 124 #ifdef DEBUG
 125         struct inode *inode = file->f_dentry->d_inode;
 126 #endif /* DEBUG */
 127
 128         struct i2c_client *client = (struct i2c_client *)file->private_data;
 129
 130         if (count > 8192)
 131                 count = 8192;
 132
 133         /* copy user space data to kernel space. */
 134         tmp = kmalloc(count,GFP_KERNEL);
 135         if (tmp==NULL)
 136                 return -ENOMEM;
 137
 138 #ifdef DEBUG
 139         printk(KERN_DEBUG "i2c-dev.o: i2c-%d reading %d bytes.\n",MINOR(inode->i_rdev),
 140                count);
 141 #endif
 142
 143         ret = i2c_master_recv(client,tmp,count);
 144         if (ret >= 0)
 145                 ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
 146         kfree(tmp);
 147         return ret;
 148 }
 149
 150 static ssize_t i2cdev_write (struct file *file, const char *buf, size_t count,
 151                              loff_t *offset)
 152 {
 153         int ret;
 154         char *tmp;
 155         struct i2c_client *client = (struct i2c_client *)file->private_data;
 156
 157 #ifdef DEBUG
 158         struct inode *inode = file->f_dentry->d_inode;
 159 #endif /* DEBUG */
 160
 161         if (count > 8192)
 162                 count = 8192;
 163
 164         /* copy user space data to kernel space. */
 165         tmp = kmalloc(count,GFP_KERNEL);
 166         if (tmp==NULL)
 167                 return -ENOMEM;
 168         if (copy_from_user(tmp,buf,count)) {
 169                 kfree(tmp);
 170                 return -EFAULT;
 171         }
 172
 173 #ifdef DEBUG
 174         printk(KERN_DEBUG "i2c-dev.o: i2c-%d writing %d bytes.\n",MINOR(inode->i_rdev),
 175                count);
 176 #endif
 177         ret = i2c_master_send(client,tmp,count);
 178         kfree(tmp);
 179         return ret;
 180 }
 181
 182 int i2cdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
 183                   unsigned long arg)
 184 {
 185         struct i2c_client *client = (struct i2c_client *)file->private_data;
 186         struct i2c_rdwr_ioctl_data rdwr_arg;
 187         struct i2c_smbus_ioctl_data data_arg;
 188         union i2c_smbus_data temp;
 189         struct i2c_msg *rdwr_pa;
 190         u8 **data_ptrs;
 191         int i,datasize,res;
 192         unsigned long funcs;
 193
 194 #ifdef DEBUG
 195         printk(KERN_DEBUG "i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n",
 196                MINOR(inode->i_rdev),cmd, arg);
 197 #endif /* DEBUG */
 198
 199         switch ( cmd ) {
 200         case I2C_SLAVE:
 201         case I2C_SLAVE_FORCE:
 202                 if ((arg > 0x3ff) ||
 203                     (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
 204                         return -EINVAL;
 205                 if ((cmd == I2C_SLAVE) && i2c_check_addr(client->adapter,arg))
 206                         return -EBUSY;
 207                 client->addr = arg;
 208                 return 0;
 209         case I2C_TENBIT:
 210                 if (arg)
 211                         client->flags |= I2C_M_TEN;
 212                 else
 213                         client->flags &= ~I2C_M_TEN;
 214                 return 0;
 215         case I2C_FUNCS:
 216                 funcs = i2c_get_functionality(client->adapter);
 217                 return (copy_to_user((unsigned long *)arg,&funcs,
 218                                      sizeof(unsigned long)))?-EFAULT:0;
 219
 220         case I2C_RDWR:
 221                 if (copy_from_user(&rdwr_arg,
 222                                    (struct i2c_rdwr_ioctl_data *)arg,
 223                                    sizeof(rdwr_arg)))
 224                         return -EFAULT;
 225
 226                 /* Put an arbitrary limit on the number of messages that can
 227                  * be sent at once */
 228                 if (rdwr_arg.nmsgs > 42)
 229                         return -EINVAL;
 230
 231                 rdwr_pa = (struct i2c_msg *)
 232                         kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
 233                         GFP_KERNEL);
 234
 235                 if (rdwr_pa == NULL) return -ENOMEM;
 236
 237                 if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
 238                                    rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
 239                         kfree(rdwr_pa);
 240                         return -EFAULT;
 241                 }
 242
 243                 data_ptrs = (u8 **) kmalloc(rdwr_arg.nmsgs * sizeof(u8 *),
 244                                             GFP_KERNEL);
 245                 if (data_ptrs == NULL) {
 246                         kfree(rdwr_pa);
 247                         return -ENOMEM;
 248                 }
 249
 250                 res = 0;
 251                 for( i=0; i<rdwr_arg.nmsgs; i++ )
 252                 {
 253                         /* Limit the size of the message to a sane amount */
 254                         if (rdwr_pa[i].len > 8192) {
 255                                 res = -EINVAL;
 256                                 break;
 257                         }
 258                         data_ptrs[i] = rdwr_pa[i].buf;
 259                         rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
 260                         if(rdwr_pa[i].buf == NULL)
 261                         {
 262                                 res = -ENOMEM;
 263                                 break;
 264                         }
 265                         if(copy_from_user(rdwr_pa[i].buf,
 266                                 data_ptrs[i],
 267                                 rdwr_pa[i].len))
 268                         {
 269                                 ++i; /* Needs to be kfreed too */
 270                                 res = -EFAULT;
 271                                 break;
 272                         }
 273                 }
 274                 if (res < 0) {
 275                         int j;
 276                         for (j = 0; j < i; ++j)
 277                                 kfree(rdwr_pa[j].buf);
 278                         kfree(data_ptrs);
 279                         kfree(rdwr_pa);
 280                         return res;
 281                 }
 282
 283                 res = i2c_transfer(client->adapter,
 284                         rdwr_pa,
 285                         rdwr_arg.nmsgs);
 286                 while(i-- > 0)
 287                 {
 288                         if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD))
 289                         {
 290                                 if(copy_to_user(
 291                                         data_ptrs[i],
 292                                         rdwr_pa[i].buf,
 293                                         rdwr_pa[i].len))
 294                                 {
 295                                         res = -EFAULT;
 296                                 }
 297                         }
 298                         kfree(rdwr_pa[i].buf);
 299                 }
 300                 kfree(data_ptrs);
 301                 kfree(rdwr_pa);
 302                 return res;
 303
 304         case I2C_SMBUS:
 305                 if (copy_from_user(&data_arg,
 306                                    (struct i2c_smbus_ioctl_data *) arg,
 307                                    sizeof(struct i2c_smbus_ioctl_data)))
 308                         return -EFAULT;
 309                 if ((data_arg.size != I2C_SMBUS_BYTE) &&
 310                     (data_arg.size != I2C_SMBUS_QUICK) &&
 311                     (data_arg.size != I2C_SMBUS_BYTE_DATA) &&
 312                     (data_arg.size != I2C_SMBUS_WORD_DATA) &&
 313                     (data_arg.size != I2C_SMBUS_PROC_CALL) &&
 314                     (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
 315                     (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA)) {
 316 #ifdef DEBUG
 317                         printk(KERN_DEBUG "i2c-dev.o: size out of range (%x) in ioctl I2C_SMBUS.\n",
 318                                data_arg.size);
 319 #endif
 320                         return -EINVAL;
 321                 }
 322                 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
 323                    so the check is valid if size==I2C_SMBUS_QUICK too. */
 324                 if ((data_arg.read_write != I2C_SMBUS_READ) &&
 325                     (data_arg.read_write != I2C_SMBUS_WRITE)) {
 326 #ifdef DEBUG
 327                         printk(KERN_DEBUG "i2c-dev.o: read_write out of range (%x) in ioctl I2C_SMBUS.\n",
 328                                data_arg.read_write);
 329 #endif
 330                         return -EINVAL;
 331                 }
 332
 333                 /* Note that command values are always valid! */
 334
 335                 if ((data_arg.size == I2C_SMBUS_QUICK) ||
 336                     ((data_arg.size == I2C_SMBUS_BYTE) &&
 337                     (data_arg.read_write == I2C_SMBUS_WRITE)))
 338                         /* These are special: we do not use data */
 339                         return i2c_smbus_xfer(client->adapter, client->addr,
 340                                               client->flags,
 341                                               data_arg.read_write,
 342                                               data_arg.command,
 343                                               data_arg.size, NULL);
 344
 345                 if (data_arg.data == NULL) {
 346 #ifdef DEBUG
 347                         printk(KERN_DEBUG "i2c-dev.o: data is NULL pointer in ioctl I2C_SMBUS.\n");
 348 #endif
 349                         return -EINVAL;
 350                 }
 351
 352                 if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
 353                     (data_arg.size == I2C_SMBUS_BYTE))
 354                         datasize = sizeof(data_arg.data->byte);
 355                 else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||
 356                          (data_arg.size == I2C_SMBUS_PROC_CALL))
 357                         datasize = sizeof(data_arg.data->word);
 358                 else /* size == I2C_SMBUS_BLOCK_DATA */
 359                         datasize = sizeof(data_arg.data->block);
 360
 361                 if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
 362                     (data_arg.read_write == I2C_SMBUS_WRITE)) {
 363                         if (copy_from_user(&temp, data_arg.data, datasize))
 364                                 return -EFAULT;
 365                 }
 366                 res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 367                       data_arg.read_write,
 368                       data_arg.command,data_arg.size,&temp);
 369                 if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
 370                               (data_arg.read_write == I2C_SMBUS_READ))) {
 371                         if (copy_to_user(data_arg.data, &temp, datasize))
 372                                 return -EFAULT;
 373                 }
 374                 return res;
 375
 376         default:
 377                 return i2c_control(client,cmd,arg);
 378         }
 379         return 0;
 380 }
 381
 382 int i2cdev_open (struct inode *inode, struct file *file)
 383 {
 384         unsigned int minor = MINOR(inode->i_rdev);
 385         struct i2c_client *client;
 386
 387         if ((minor >= I2CDEV_ADAPS_MAX) || ! (i2cdev_adaps[minor])) {
 388 #ifdef DEBUG
 389                 printk(KERN_DEBUG "i2c-dev.o: Trying to open unattached adapter i2c-%d\n",
 390                        minor);
 391 #endif
 392                 return -ENODEV;
 393         }
 394
 395         /* Note that we here allocate a client for later use, but we will *not*
 396            register this client! Yes, this is safe. No, it is not very clean. */
 397         if(! (client = kmalloc(sizeof(struct i2c_client),GFP_KERNEL)))
 398                 return -ENOMEM;
 399         memcpy(client,&i2cdev_client_template,sizeof(struct i2c_client));
 400         client->adapter = i2cdev_adaps[minor];
 401         file->private_data = client;
 402
 403         if (i2cdev_adaps[minor]->inc_use)
 404                 i2cdev_adaps[minor]->inc_use(i2cdev_adaps[minor]);
 405
 406 #ifdef DEBUG
 407         printk(KERN_DEBUG "i2c-dev.o: opened i2c-%d\n",minor);
 408 #endif
 409         return 0;
 410 }
 411
 412 static int i2cdev_release (struct inode *inode, struct file *file)
 413 {
 414         unsigned int minor = MINOR(inode->i_rdev);
 415         kfree(file->private_data);
 416         file->private_data=NULL;
 417 #ifdef DEBUG
 418         printk(KERN_DEBUG "i2c-dev.o: Closed: i2c-%d\n", minor);
 419 #endif
 420         lock_kernel();
 421         if (i2cdev_adaps[minor]->dec_use)
 422                 i2cdev_adaps[minor]->dec_use(i2cdev_adaps[minor]);
 423         unlock_kernel();
 424         return 0;
 425 }
 426
 427 int i2cdev_attach_adapter(struct i2c_adapter *adap)
 428 {
 429         int i;
 430         char name[8];
 431
 432         if ((i = i2c_adapter_id(adap)) < 0) {
 433                 printk(KERN_DEBUG "i2c-dev.o: Unknown adapter ?!?\n");
 434                 return -ENODEV;
 435         }
 436         if (i >= I2CDEV_ADAPS_MAX) {
 437                 printk(KERN_DEBUG "i2c-dev.o: Adapter number too large?!? (%d)\n",i);
 438                 return -ENODEV;
 439         }
 440
 441         sprintf (name, "%d", i);
 442         if (! i2cdev_adaps[i]) {
 443                 i2cdev_adaps[i] = adap;
 444 #ifdef CONFIG_DEVFS_FS
 445                 devfs_i2c[i] = devfs_register (devfs_handle, name,
 446                         DEVFS_FL_DEFAULT, I2C_MAJOR, i,
 447                         S_IFCHR | S_IRUSR | S_IWUSR,
 448                         &i2cdev_fops, NULL);
 449 #endif
 450                 printk(KERN_DEBUG "i2c-dev.o: Registered '%s' as minor %d\n",adap->name,i);
 451         } else {
 452                 /* This is actually a detach_adapter call! */
 453 #ifdef CONFIG_DEVFS_FS
 454                 devfs_unregister(devfs_i2c[i]);
 455 #endif
 456                 i2cdev_adaps[i] = NULL;
 457 #ifdef DEBUG
 458                 printk(KERN_DEBUG "i2c-dev.o: Adapter unregistered: %s\n",adap->name);
 459 #endif
 460         }
 461
 462         return 0;
 463 }
 464
 465 int i2cdev_detach_client(struct i2c_client *client)
 466 {
 467         return 0;
 468 }
 469
 470 static int i2cdev_command(struct i2c_client *client, unsigned int cmd,
 471                            void *arg)
 472 {
 473         return -1;
 474 }
 475
 476 int __init i2c_dev_init(void)
 477 {
 478         int res;
 479
 480         printk(KERN_INFO "i2c-dev.o: i2c /dev entries driver module version %s (%s)\n", I2C_VERSION, I2C_DATE);
 481
 482         i2cdev_initialized = 0;
 483 #ifdef CONFIG_DEVFS_FS
 484         if (devfs_register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops)) {
 485 #else
 486         if (register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops)) {
 487 #endif
 488                 printk(KERN_ERR "i2c-dev.o: unable to get major %d for i2c bus\n",
 489                        I2C_MAJOR);
 490                 return -EIO;
 491         }
 492 #ifdef CONFIG_DEVFS_FS
 493         devfs_handle = devfs_mk_dir(NULL, "i2c", NULL);
 494 #endif
 495         i2cdev_initialized ++;
 496
 497         if ((res = i2c_add_driver(&i2cdev_driver))) {
 498                 printk(KERN_ERR "i2c-dev.o: Driver registration failed, module not inserted.\n");
 499                 i2cdev_cleanup();
 500                 return res;
 501         }
 502         i2cdev_initialized ++;
 503         return 0;
 504 }
 505
 506 int i2cdev_cleanup(void)
 507 {
 508         int res;
 509
 510         if (i2cdev_initialized >= 2) {
 511                 if ((res = i2c_del_driver(&i2cdev_driver))) {
 512                         printk("i2c-dev.o: Driver deregistration failed, "
 513                                "module not removed.\n");
 514                         return res;
 515                 }
 516         i2cdev_initialized --;
 517         }
 518
 519         if (i2cdev_initialized >= 1) {
 520 #ifdef CONFIG_DEVFS_FS
 521                 devfs_unregister(devfs_handle);
 522                 if ((res = devfs_unregister_chrdev(I2C_MAJOR, "i2c"))) {
 523 #else
 524                 if ((res = unregister_chrdev(I2C_MAJOR,"i2c"))) {
 525 #endif
 526                         printk("i2c-dev.o: unable to release major %d for i2c bus\n",
 527                                I2C_MAJOR);
 528                         return res;
 529                 }
 530                 i2cdev_initialized --;
 531         }
 532         return 0;
 533 }
 534
 535 EXPORT_NO_SYMBOLS;
 536
 537 #ifdef MODULE
 538
 539 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and Simon G. Vogl <simon@tk.uni-linz.ac.at>");
 540 MODULE_DESCRIPTION("I2C /dev entries driver");
 541 MODULE_LICENSE("GPL");
 542
 543 int init_module(void)
 544 {
 545         return i2c_dev_init();
 546 }
 547
 548 int cleanup_module(void)
 549 {
 550         return i2cdev_cleanup();
 551 }
 552
 553 #endif /* def MODULE */
 554