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 Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com> 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21*/ 22 23/* Note that this is a complete rewrite of Simon Vogl's i2c-dev module. 24 But I have used so much of his original code and ideas that it seems 25 only fair to recognize him as co-author -- Frodo */ 26 27/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */ 28 29#include <linux/kernel.h> 30#include <linux/module.h> 31#include <linux/fs.h> 32#include <linux/slab.h> 33#include <linux/init.h> 34#include <linux/list.h> 35#include <linux/i2c.h> 36#include <linux/i2c-dev.h> 37#include <linux/jiffies.h> 38#include <linux/uaccess.h> 39 40static struct i2c_driver i2cdev_driver; 41 42/* 43 * An i2c_dev represents an i2c_adapter ... an I2C or SMBus master, not a 44 * slave (i2c_client) with which messages will be exchanged. It's coupled 45 * with a character special file which is accessed by user mode drivers. 46 * 47 * The list of i2c_dev structures is parallel to the i2c_adapter lists 48 * maintained by the driver model, and is updated using notifications 49 * delivered to the i2cdev_driver. 50 */ 51struct i2c_dev { 52 struct list_head list; 53 struct i2c_adapter *adap; 54 struct device *dev; 55}; 56 57#define I2C_MINORS 256 58static LIST_HEAD(i2c_dev_list); 59static DEFINE_SPINLOCK(i2c_dev_list_lock); 60 61static struct i2c_dev *i2c_dev_get_by_minor(unsigned index) 62{ 63 struct i2c_dev *i2c_dev; 64 65 spin_lock(&i2c_dev_list_lock); 66 list_for_each_entry(i2c_dev, &i2c_dev_list, list) { 67 if (i2c_dev->adap->nr == index) 68 goto found; 69 } 70 i2c_dev = NULL; 71found: 72 spin_unlock(&i2c_dev_list_lock); 73 return i2c_dev; 74} 75 76static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap) 77{ 78 struct i2c_dev *i2c_dev; 79 80 if (adap->nr >= I2C_MINORS) { 81 printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n", 82 adap->nr); 83 return ERR_PTR(-ENODEV); 84 } 85 86 i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL); 87 if (!i2c_dev) 88 return ERR_PTR(-ENOMEM); 89 i2c_dev->adap = adap; 90 91 spin_lock(&i2c_dev_list_lock); 92 list_add_tail(&i2c_dev->list, &i2c_dev_list); 93 spin_unlock(&i2c_dev_list_lock); 94 return i2c_dev; 95} 96 97static void return_i2c_dev(struct i2c_dev *i2c_dev) 98{ 99 spin_lock(&i2c_dev_list_lock); 100 list_del(&i2c_dev->list); 101 spin_unlock(&i2c_dev_list_lock); 102 kfree(i2c_dev); 103} 104 105static ssize_t show_adapter_name(struct device *dev, 106 struct device_attribute *attr, char *buf) 107{ 108 struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(dev->devt)); 109 110 if (!i2c_dev) 111 return -ENODEV; 112 return sprintf(buf, "%s\n", i2c_dev->adap->name); 113} 114static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL); 115 116/* ------------------------------------------------------------------------- */ 117 118/* 119 * After opening an instance of this character special file, a file 120 * descriptor starts out associated only with an i2c_adapter (and bus). 121 * 122 * Using the I2C_RDWR ioctl(), you can then *immediately* issue i2c_msg 123 * traffic to any devices on the bus used by that adapter. That's because 124 * the i2c_msg vectors embed all the addressing information they need, and 125 * are submitted directly to an i2c_adapter. However, SMBus-only adapters 126 * don't support that interface. 127 * 128 * To use read()/write() system calls on that file descriptor, or to use 129 * SMBus interfaces (and work with SMBus-only hosts!), you must first issue 130 * an I2C_SLAVE (or I2C_SLAVE_FORCE) ioctl. That configures an anonymous 131 * (never registered) i2c_client so it holds the addressing information 132 * needed by those system calls and by this SMBus interface. 133 */ 134 135static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count, 136 loff_t *offset) 137{ 138 char *tmp; 139 int ret; 140 141 struct i2c_client *client = file->private_data; 142 143 if (count > 8192) 144 count = 8192; 145 146 tmp = kmalloc(count, GFP_KERNEL); 147 if (tmp == NULL) 148 return -ENOMEM; 149 150 pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n", 151 iminor(file->f_path.dentry->d_inode), count); 152 153 ret = i2c_master_recv(client, tmp, count); 154 if (ret >= 0) 155 ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret; 156 kfree(tmp); 157 return ret; 158} 159 160static ssize_t i2cdev_write(struct file *file, const char __user *buf, 161 size_t count, loff_t *offset) 162{ 163 int ret; 164 char *tmp; 165 struct i2c_client *client = file->private_data; 166 167 if (count > 8192) 168 count = 8192; 169 170 tmp = memdup_user(buf, count); 171 if (IS_ERR(tmp)) 172 return PTR_ERR(tmp); 173 174 pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n", 175 iminor(file->f_path.dentry->d_inode), count); 176 177 ret = i2c_master_send(client, tmp, count); 178 kfree(tmp); 179 return ret; 180} 181 182static int i2cdev_check(struct device *dev, void *addrp) 183{ 184 struct i2c_client *client = i2c_verify_client(dev); 185 186 if (!client || client->addr != *(unsigned int *)addrp) 187 return 0; 188 189 return dev->driver ? -EBUSY : 0; 190} 191 192/* walk up mux tree */ 193static int i2cdev_check_mux_parents(struct i2c_adapter *adapter, int addr) 194{ 195 int result; 196 197 result = device_for_each_child(&adapter->dev, &addr, i2cdev_check); 198 199 if (!result && i2c_parent_is_i2c_adapter(adapter)) 200 result = i2cdev_check_mux_parents( 201 to_i2c_adapter(adapter->dev.parent), addr); 202 203 return result; 204} 205 206/* recurse down mux tree */ 207static int i2cdev_check_mux_children(struct device *dev, void *addrp) 208{ 209 int result; 210 211 if (dev->type == &i2c_adapter_type) 212 result = device_for_each_child(dev, addrp, 213 i2cdev_check_mux_children); 214 else 215 result = i2cdev_check(dev, addrp); 216 217 return result; 218} 219 220/* This address checking function differs from the one in i2c-core 221 in that it considers an address with a registered device, but no 222 driver bound to it, as NOT busy. */ 223static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr) 224{ 225 int result = 0; 226 227 if (i2c_parent_is_i2c_adapter(adapter)) 228 result = i2cdev_check_mux_parents( 229 to_i2c_adapter(adapter->dev.parent), addr); 230 231 if (!result) 232 result = device_for_each_child(&adapter->dev, &addr, 233 i2cdev_check_mux_children); 234 235 return result; 236} 237 238static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client, 239 unsigned long arg) 240{ 241 struct i2c_rdwr_ioctl_data rdwr_arg; 242 struct i2c_msg *rdwr_pa; 243 u8 __user **data_ptrs; 244 int i, res; 245 246 if (copy_from_user(&rdwr_arg, 247 (struct i2c_rdwr_ioctl_data __user *)arg, 248 sizeof(rdwr_arg))) 249 return -EFAULT; 250 251 /* Put an arbitrary limit on the number of messages that can 252 * be sent at once */ 253 if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS) 254 return -EINVAL; 255 256 rdwr_pa = kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), GFP_KERNEL); 257 if (!rdwr_pa) 258 return -ENOMEM; 259 260 if (copy_from_user(rdwr_pa, rdwr_arg.msgs, 261 rdwr_arg.nmsgs * sizeof(struct i2c_msg))) { 262 kfree(rdwr_pa); 263 return -EFAULT; 264 } 265 266 data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL); 267 if (data_ptrs == NULL) { 268 kfree(rdwr_pa); 269 return -ENOMEM; 270 } 271 272 res = 0; 273 for (i = 0; i < rdwr_arg.nmsgs; i++) { 274 /* Limit the size of the message to a sane amount; 275 * and don't let length change either. */ 276 if ((rdwr_pa[i].len > 8192) || 277 (rdwr_pa[i].flags & I2C_M_RECV_LEN)) { 278 res = -EINVAL; 279 break; 280 } 281 data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf; 282 rdwr_pa[i].buf = memdup_user(data_ptrs[i], rdwr_pa[i].len); 283 if (IS_ERR(rdwr_pa[i].buf)) { 284 res = PTR_ERR(rdwr_pa[i].buf); 285 break; 286 } 287 } 288 if (res < 0) { 289 int j; 290 for (j = 0; j < i; ++j) 291 kfree(rdwr_pa[j].buf); 292 kfree(data_ptrs); 293 kfree(rdwr_pa); 294 return res; 295 } 296 297 res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs); 298 while (i-- > 0) { 299 if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) { 300 if (copy_to_user(data_ptrs[i], rdwr_pa[i].buf, 301 rdwr_pa[i].len)) 302 res = -EFAULT; 303 } 304 kfree(rdwr_pa[i].buf); 305 } 306 kfree(data_ptrs); 307 kfree(rdwr_pa); 308 return res; 309} 310 311static noinline int i2cdev_ioctl_smbus(struct i2c_client *client, 312 unsigned long arg) 313{ 314 struct i2c_smbus_ioctl_data data_arg; 315 union i2c_smbus_data temp; 316 int datasize, res; 317 318 if (copy_from_user(&data_arg, 319 (struct i2c_smbus_ioctl_data __user *) arg, 320 sizeof(struct i2c_smbus_ioctl_data))) 321 return -EFAULT; 322 if ((data_arg.size != I2C_SMBUS_BYTE) && 323 (data_arg.size != I2C_SMBUS_QUICK) && 324 (data_arg.size != I2C_SMBUS_BYTE_DATA) && 325 (data_arg.size != I2C_SMBUS_WORD_DATA) && 326 (data_arg.size != I2C_SMBUS_PROC_CALL) && 327 (data_arg.size != I2C_SMBUS_BLOCK_DATA) && 328 (data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) && 329 (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) && 330 (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) { 331 dev_dbg(&client->adapter->dev, 332 "size out of range (%x) in ioctl I2C_SMBUS.\n", 333 data_arg.size); 334 return -EINVAL; 335 } 336 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1, 337 so the check is valid if size==I2C_SMBUS_QUICK too. */ 338 if ((data_arg.read_write != I2C_SMBUS_READ) && 339 (data_arg.read_write != I2C_SMBUS_WRITE)) { 340 dev_dbg(&client->adapter->dev, 341 "read_write out of range (%x) in ioctl I2C_SMBUS.\n", 342 data_arg.read_write); 343 return -EINVAL; 344 } 345 346 /* Note that command values are always valid! */ 347 348 if ((data_arg.size == I2C_SMBUS_QUICK) || 349 ((data_arg.size == I2C_SMBUS_BYTE) && 350 (data_arg.read_write == I2C_SMBUS_WRITE))) 351 /* These are special: we do not use data */ 352 return i2c_smbus_xfer(client->adapter, client->addr, 353 client->flags, data_arg.read_write, 354 data_arg.command, data_arg.size, NULL); 355 356 if (data_arg.data == NULL) { 357 dev_dbg(&client->adapter->dev, 358 "data is NULL pointer in ioctl I2C_SMBUS.\n"); 359 return -EINVAL; 360 } 361 362 if ((data_arg.size == I2C_SMBUS_BYTE_DATA) || 363 (data_arg.size == I2C_SMBUS_BYTE)) 364 datasize = sizeof(data_arg.data->byte); 365 else if ((data_arg.size == I2C_SMBUS_WORD_DATA) || 366 (data_arg.size == I2C_SMBUS_PROC_CALL)) 367 datasize = sizeof(data_arg.data->word); 368 else /* size == smbus block, i2c block, or block proc. call */ 369 datasize = sizeof(data_arg.data->block); 370 371 if ((data_arg.size == I2C_SMBUS_PROC_CALL) || 372 (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || 373 (data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) || 374 (data_arg.read_write == I2C_SMBUS_WRITE)) { 375 if (copy_from_user(&temp, data_arg.data, datasize)) 376 return -EFAULT; 377 } 378 if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) { 379 /* Convert old I2C block commands to the new 380 convention. This preserves binary compatibility. */ 381 data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA; 382 if (data_arg.read_write == I2C_SMBUS_READ) 383 temp.block[0] = I2C_SMBUS_BLOCK_MAX; 384 } 385 res = i2c_smbus_xfer(client->adapter, client->addr, client->flags, 386 data_arg.read_write, data_arg.command, data_arg.size, &temp); 387 if (!res && ((data_arg.size == I2C_SMBUS_PROC_CALL) || 388 (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || 389 (data_arg.read_write == I2C_SMBUS_READ))) { 390 if (copy_to_user(data_arg.data, &temp, datasize)) 391 return -EFAULT; 392 } 393 return res; 394} 395 396static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 397{ 398 struct i2c_client *client = file->private_data; 399 unsigned long funcs; 400 401 dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n", 402 cmd, arg); 403 404 switch (cmd) { 405 case I2C_SLAVE: 406 case I2C_SLAVE_FORCE: 407 /* NOTE: devices set up to work with "new style" drivers 408 * can't use I2C_SLAVE, even when the device node is not 409 * bound to a driver. Only I2C_SLAVE_FORCE will work. 410 * 411 * Setting the PEC flag here won't affect kernel drivers, 412 * which will be using the i2c_client node registered with 413 * the driver model core. Likewise, when that client has 414 * the PEC flag already set, the i2c-dev driver won't see 415 * (or use) this setting. 416 */ 417 if ((arg > 0x3ff) || 418 (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f)) 419 return -EINVAL; 420 if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg)) 421 return -EBUSY; 422 /* REVISIT: address could become busy later */ 423 client->addr = arg; 424 return 0; 425 case I2C_TENBIT: 426 if (arg) 427 client->flags |= I2C_M_TEN; 428 else 429 client->flags &= ~I2C_M_TEN; 430 return 0; 431 case I2C_PEC: 432 if (arg) 433 client->flags |= I2C_CLIENT_PEC; 434 else 435 client->flags &= ~I2C_CLIENT_PEC; 436 return 0; 437 case I2C_FUNCS: 438 funcs = i2c_get_functionality(client->adapter); 439 return put_user(funcs, (unsigned long __user *)arg); 440 441 case I2C_RDWR: 442 return i2cdev_ioctl_rdrw(client, arg); 443 444 case I2C_SMBUS: 445 return i2cdev_ioctl_smbus(client, arg); 446 447 case I2C_RETRIES: 448 client->adapter->retries = arg; 449 break; 450 case I2C_TIMEOUT: 451 /* For historical reasons, user-space sets the timeout 452 * value in units of 10 ms. 453 */ 454 client->adapter->timeout = msecs_to_jiffies(arg * 10); 455 break; 456 default: 457 /* NOTE: returning a fault code here could cause trouble 458 * in buggy userspace code. Some old kernel bugs returned 459 * zero in this case, and userspace code might accidentally 460 * have depended on that bug. 461 */ 462 return -ENOTTY; 463 } 464 return 0; 465} 466 467static int i2cdev_open(struct inode *inode, struct file *file) 468{ 469 unsigned int minor = iminor(inode); 470 struct i2c_client *client; 471 struct i2c_adapter *adap; 472 struct i2c_dev *i2c_dev; 473 474 i2c_dev = i2c_dev_get_by_minor(minor); 475 if (!i2c_dev) 476 return -ENODEV; 477 478 adap = i2c_get_adapter(i2c_dev->adap->nr); 479 if (!adap) 480 return -ENODEV; 481 482 /* This creates an anonymous i2c_client, which may later be 483 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE. 484 * 485 * This client is ** NEVER REGISTERED ** with the driver model 486 * or I2C core code!! It just holds private copies of addressing 487 * information and maybe a PEC flag. 488 */ 489 client = kzalloc(sizeof(*client), GFP_KERNEL); 490 if (!client) { 491 i2c_put_adapter(adap); 492 return -ENOMEM; 493 } 494 snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr); 495 client->driver = &i2cdev_driver; 496 497 client->adapter = adap; 498 file->private_data = client; 499 500 return 0; 501} 502 503static int i2cdev_release(struct inode *inode, struct file *file) 504{ 505 struct i2c_client *client = file->private_data; 506 507 i2c_put_adapter(client->adapter); 508 kfree(client); 509 file->private_data = NULL; 510 511 return 0; 512} 513 514static const struct file_operations i2cdev_fops = { 515 .owner = THIS_MODULE, 516 .llseek = no_llseek, 517 .read = i2cdev_read, 518 .write = i2cdev_write, 519 .unlocked_ioctl = i2cdev_ioctl, 520 .open = i2cdev_open, 521 .release = i2cdev_release, 522}; 523 524/* ------------------------------------------------------------------------- */ 525 526/* 527 * The legacy "i2cdev_driver" is used primarily to get notifications when 528 * I2C adapters are added or removed, so that each one gets an i2c_dev 529 * and is thus made available to userspace driver code. 530 */ 531 532static struct class *i2c_dev_class; 533 534static int i2cdev_attach_adapter(struct i2c_adapter *adap) 535{ 536 struct i2c_dev *i2c_dev; 537 int res; 538 539 i2c_dev = get_free_i2c_dev(adap); 540 if (IS_ERR(i2c_dev)) 541 return PTR_ERR(i2c_dev); 542 543 /* register this i2c device with the driver core */ 544 i2c_dev->dev = device_create(i2c_dev_class, &adap->dev, 545 MKDEV(I2C_MAJOR, adap->nr), NULL, 546 "i2c-%d", adap->nr); 547 if (IS_ERR(i2c_dev->dev)) { 548 res = PTR_ERR(i2c_dev->dev); 549 goto error; 550 } 551 res = device_create_file(i2c_dev->dev, &dev_attr_name); 552 if (res) 553 goto error_destroy; 554 555 pr_debug("i2c-dev: adapter [%s] registered as minor %d\n", 556 adap->name, adap->nr); 557 return 0; 558error_destroy: 559 device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr)); 560error: 561 return_i2c_dev(i2c_dev); 562 return res; 563} 564 565static int i2cdev_detach_adapter(struct i2c_adapter *adap) 566{ 567 struct i2c_dev *i2c_dev; 568 569 i2c_dev = i2c_dev_get_by_minor(adap->nr); 570 if (!i2c_dev) /* attach_adapter must have failed */ 571 return 0; 572 573 device_remove_file(i2c_dev->dev, &dev_attr_name); 574 return_i2c_dev(i2c_dev); 575 device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr)); 576 577 pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name); 578 return 0; 579} 580 581static struct i2c_driver i2cdev_driver = { 582 .driver = { 583 .name = "dev_driver", 584 }, 585 .attach_adapter = i2cdev_attach_adapter, 586 .detach_adapter = i2cdev_detach_adapter, 587}; 588 589/* ------------------------------------------------------------------------- */ 590 591/* 592 * module load/unload record keeping 593 */ 594 595static int __init i2c_dev_init(void) 596{ 597 int res; 598 599 printk(KERN_INFO "i2c /dev entries driver\n"); 600 601 res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops); 602 if (res) 603 goto out; 604 605 i2c_dev_class = class_create(THIS_MODULE, "i2c-dev"); 606 if (IS_ERR(i2c_dev_class)) { 607 res = PTR_ERR(i2c_dev_class); 608 goto out_unreg_chrdev; 609 } 610 611 res = i2c_add_driver(&i2cdev_driver); 612 if (res) 613 goto out_unreg_class; 614 615 return 0; 616 617out_unreg_class: 618 class_destroy(i2c_dev_class); 619out_unreg_chrdev: 620 unregister_chrdev(I2C_MAJOR, "i2c"); 621out: 622 printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__); 623 return res; 624} 625 626static void __exit i2c_dev_exit(void) 627{ 628 i2c_del_driver(&i2cdev_driver); 629 class_destroy(i2c_dev_class); 630 unregister_chrdev(I2C_MAJOR, "i2c"); 631} 632 633MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and " 634 "Simon G. Vogl <simon@tk.uni-linz.ac.at>"); 635MODULE_DESCRIPTION("I2C /dev entries driver"); 636MODULE_LICENSE("GPL"); 637 638module_init(i2c_dev_init); 639module_exit(i2c_dev_exit); 640