xref: /openbmc/linux/drivers/i2c/i2c-dev.c (revision abfbd895)
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_rdwr(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_RDWR_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 		if ((arg > 0x3ff) ||
425 		    (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
426 			return -EINVAL;
427 		if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
428 			return -EBUSY;
429 		/* REVISIT: address could become busy later */
430 		client->addr = arg;
431 		return 0;
432 	case I2C_TENBIT:
433 		if (arg)
434 			client->flags |= I2C_M_TEN;
435 		else
436 			client->flags &= ~I2C_M_TEN;
437 		return 0;
438 	case I2C_PEC:
439 		/*
440 		 * Setting the PEC flag here won't affect kernel drivers,
441 		 * which will be using the i2c_client node registered with
442 		 * the driver model core.  Likewise, when that client has
443 		 * the PEC flag already set, the i2c-dev driver won't see
444 		 * (or use) this setting.
445 		 */
446 		if (arg)
447 			client->flags |= I2C_CLIENT_PEC;
448 		else
449 			client->flags &= ~I2C_CLIENT_PEC;
450 		return 0;
451 	case I2C_FUNCS:
452 		funcs = i2c_get_functionality(client->adapter);
453 		return put_user(funcs, (unsigned long __user *)arg);
454 
455 	case I2C_RDWR:
456 		return i2cdev_ioctl_rdwr(client, arg);
457 
458 	case I2C_SMBUS:
459 		return i2cdev_ioctl_smbus(client, arg);
460 
461 	case I2C_RETRIES:
462 		client->adapter->retries = arg;
463 		break;
464 	case I2C_TIMEOUT:
465 		/* For historical reasons, user-space sets the timeout
466 		 * value in units of 10 ms.
467 		 */
468 		client->adapter->timeout = msecs_to_jiffies(arg * 10);
469 		break;
470 	default:
471 		/* NOTE:  returning a fault code here could cause trouble
472 		 * in buggy userspace code.  Some old kernel bugs returned
473 		 * zero in this case, and userspace code might accidentally
474 		 * have depended on that bug.
475 		 */
476 		return -ENOTTY;
477 	}
478 	return 0;
479 }
480 
481 static int i2cdev_open(struct inode *inode, struct file *file)
482 {
483 	unsigned int minor = iminor(inode);
484 	struct i2c_client *client;
485 	struct i2c_adapter *adap;
486 	struct i2c_dev *i2c_dev;
487 
488 	i2c_dev = i2c_dev_get_by_minor(minor);
489 	if (!i2c_dev)
490 		return -ENODEV;
491 
492 	adap = i2c_get_adapter(i2c_dev->adap->nr);
493 	if (!adap)
494 		return -ENODEV;
495 
496 	/* This creates an anonymous i2c_client, which may later be
497 	 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
498 	 *
499 	 * This client is ** NEVER REGISTERED ** with the driver model
500 	 * or I2C core code!!  It just holds private copies of addressing
501 	 * information and maybe a PEC flag.
502 	 */
503 	client = kzalloc(sizeof(*client), GFP_KERNEL);
504 	if (!client) {
505 		i2c_put_adapter(adap);
506 		return -ENOMEM;
507 	}
508 	snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
509 
510 	client->adapter = adap;
511 	file->private_data = client;
512 
513 	return 0;
514 }
515 
516 static int i2cdev_release(struct inode *inode, struct file *file)
517 {
518 	struct i2c_client *client = file->private_data;
519 
520 	i2c_put_adapter(client->adapter);
521 	kfree(client);
522 	file->private_data = NULL;
523 
524 	return 0;
525 }
526 
527 static const struct file_operations i2cdev_fops = {
528 	.owner		= THIS_MODULE,
529 	.llseek		= no_llseek,
530 	.read		= i2cdev_read,
531 	.write		= i2cdev_write,
532 	.unlocked_ioctl	= i2cdev_ioctl,
533 	.open		= i2cdev_open,
534 	.release	= i2cdev_release,
535 };
536 
537 /* ------------------------------------------------------------------------- */
538 
539 static struct class *i2c_dev_class;
540 
541 static int i2cdev_attach_adapter(struct device *dev, void *dummy)
542 {
543 	struct i2c_adapter *adap;
544 	struct i2c_dev *i2c_dev;
545 	int res;
546 
547 	if (dev->type != &i2c_adapter_type)
548 		return 0;
549 	adap = to_i2c_adapter(dev);
550 
551 	i2c_dev = get_free_i2c_dev(adap);
552 	if (IS_ERR(i2c_dev))
553 		return PTR_ERR(i2c_dev);
554 
555 	/* register this i2c device with the driver core */
556 	i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,
557 				     MKDEV(I2C_MAJOR, adap->nr), NULL,
558 				     "i2c-%d", adap->nr);
559 	if (IS_ERR(i2c_dev->dev)) {
560 		res = PTR_ERR(i2c_dev->dev);
561 		goto error;
562 	}
563 
564 	pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
565 		 adap->name, adap->nr);
566 	return 0;
567 error:
568 	return_i2c_dev(i2c_dev);
569 	return res;
570 }
571 
572 static int i2cdev_detach_adapter(struct device *dev, void *dummy)
573 {
574 	struct i2c_adapter *adap;
575 	struct i2c_dev *i2c_dev;
576 
577 	if (dev->type != &i2c_adapter_type)
578 		return 0;
579 	adap = to_i2c_adapter(dev);
580 
581 	i2c_dev = i2c_dev_get_by_minor(adap->nr);
582 	if (!i2c_dev) /* attach_adapter must have failed */
583 		return 0;
584 
585 	return_i2c_dev(i2c_dev);
586 	device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
587 
588 	pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
589 	return 0;
590 }
591 
592 static int i2cdev_notifier_call(struct notifier_block *nb, unsigned long action,
593 			 void *data)
594 {
595 	struct device *dev = data;
596 
597 	switch (action) {
598 	case BUS_NOTIFY_ADD_DEVICE:
599 		return i2cdev_attach_adapter(dev, NULL);
600 	case BUS_NOTIFY_DEL_DEVICE:
601 		return i2cdev_detach_adapter(dev, NULL);
602 	}
603 
604 	return 0;
605 }
606 
607 static struct notifier_block i2cdev_notifier = {
608 	.notifier_call = i2cdev_notifier_call,
609 };
610 
611 /* ------------------------------------------------------------------------- */
612 
613 /*
614  * module load/unload record keeping
615  */
616 
617 static int __init i2c_dev_init(void)
618 {
619 	int res;
620 
621 	printk(KERN_INFO "i2c /dev entries driver\n");
622 
623 	res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
624 	if (res)
625 		goto out;
626 
627 	i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
628 	if (IS_ERR(i2c_dev_class)) {
629 		res = PTR_ERR(i2c_dev_class);
630 		goto out_unreg_chrdev;
631 	}
632 	i2c_dev_class->dev_groups = i2c_groups;
633 
634 	/* Keep track of adapters which will be added or removed later */
635 	res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);
636 	if (res)
637 		goto out_unreg_class;
638 
639 	/* Bind to already existing adapters right away */
640 	i2c_for_each_dev(NULL, i2cdev_attach_adapter);
641 
642 	return 0;
643 
644 out_unreg_class:
645 	class_destroy(i2c_dev_class);
646 out_unreg_chrdev:
647 	unregister_chrdev(I2C_MAJOR, "i2c");
648 out:
649 	printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
650 	return res;
651 }
652 
653 static void __exit i2c_dev_exit(void)
654 {
655 	bus_unregister_notifier(&i2c_bus_type, &i2cdev_notifier);
656 	i2c_for_each_dev(NULL, i2cdev_detach_adapter);
657 	class_destroy(i2c_dev_class);
658 	unregister_chrdev(I2C_MAJOR, "i2c");
659 }
660 
661 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
662 		"Simon G. Vogl <simon@tk.uni-linz.ac.at>");
663 MODULE_DESCRIPTION("I2C /dev entries driver");
664 MODULE_LICENSE("GPL");
665 
666 module_init(i2c_dev_init);
667 module_exit(i2c_dev_exit);
668