1 /* i2c-core.c - a device driver for the iic-bus interface */
2 /* ------------------------------------------------------------------------- */
3 /* Copyright (C) 1995-99 Simon G. Vogl
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18 /* ------------------------------------------------------------------------- */
20 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
21 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
22 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
23 Jean Delvare <khali@linux-fr.org> */
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
30 #include <linux/init.h>
31 #include <linux/idr.h>
32 #include <linux/seq_file.h>
33 #include <linux/platform_device.h>
34 #include <linux/mutex.h>
35 #include <linux/completion.h>
36 #include <linux/hardirq.h>
37 #include <linux/irqflags.h>
38 #include <linux/semaphore.h>
39 #include <asm/uaccess.h>
44 static DEFINE_MUTEX(core_lock);
45 static DEFINE_IDR(i2c_adapter_idr);
47 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
49 /* ------------------------------------------------------------------------- */
51 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
52 const struct i2c_client *client)
55 if (strcmp(client->name, id->name) == 0)
62 static int i2c_device_match(struct device *dev, struct device_driver *drv)
64 struct i2c_client *client = to_i2c_client(dev);
65 struct i2c_driver *driver = to_i2c_driver(drv);
67 /* make legacy i2c drivers bypass driver model probing entirely;
68 * such drivers scan each i2c adapter/bus themselves.
70 if (!is_newstyle_driver(driver))
73 /* match on an id table if there is one */
75 return i2c_match_id(driver->id_table, client) != NULL;
77 /* new style drivers use the same kind of driver matching policy
78 * as platform devices or SPI: compare device and driver IDs.
80 return strcmp(client->driver_name, drv->name) == 0;
85 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
86 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
88 struct i2c_client *client = to_i2c_client(dev);
90 /* by definition, legacy drivers can't hotplug */
94 if (client->driver_name[0]) {
95 if (add_uevent_var(env, "MODALIAS=%s", client->driver_name))
98 if (add_uevent_var(env, "MODALIAS=%s%s",
99 I2C_MODULE_PREFIX, client->name))
102 dev_dbg(dev, "uevent\n");
107 #define i2c_device_uevent NULL
108 #endif /* CONFIG_HOTPLUG */
110 static int i2c_device_probe(struct device *dev)
112 struct i2c_client *client = to_i2c_client(dev);
113 struct i2c_driver *driver = to_i2c_driver(dev->driver);
114 const struct i2c_device_id *id;
119 client->driver = driver;
120 dev_dbg(dev, "probe\n");
122 if (driver->id_table)
123 id = i2c_match_id(driver->id_table, client);
126 status = driver->probe(client, id);
128 client->driver = NULL;
132 static int i2c_device_remove(struct device *dev)
134 struct i2c_client *client = to_i2c_client(dev);
135 struct i2c_driver *driver;
141 driver = to_i2c_driver(dev->driver);
142 if (driver->remove) {
143 dev_dbg(dev, "remove\n");
144 status = driver->remove(client);
150 client->driver = NULL;
154 static void i2c_device_shutdown(struct device *dev)
156 struct i2c_driver *driver;
160 driver = to_i2c_driver(dev->driver);
161 if (driver->shutdown)
162 driver->shutdown(to_i2c_client(dev));
165 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
167 struct i2c_driver *driver;
171 driver = to_i2c_driver(dev->driver);
172 if (!driver->suspend)
174 return driver->suspend(to_i2c_client(dev), mesg);
177 static int i2c_device_resume(struct device * dev)
179 struct i2c_driver *driver;
183 driver = to_i2c_driver(dev->driver);
186 return driver->resume(to_i2c_client(dev));
189 static void i2c_client_release(struct device *dev)
191 struct i2c_client *client = to_i2c_client(dev);
192 complete(&client->released);
195 static void i2c_client_dev_release(struct device *dev)
197 kfree(to_i2c_client(dev));
200 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
202 struct i2c_client *client = to_i2c_client(dev);
203 return sprintf(buf, "%s\n", client->name);
206 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
208 struct i2c_client *client = to_i2c_client(dev);
209 return client->driver_name[0]
210 ? sprintf(buf, "%s\n", client->driver_name)
211 : sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
214 static struct device_attribute i2c_dev_attrs[] = {
215 __ATTR(name, S_IRUGO, show_client_name, NULL),
216 /* modalias helps coldplug: modprobe $(cat .../modalias) */
217 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
221 static struct bus_type i2c_bus_type = {
223 .dev_attrs = i2c_dev_attrs,
224 .match = i2c_device_match,
225 .uevent = i2c_device_uevent,
226 .probe = i2c_device_probe,
227 .remove = i2c_device_remove,
228 .shutdown = i2c_device_shutdown,
229 .suspend = i2c_device_suspend,
230 .resume = i2c_device_resume,
235 * i2c_verify_client - return parameter as i2c_client, or NULL
236 * @dev: device, probably from some driver model iterator
238 * When traversing the driver model tree, perhaps using driver model
239 * iterators like @device_for_each_child(), you can't assume very much
240 * about the nodes you find. Use this function to avoid oopses caused
241 * by wrongly treating some non-I2C device as an i2c_client.
243 struct i2c_client *i2c_verify_client(struct device *dev)
245 return (dev->bus == &i2c_bus_type)
249 EXPORT_SYMBOL(i2c_verify_client);
253 * i2c_new_device - instantiate an i2c device for use with a new style driver
254 * @adap: the adapter managing the device
255 * @info: describes one I2C device; bus_num is ignored
258 * Create a device to work with a new style i2c driver, where binding is
259 * handled through driver model probe()/remove() methods. This call is not
260 * appropriate for use by mainboad initialization logic, which usually runs
261 * during an arch_initcall() long before any i2c_adapter could exist.
263 * This returns the new i2c client, which may be saved for later use with
264 * i2c_unregister_device(); or NULL to indicate an error.
267 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
269 struct i2c_client *client;
272 client = kzalloc(sizeof *client, GFP_KERNEL);
276 client->adapter = adap;
278 client->dev.platform_data = info->platform_data;
279 device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
281 client->flags = info->flags & ~I2C_CLIENT_WAKE;
282 client->addr = info->addr;
283 client->irq = info->irq;
285 strlcpy(client->driver_name, info->driver_name,
286 sizeof(client->driver_name));
287 strlcpy(client->name, info->type, sizeof(client->name));
289 /* a new style driver may be bound to this device when we
290 * return from this function, or any later moment (e.g. maybe
291 * hotplugging will load the driver module). and the device
292 * refcount model is the standard driver model one.
294 status = i2c_attach_client(client);
301 EXPORT_SYMBOL_GPL(i2c_new_device);
305 * i2c_unregister_device - reverse effect of i2c_new_device()
306 * @client: value returned from i2c_new_device()
309 void i2c_unregister_device(struct i2c_client *client)
311 struct i2c_adapter *adapter = client->adapter;
312 struct i2c_driver *driver = client->driver;
314 if (driver && !is_newstyle_driver(driver)) {
315 dev_err(&client->dev, "can't unregister devices "
316 "with legacy drivers\n");
321 mutex_lock(&adapter->clist_lock);
322 list_del(&client->list);
323 mutex_unlock(&adapter->clist_lock);
325 device_unregister(&client->dev);
327 EXPORT_SYMBOL_GPL(i2c_unregister_device);
330 static const struct i2c_device_id dummy_id[] = {
335 static int dummy_probe(struct i2c_client *client,
336 const struct i2c_device_id *id)
341 static int dummy_remove(struct i2c_client *client)
346 static struct i2c_driver dummy_driver = {
347 .driver.name = "dummy",
348 .probe = dummy_probe,
349 .remove = dummy_remove,
350 .id_table = dummy_id,
354 * i2c_new_dummy - return a new i2c device bound to a dummy driver
355 * @adapter: the adapter managing the device
356 * @address: seven bit address to be used
359 * This returns an I2C client bound to the "dummy" driver, intended for use
360 * with devices that consume multiple addresses. Examples of such chips
361 * include various EEPROMS (like 24c04 and 24c08 models).
363 * These dummy devices have two main uses. First, most I2C and SMBus calls
364 * except i2c_transfer() need a client handle; the dummy will be that handle.
365 * And second, this prevents the specified address from being bound to a
368 * This returns the new i2c client, which should be saved for later use with
369 * i2c_unregister_device(); or NULL to indicate an error.
372 i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
374 struct i2c_board_info info = {
375 I2C_BOARD_INFO("dummy", address),
378 return i2c_new_device(adapter, &info);
380 EXPORT_SYMBOL_GPL(i2c_new_dummy);
382 /* ------------------------------------------------------------------------- */
384 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
386 static void i2c_adapter_dev_release(struct device *dev)
388 struct i2c_adapter *adap = to_i2c_adapter(dev);
389 complete(&adap->dev_released);
393 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
395 struct i2c_adapter *adap = to_i2c_adapter(dev);
396 return sprintf(buf, "%s\n", adap->name);
399 static struct device_attribute i2c_adapter_attrs[] = {
400 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
404 static struct class i2c_adapter_class = {
405 .owner = THIS_MODULE,
406 .name = "i2c-adapter",
407 .dev_attrs = i2c_adapter_attrs,
410 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
412 struct i2c_devinfo *devinfo;
414 mutex_lock(&__i2c_board_lock);
415 list_for_each_entry(devinfo, &__i2c_board_list, list) {
416 if (devinfo->busnum == adapter->nr
417 && !i2c_new_device(adapter,
418 &devinfo->board_info))
419 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
420 i2c_adapter_id(adapter),
421 devinfo->board_info.addr);
423 mutex_unlock(&__i2c_board_lock);
426 static int i2c_do_add_adapter(struct device_driver *d, void *data)
428 struct i2c_driver *driver = to_i2c_driver(d);
429 struct i2c_adapter *adap = data;
431 if (driver->attach_adapter) {
432 /* We ignore the return code; if it fails, too bad */
433 driver->attach_adapter(adap);
438 static int i2c_register_adapter(struct i2c_adapter *adap)
442 mutex_init(&adap->bus_lock);
443 mutex_init(&adap->clist_lock);
444 INIT_LIST_HEAD(&adap->clients);
446 mutex_lock(&core_lock);
448 /* Add the adapter to the driver core.
449 * If the parent pointer is not set up,
450 * we add this adapter to the host bus.
452 if (adap->dev.parent == NULL) {
453 adap->dev.parent = &platform_bus;
454 pr_debug("I2C adapter driver [%s] forgot to specify "
455 "physical device\n", adap->name);
457 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
458 adap->dev.release = &i2c_adapter_dev_release;
459 adap->dev.class = &i2c_adapter_class;
460 res = device_register(&adap->dev);
464 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
466 /* create pre-declared device nodes for new-style drivers */
467 if (adap->nr < __i2c_first_dynamic_bus_num)
468 i2c_scan_static_board_info(adap);
470 /* let legacy drivers scan this bus for matching devices */
471 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
475 mutex_unlock(&core_lock);
479 idr_remove(&i2c_adapter_idr, adap->nr);
484 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
485 * @adapter: the adapter to add
488 * This routine is used to declare an I2C adapter when its bus number
489 * doesn't matter. Examples: for I2C adapters dynamically added by
490 * USB links or PCI plugin cards.
492 * When this returns zero, a new bus number was allocated and stored
493 * in adap->nr, and the specified adapter became available for clients.
494 * Otherwise, a negative errno value is returned.
496 int i2c_add_adapter(struct i2c_adapter *adapter)
501 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
504 mutex_lock(&core_lock);
505 /* "above" here means "above or equal to", sigh */
506 res = idr_get_new_above(&i2c_adapter_idr, adapter,
507 __i2c_first_dynamic_bus_num, &id);
508 mutex_unlock(&core_lock);
517 return i2c_register_adapter(adapter);
519 EXPORT_SYMBOL(i2c_add_adapter);
522 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
523 * @adap: the adapter to register (with adap->nr initialized)
526 * This routine is used to declare an I2C adapter when its bus number
527 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
528 * or otherwise built in to the system's mainboard, and where i2c_board_info
529 * is used to properly configure I2C devices.
531 * If no devices have pre-been declared for this bus, then be sure to
532 * register the adapter before any dynamically allocated ones. Otherwise
533 * the required bus ID may not be available.
535 * When this returns zero, the specified adapter became available for
536 * clients using the bus number provided in adap->nr. Also, the table
537 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
538 * and the appropriate driver model device nodes are created. Otherwise, a
539 * negative errno value is returned.
541 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
546 if (adap->nr & ~MAX_ID_MASK)
550 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
553 mutex_lock(&core_lock);
554 /* "above" here means "above or equal to", sigh;
555 * we need the "equal to" result to force the result
557 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
558 if (status == 0 && id != adap->nr) {
560 idr_remove(&i2c_adapter_idr, id);
562 mutex_unlock(&core_lock);
563 if (status == -EAGAIN)
567 status = i2c_register_adapter(adap);
570 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
572 static int i2c_do_del_adapter(struct device_driver *d, void *data)
574 struct i2c_driver *driver = to_i2c_driver(d);
575 struct i2c_adapter *adapter = data;
578 if (!driver->detach_adapter)
580 res = driver->detach_adapter(adapter);
582 dev_err(&adapter->dev, "detach_adapter failed (%d) "
583 "for driver [%s]\n", res, driver->driver.name);
588 * i2c_del_adapter - unregister I2C adapter
589 * @adap: the adapter being unregistered
592 * This unregisters an I2C adapter which was previously registered
593 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
595 int i2c_del_adapter(struct i2c_adapter *adap)
597 struct list_head *item, *_n;
598 struct i2c_client *client;
601 mutex_lock(&core_lock);
603 /* First make sure that this adapter was ever added */
604 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
605 pr_debug("i2c-core: attempting to delete unregistered "
606 "adapter [%s]\n", adap->name);
611 /* Tell drivers about this removal */
612 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
617 /* detach any active clients. This must be done first, because
618 * it can fail; in which case we give up. */
619 list_for_each_safe(item, _n, &adap->clients) {
620 struct i2c_driver *driver;
622 client = list_entry(item, struct i2c_client, list);
623 driver = client->driver;
625 /* new style, follow standard driver model */
626 if (!driver || is_newstyle_driver(driver)) {
627 i2c_unregister_device(client);
631 /* legacy drivers create and remove clients themselves */
632 if ((res = driver->detach_client(client))) {
633 dev_err(&adap->dev, "detach_client failed for client "
634 "[%s] at address 0x%02x\n", client->name,
640 /* clean up the sysfs representation */
641 init_completion(&adap->dev_released);
642 device_unregister(&adap->dev);
644 /* wait for sysfs to drop all references */
645 wait_for_completion(&adap->dev_released);
648 idr_remove(&i2c_adapter_idr, adap->nr);
650 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
653 mutex_unlock(&core_lock);
656 EXPORT_SYMBOL(i2c_del_adapter);
659 /* ------------------------------------------------------------------------- */
662 * An i2c_driver is used with one or more i2c_client (device) nodes to access
663 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
664 * are two models for binding the driver to its device: "new style" drivers
665 * follow the standard Linux driver model and just respond to probe() calls
666 * issued if the driver core sees they match(); "legacy" drivers create device
670 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
674 /* new style driver methods can't mix with legacy ones */
675 if (is_newstyle_driver(driver)) {
676 if (driver->attach_adapter || driver->detach_adapter
677 || driver->detach_client) {
679 "i2c-core: driver [%s] is confused\n",
680 driver->driver.name);
685 /* add the driver to the list of i2c drivers in the driver core */
686 driver->driver.owner = owner;
687 driver->driver.bus = &i2c_bus_type;
689 /* for new style drivers, when registration returns the driver core
690 * will have called probe() for all matching-but-unbound devices.
692 res = driver_register(&driver->driver);
696 mutex_lock(&core_lock);
698 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
700 /* legacy drivers scan i2c busses directly */
701 if (driver->attach_adapter) {
702 struct i2c_adapter *adapter;
704 down(&i2c_adapter_class.sem);
705 list_for_each_entry(adapter, &i2c_adapter_class.devices,
707 driver->attach_adapter(adapter);
709 up(&i2c_adapter_class.sem);
712 mutex_unlock(&core_lock);
715 EXPORT_SYMBOL(i2c_register_driver);
718 * i2c_del_driver - unregister I2C driver
719 * @driver: the driver being unregistered
722 void i2c_del_driver(struct i2c_driver *driver)
724 struct list_head *item2, *_n;
725 struct i2c_client *client;
726 struct i2c_adapter *adap;
728 mutex_lock(&core_lock);
730 /* new-style driver? */
731 if (is_newstyle_driver(driver))
734 /* Have a look at each adapter, if clients of this driver are still
735 * attached. If so, detach them to be able to kill the driver
738 down(&i2c_adapter_class.sem);
739 list_for_each_entry(adap, &i2c_adapter_class.devices, dev.node) {
740 if (driver->detach_adapter) {
741 if (driver->detach_adapter(adap)) {
742 dev_err(&adap->dev, "detach_adapter failed "
744 driver->driver.name);
747 list_for_each_safe(item2, _n, &adap->clients) {
748 client = list_entry(item2, struct i2c_client, list);
749 if (client->driver != driver)
751 dev_dbg(&adap->dev, "detaching client [%s] "
752 "at 0x%02x\n", client->name,
754 if (driver->detach_client(client)) {
755 dev_err(&adap->dev, "detach_client "
756 "failed for client [%s] at "
757 "0x%02x\n", client->name,
763 up(&i2c_adapter_class.sem);
766 driver_unregister(&driver->driver);
767 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
769 mutex_unlock(&core_lock);
771 EXPORT_SYMBOL(i2c_del_driver);
773 /* ------------------------------------------------------------------------- */
775 static int __i2c_check_addr(struct device *dev, void *addrp)
777 struct i2c_client *client = i2c_verify_client(dev);
778 int addr = *(int *)addrp;
780 if (client && client->addr == addr)
785 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
787 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
790 int i2c_attach_client(struct i2c_client *client)
792 struct i2c_adapter *adapter = client->adapter;
795 client->dev.parent = &client->adapter->dev;
796 client->dev.bus = &i2c_bus_type;
799 client->dev.driver = &client->driver->driver;
801 if (client->driver && !is_newstyle_driver(client->driver)) {
802 client->dev.release = i2c_client_release;
803 client->dev.uevent_suppress = 1;
805 client->dev.release = i2c_client_dev_release;
807 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
808 "%d-%04x", i2c_adapter_id(adapter), client->addr);
809 res = device_register(&client->dev);
813 mutex_lock(&adapter->clist_lock);
814 list_add_tail(&client->list, &adapter->clients);
815 mutex_unlock(&adapter->clist_lock);
817 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
818 client->name, client->dev.bus_id);
820 if (adapter->client_register) {
821 if (adapter->client_register(client)) {
822 dev_dbg(&adapter->dev, "client_register "
823 "failed for client [%s] at 0x%02x\n",
824 client->name, client->addr);
831 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
832 "(%d)\n", client->name, client->addr, res);
835 EXPORT_SYMBOL(i2c_attach_client);
837 int i2c_detach_client(struct i2c_client *client)
839 struct i2c_adapter *adapter = client->adapter;
842 if (adapter->client_unregister) {
843 res = adapter->client_unregister(client);
845 dev_err(&client->dev,
846 "client_unregister [%s] failed, "
847 "client not detached\n", client->name);
852 mutex_lock(&adapter->clist_lock);
853 list_del(&client->list);
854 mutex_unlock(&adapter->clist_lock);
856 init_completion(&client->released);
857 device_unregister(&client->dev);
858 wait_for_completion(&client->released);
863 EXPORT_SYMBOL(i2c_detach_client);
866 * i2c_use_client - increments the reference count of the i2c client structure
867 * @client: the client being referenced
869 * Each live reference to a client should be refcounted. The driver model does
870 * that automatically as part of driver binding, so that most drivers don't
871 * need to do this explicitly: they hold a reference until they're unbound
874 * A pointer to the client with the incremented reference counter is returned.
876 struct i2c_client *i2c_use_client(struct i2c_client *client)
878 get_device(&client->dev);
881 EXPORT_SYMBOL(i2c_use_client);
884 * i2c_release_client - release a use of the i2c client structure
885 * @client: the client being no longer referenced
887 * Must be called when a user of a client is finished with it.
889 void i2c_release_client(struct i2c_client *client)
891 put_device(&client->dev);
893 EXPORT_SYMBOL(i2c_release_client);
900 static int i2c_cmd(struct device *dev, void *_arg)
902 struct i2c_client *client = i2c_verify_client(dev);
903 struct i2c_cmd_arg *arg = _arg;
905 if (client && client->driver && client->driver->command)
906 client->driver->command(client, arg->cmd, arg->arg);
910 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
912 struct i2c_cmd_arg cmd_arg;
916 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
918 EXPORT_SYMBOL(i2c_clients_command);
920 static int __init i2c_init(void)
924 retval = bus_register(&i2c_bus_type);
927 retval = class_register(&i2c_adapter_class);
930 retval = i2c_add_driver(&dummy_driver);
936 class_unregister(&i2c_adapter_class);
938 bus_unregister(&i2c_bus_type);
942 static void __exit i2c_exit(void)
944 i2c_del_driver(&dummy_driver);
945 class_unregister(&i2c_adapter_class);
946 bus_unregister(&i2c_bus_type);
949 subsys_initcall(i2c_init);
950 module_exit(i2c_exit);
952 /* ----------------------------------------------------
953 * the functional interface to the i2c busses.
954 * ----------------------------------------------------
957 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
961 if (adap->algo->master_xfer) {
963 for (ret = 0; ret < num; ret++) {
964 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
965 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
966 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
967 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
971 if (in_atomic() || irqs_disabled()) {
972 ret = mutex_trylock(&adap->bus_lock);
974 /* I2C activity is ongoing. */
977 mutex_lock_nested(&adap->bus_lock, adap->level);
980 ret = adap->algo->master_xfer(adap,msgs,num);
981 mutex_unlock(&adap->bus_lock);
985 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
989 EXPORT_SYMBOL(i2c_transfer);
991 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
994 struct i2c_adapter *adap=client->adapter;
997 msg.addr = client->addr;
998 msg.flags = client->flags & I2C_M_TEN;
1000 msg.buf = (char *)buf;
1002 ret = i2c_transfer(adap, &msg, 1);
1004 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1005 transmitted, else error code. */
1006 return (ret == 1) ? count : ret;
1008 EXPORT_SYMBOL(i2c_master_send);
1010 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1012 struct i2c_adapter *adap=client->adapter;
1016 msg.addr = client->addr;
1017 msg.flags = client->flags & I2C_M_TEN;
1018 msg.flags |= I2C_M_RD;
1022 ret = i2c_transfer(adap, &msg, 1);
1024 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1025 transmitted, else error code. */
1026 return (ret == 1) ? count : ret;
1028 EXPORT_SYMBOL(i2c_master_recv);
1030 /* ----------------------------------------------------
1031 * the i2c address scanning function
1032 * Will not work for 10-bit addresses!
1033 * ----------------------------------------------------
1035 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1036 int (*found_proc) (struct i2c_adapter *, int, int))
1040 /* Make sure the address is valid */
1041 if (addr < 0x03 || addr > 0x77) {
1042 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1047 /* Skip if already in use */
1048 if (i2c_check_addr(adapter, addr))
1051 /* Make sure there is something at this address, unless forced */
1053 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1054 I2C_SMBUS_QUICK, NULL) < 0)
1057 /* prevent 24RF08 corruption */
1058 if ((addr & ~0x0f) == 0x50)
1059 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1060 I2C_SMBUS_QUICK, NULL);
1063 /* Finally call the custom detection function */
1064 err = found_proc(adapter, addr, kind);
1065 /* -ENODEV can be returned if there is a chip at the given address
1066 but it isn't supported by this chip driver. We catch it here as
1067 this isn't an error. */
1072 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1077 int i2c_probe(struct i2c_adapter *adapter,
1078 const struct i2c_client_address_data *address_data,
1079 int (*found_proc) (struct i2c_adapter *, int, int))
1082 int adap_id = i2c_adapter_id(adapter);
1084 /* Force entries are done first, and are not affected by ignore
1086 if (address_data->forces) {
1087 const unsigned short * const *forces = address_data->forces;
1090 for (kind = 0; forces[kind]; kind++) {
1091 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1093 if (forces[kind][i] == adap_id
1094 || forces[kind][i] == ANY_I2C_BUS) {
1095 dev_dbg(&adapter->dev, "found force "
1096 "parameter for adapter %d, "
1097 "addr 0x%02x, kind %d\n",
1098 adap_id, forces[kind][i + 1],
1100 err = i2c_probe_address(adapter,
1101 forces[kind][i + 1],
1110 /* Stop here if we can't use SMBUS_QUICK */
1111 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1112 if (address_data->probe[0] == I2C_CLIENT_END
1113 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1116 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1117 "can't probe for chips\n");
1121 /* Probe entries are done second, and are not affected by ignore
1123 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1124 if (address_data->probe[i] == adap_id
1125 || address_data->probe[i] == ANY_I2C_BUS) {
1126 dev_dbg(&adapter->dev, "found probe parameter for "
1127 "adapter %d, addr 0x%02x\n", adap_id,
1128 address_data->probe[i + 1]);
1129 err = i2c_probe_address(adapter,
1130 address_data->probe[i + 1],
1137 /* Normal entries are done last, unless shadowed by an ignore entry */
1138 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1142 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1144 if ((address_data->ignore[j] == adap_id ||
1145 address_data->ignore[j] == ANY_I2C_BUS)
1146 && address_data->ignore[j + 1]
1147 == address_data->normal_i2c[i]) {
1148 dev_dbg(&adapter->dev, "found ignore "
1149 "parameter for adapter %d, "
1150 "addr 0x%02x\n", adap_id,
1151 address_data->ignore[j + 1]);
1159 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1160 "addr 0x%02x\n", adap_id,
1161 address_data->normal_i2c[i]);
1162 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1170 EXPORT_SYMBOL(i2c_probe);
1173 i2c_new_probed_device(struct i2c_adapter *adap,
1174 struct i2c_board_info *info,
1175 unsigned short const *addr_list)
1179 /* Stop here if the bus doesn't support probing */
1180 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1181 dev_err(&adap->dev, "Probing not supported\n");
1185 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1186 /* Check address validity */
1187 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1188 dev_warn(&adap->dev, "Invalid 7-bit address "
1189 "0x%02x\n", addr_list[i]);
1193 /* Check address availability */
1194 if (i2c_check_addr(adap, addr_list[i])) {
1195 dev_dbg(&adap->dev, "Address 0x%02x already in "
1196 "use, not probing\n", addr_list[i]);
1200 /* Test address responsiveness
1201 The default probe method is a quick write, but it is known
1202 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1203 and could also irreversibly write-protect some EEPROMs, so
1204 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1205 read instead. Also, some bus drivers don't implement
1206 quick write, so we fallback to a byte read it that case
1208 if ((addr_list[i] & ~0x07) == 0x30
1209 || (addr_list[i] & ~0x0f) == 0x50
1210 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1211 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1213 I2C_SMBUS_BYTE, NULL) >= 0)
1216 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1218 I2C_SMBUS_QUICK, NULL) >= 0)
1223 if (addr_list[i] == I2C_CLIENT_END) {
1224 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1228 info->addr = addr_list[i];
1229 return i2c_new_device(adap, info);
1231 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1233 struct i2c_adapter* i2c_get_adapter(int id)
1235 struct i2c_adapter *adapter;
1237 mutex_lock(&core_lock);
1238 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1239 if (adapter && !try_module_get(adapter->owner))
1242 mutex_unlock(&core_lock);
1245 EXPORT_SYMBOL(i2c_get_adapter);
1247 void i2c_put_adapter(struct i2c_adapter *adap)
1249 module_put(adap->owner);
1251 EXPORT_SYMBOL(i2c_put_adapter);
1253 /* The SMBus parts */
1255 #define POLY (0x1070U << 3)
1261 for(i = 0; i < 8; i++) {
1266 return (u8)(data >> 8);
1269 /* Incremental CRC8 over count bytes in the array pointed to by p */
1270 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1274 for(i = 0; i < count; i++)
1275 crc = crc8((crc ^ p[i]) << 8);
1279 /* Assume a 7-bit address, which is reasonable for SMBus */
1280 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1282 /* The address will be sent first */
1283 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1284 pec = i2c_smbus_pec(pec, &addr, 1);
1286 /* The data buffer follows */
1287 return i2c_smbus_pec(pec, msg->buf, msg->len);
1290 /* Used for write only transactions */
1291 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1293 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1297 /* Return <0 on CRC error
1298 If there was a write before this read (most cases) we need to take the
1299 partial CRC from the write part into account.
1300 Note that this function does modify the message (we need to decrease the
1301 message length to hide the CRC byte from the caller). */
1302 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1304 u8 rpec = msg->buf[--msg->len];
1305 cpec = i2c_smbus_msg_pec(cpec, msg);
1308 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1315 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
1317 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1318 value,0,I2C_SMBUS_QUICK,NULL);
1320 EXPORT_SYMBOL(i2c_smbus_write_quick);
1322 s32 i2c_smbus_read_byte(struct i2c_client *client)
1324 union i2c_smbus_data data;
1325 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1326 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
1331 EXPORT_SYMBOL(i2c_smbus_read_byte);
1333 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1335 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1336 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1338 EXPORT_SYMBOL(i2c_smbus_write_byte);
1340 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1342 union i2c_smbus_data data;
1343 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1344 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
1349 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1351 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1353 union i2c_smbus_data data;
1355 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1356 I2C_SMBUS_WRITE,command,
1357 I2C_SMBUS_BYTE_DATA,&data);
1359 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1361 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1363 union i2c_smbus_data data;
1364 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1365 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
1370 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1372 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1374 union i2c_smbus_data data;
1376 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1377 I2C_SMBUS_WRITE,command,
1378 I2C_SMBUS_WORD_DATA,&data);
1380 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1383 * i2c_smbus_read_block_data - SMBus block read request
1384 * @client: Handle to slave device
1385 * @command: Command byte issued to let the slave know what data should
1387 * @values: Byte array into which data will be read; big enough to hold
1388 * the data returned by the slave. SMBus allows at most 32 bytes.
1390 * Returns the number of bytes read in the slave's response, else a
1391 * negative number to indicate some kind of error.
1393 * Note that using this function requires that the client's adapter support
1394 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1395 * support this; its emulation through I2C messaging relies on a specific
1396 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1398 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1401 union i2c_smbus_data data;
1403 if (i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1404 I2C_SMBUS_READ, command,
1405 I2C_SMBUS_BLOCK_DATA, &data))
1408 memcpy(values, &data.block[1], data.block[0]);
1409 return data.block[0];
1411 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1413 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1414 u8 length, const u8 *values)
1416 union i2c_smbus_data data;
1418 if (length > I2C_SMBUS_BLOCK_MAX)
1419 length = I2C_SMBUS_BLOCK_MAX;
1420 data.block[0] = length;
1421 memcpy(&data.block[1], values, length);
1422 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1423 I2C_SMBUS_WRITE,command,
1424 I2C_SMBUS_BLOCK_DATA,&data);
1426 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1428 /* Returns the number of read bytes */
1429 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1430 u8 length, u8 *values)
1432 union i2c_smbus_data data;
1434 if (length > I2C_SMBUS_BLOCK_MAX)
1435 length = I2C_SMBUS_BLOCK_MAX;
1436 data.block[0] = length;
1437 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1438 I2C_SMBUS_READ,command,
1439 I2C_SMBUS_I2C_BLOCK_DATA,&data))
1442 memcpy(values, &data.block[1], data.block[0]);
1443 return data.block[0];
1445 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1447 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1448 u8 length, const u8 *values)
1450 union i2c_smbus_data data;
1452 if (length > I2C_SMBUS_BLOCK_MAX)
1453 length = I2C_SMBUS_BLOCK_MAX;
1454 data.block[0] = length;
1455 memcpy(data.block + 1, values, length);
1456 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1457 I2C_SMBUS_WRITE, command,
1458 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1460 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1462 /* Simulate a SMBus command using the i2c protocol
1463 No checking of parameters is done! */
1464 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1465 unsigned short flags,
1466 char read_write, u8 command, int size,
1467 union i2c_smbus_data * data)
1469 /* So we need to generate a series of msgs. In the case of writing, we
1470 need to use only one message; when reading, we need two. We initialize
1471 most things with sane defaults, to keep the code below somewhat
1473 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1474 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1475 int num = read_write == I2C_SMBUS_READ?2:1;
1476 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1477 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1482 msgbuf0[0] = command;
1484 case I2C_SMBUS_QUICK:
1486 /* Special case: The read/write field is used as data */
1487 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1490 case I2C_SMBUS_BYTE:
1491 if (read_write == I2C_SMBUS_READ) {
1492 /* Special case: only a read! */
1493 msg[0].flags = I2C_M_RD | flags;
1497 case I2C_SMBUS_BYTE_DATA:
1498 if (read_write == I2C_SMBUS_READ)
1502 msgbuf0[1] = data->byte;
1505 case I2C_SMBUS_WORD_DATA:
1506 if (read_write == I2C_SMBUS_READ)
1510 msgbuf0[1] = data->word & 0xff;
1511 msgbuf0[2] = data->word >> 8;
1514 case I2C_SMBUS_PROC_CALL:
1515 num = 2; /* Special case */
1516 read_write = I2C_SMBUS_READ;
1519 msgbuf0[1] = data->word & 0xff;
1520 msgbuf0[2] = data->word >> 8;
1522 case I2C_SMBUS_BLOCK_DATA:
1523 if (read_write == I2C_SMBUS_READ) {
1524 msg[1].flags |= I2C_M_RECV_LEN;
1525 msg[1].len = 1; /* block length will be added by
1526 the underlying bus driver */
1528 msg[0].len = data->block[0] + 2;
1529 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1530 dev_err(&adapter->dev, "smbus_access called with "
1531 "invalid block write size (%d)\n",
1535 for (i = 1; i < msg[0].len; i++)
1536 msgbuf0[i] = data->block[i-1];
1539 case I2C_SMBUS_BLOCK_PROC_CALL:
1540 num = 2; /* Another special case */
1541 read_write = I2C_SMBUS_READ;
1542 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1543 dev_err(&adapter->dev, "%s called with invalid "
1544 "block proc call size (%d)\n", __func__,
1548 msg[0].len = data->block[0] + 2;
1549 for (i = 1; i < msg[0].len; i++)
1550 msgbuf0[i] = data->block[i-1];
1551 msg[1].flags |= I2C_M_RECV_LEN;
1552 msg[1].len = 1; /* block length will be added by
1553 the underlying bus driver */
1555 case I2C_SMBUS_I2C_BLOCK_DATA:
1556 if (read_write == I2C_SMBUS_READ) {
1557 msg[1].len = data->block[0];
1559 msg[0].len = data->block[0] + 1;
1560 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1561 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1562 "invalid block write size (%d)\n",
1566 for (i = 1; i <= data->block[0]; i++)
1567 msgbuf0[i] = data->block[i];
1571 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1576 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1577 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1579 /* Compute PEC if first message is a write */
1580 if (!(msg[0].flags & I2C_M_RD)) {
1581 if (num == 1) /* Write only */
1582 i2c_smbus_add_pec(&msg[0]);
1583 else /* Write followed by read */
1584 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1586 /* Ask for PEC if last message is a read */
1587 if (msg[num-1].flags & I2C_M_RD)
1591 if (i2c_transfer(adapter, msg, num) < 0)
1594 /* Check PEC if last message is a read */
1595 if (i && (msg[num-1].flags & I2C_M_RD)) {
1596 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1600 if (read_write == I2C_SMBUS_READ)
1602 case I2C_SMBUS_BYTE:
1603 data->byte = msgbuf0[0];
1605 case I2C_SMBUS_BYTE_DATA:
1606 data->byte = msgbuf1[0];
1608 case I2C_SMBUS_WORD_DATA:
1609 case I2C_SMBUS_PROC_CALL:
1610 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1612 case I2C_SMBUS_I2C_BLOCK_DATA:
1613 for (i = 0; i < data->block[0]; i++)
1614 data->block[i+1] = msgbuf1[i];
1616 case I2C_SMBUS_BLOCK_DATA:
1617 case I2C_SMBUS_BLOCK_PROC_CALL:
1618 for (i = 0; i < msgbuf1[0] + 1; i++)
1619 data->block[i] = msgbuf1[i];
1626 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1627 char read_write, u8 command, int size,
1628 union i2c_smbus_data * data)
1632 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1634 if (adapter->algo->smbus_xfer) {
1635 mutex_lock(&adapter->bus_lock);
1636 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1638 mutex_unlock(&adapter->bus_lock);
1640 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1645 EXPORT_SYMBOL(i2c_smbus_xfer);
1647 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1648 MODULE_DESCRIPTION("I2C-Bus main module");
1649 MODULE_LICENSE("GPL");