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