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/mutex.h>
33 #include <linux/completion.h>
34 #include <linux/hardirq.h>
35 #include <linux/irqflags.h>
36 #include <linux/rwsem.h>
37 #include <asm/uaccess.h>
42 /* core_lock protects i2c_adapter_idr, userspace_devices, and guarantees
43 that device detection, deletion of detected devices, and attach_adapter
44 and detach_adapter calls are serialized */
45 static DEFINE_MUTEX(core_lock);
46 static DEFINE_IDR(i2c_adapter_idr);
47 static LIST_HEAD(userspace_devices);
49 static struct device_type i2c_client_type;
50 static int i2c_check_addr(struct i2c_adapter *adapter, int addr);
51 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
53 /* ------------------------------------------------------------------------- */
55 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
56 const struct i2c_client *client)
59 if (strcmp(client->name, id->name) == 0)
66 static int i2c_device_match(struct device *dev, struct device_driver *drv)
68 struct i2c_client *client = i2c_verify_client(dev);
69 struct i2c_driver *driver;
74 driver = to_i2c_driver(drv);
75 /* match on an id table if there is one */
77 return i2c_match_id(driver->id_table, client) != NULL;
84 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
85 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
87 struct i2c_client *client = to_i2c_client(dev);
89 if (add_uevent_var(env, "MODALIAS=%s%s",
90 I2C_MODULE_PREFIX, client->name))
92 dev_dbg(dev, "uevent\n");
97 #define i2c_device_uevent NULL
98 #endif /* CONFIG_HOTPLUG */
100 static int i2c_device_probe(struct device *dev)
102 struct i2c_client *client = i2c_verify_client(dev);
103 struct i2c_driver *driver;
109 driver = to_i2c_driver(dev->driver);
110 if (!driver->probe || !driver->id_table)
112 client->driver = driver;
113 if (!device_can_wakeup(&client->dev))
114 device_init_wakeup(&client->dev,
115 client->flags & I2C_CLIENT_WAKE);
116 dev_dbg(dev, "probe\n");
118 status = driver->probe(client, i2c_match_id(driver->id_table, client));
120 client->driver = NULL;
124 static int i2c_device_remove(struct device *dev)
126 struct i2c_client *client = i2c_verify_client(dev);
127 struct i2c_driver *driver;
130 if (!client || !dev->driver)
133 driver = to_i2c_driver(dev->driver);
134 if (driver->remove) {
135 dev_dbg(dev, "remove\n");
136 status = driver->remove(client);
142 client->driver = NULL;
146 static void i2c_device_shutdown(struct device *dev)
148 struct i2c_client *client = i2c_verify_client(dev);
149 struct i2c_driver *driver;
151 if (!client || !dev->driver)
153 driver = to_i2c_driver(dev->driver);
154 if (driver->shutdown)
155 driver->shutdown(client);
158 static int i2c_device_suspend(struct device *dev, pm_message_t mesg)
160 struct i2c_client *client = i2c_verify_client(dev);
161 struct i2c_driver *driver;
163 if (!client || !dev->driver)
165 driver = to_i2c_driver(dev->driver);
166 if (!driver->suspend)
168 return driver->suspend(client, mesg);
171 static int i2c_device_resume(struct device *dev)
173 struct i2c_client *client = i2c_verify_client(dev);
174 struct i2c_driver *driver;
176 if (!client || !dev->driver)
178 driver = to_i2c_driver(dev->driver);
181 return driver->resume(client);
184 static void i2c_client_dev_release(struct device *dev)
186 kfree(to_i2c_client(dev));
190 show_name(struct device *dev, struct device_attribute *attr, char *buf)
192 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
193 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
197 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
199 struct i2c_client *client = to_i2c_client(dev);
200 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
203 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
204 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
206 static struct attribute *i2c_dev_attrs[] = {
208 /* modalias helps coldplug: modprobe $(cat .../modalias) */
209 &dev_attr_modalias.attr,
213 static struct attribute_group i2c_dev_attr_group = {
214 .attrs = i2c_dev_attrs,
217 static const struct attribute_group *i2c_dev_attr_groups[] = {
222 struct bus_type i2c_bus_type = {
224 .match = i2c_device_match,
225 .probe = i2c_device_probe,
226 .remove = i2c_device_remove,
227 .shutdown = i2c_device_shutdown,
228 .suspend = i2c_device_suspend,
229 .resume = i2c_device_resume,
231 EXPORT_SYMBOL_GPL(i2c_bus_type);
233 static struct device_type i2c_client_type = {
234 .groups = i2c_dev_attr_groups,
235 .uevent = i2c_device_uevent,
236 .release = i2c_client_dev_release,
241 * i2c_verify_client - return parameter as i2c_client, or NULL
242 * @dev: device, probably from some driver model iterator
244 * When traversing the driver model tree, perhaps using driver model
245 * iterators like @device_for_each_child(), you can't assume very much
246 * about the nodes you find. Use this function to avoid oopses caused
247 * by wrongly treating some non-I2C device as an i2c_client.
249 struct i2c_client *i2c_verify_client(struct device *dev)
251 return (dev->type == &i2c_client_type)
255 EXPORT_SYMBOL(i2c_verify_client);
259 * i2c_new_device - instantiate an i2c device
260 * @adap: the adapter managing the device
261 * @info: describes one I2C device; bus_num is ignored
264 * Create an i2c device. Binding is handled through driver model
265 * probe()/remove() methods. A driver may be bound to this device when we
266 * return from this function, or any later moment (e.g. maybe hotplugging will
267 * load the driver module). This call is not appropriate for use by mainboard
268 * initialization logic, which usually runs during an arch_initcall() long
269 * before any i2c_adapter could exist.
271 * This returns the new i2c client, which may be saved for later use with
272 * i2c_unregister_device(); or NULL to indicate an error.
275 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
277 struct i2c_client *client;
280 client = kzalloc(sizeof *client, GFP_KERNEL);
284 client->adapter = adap;
286 client->dev.platform_data = info->platform_data;
289 client->dev.archdata = *info->archdata;
291 client->flags = info->flags;
292 client->addr = info->addr;
293 client->irq = info->irq;
295 strlcpy(client->name, info->type, sizeof(client->name));
297 /* Check for address business */
298 status = i2c_check_addr(adap, client->addr);
302 client->dev.parent = &client->adapter->dev;
303 client->dev.bus = &i2c_bus_type;
304 client->dev.type = &i2c_client_type;
306 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
308 status = device_register(&client->dev);
312 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
313 client->name, dev_name(&client->dev));
318 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
319 "(%d)\n", client->name, client->addr, status);
323 EXPORT_SYMBOL_GPL(i2c_new_device);
327 * i2c_unregister_device - reverse effect of i2c_new_device()
328 * @client: value returned from i2c_new_device()
331 void i2c_unregister_device(struct i2c_client *client)
333 device_unregister(&client->dev);
335 EXPORT_SYMBOL_GPL(i2c_unregister_device);
338 static const struct i2c_device_id dummy_id[] = {
343 static int dummy_probe(struct i2c_client *client,
344 const struct i2c_device_id *id)
349 static int dummy_remove(struct i2c_client *client)
354 static struct i2c_driver dummy_driver = {
355 .driver.name = "dummy",
356 .probe = dummy_probe,
357 .remove = dummy_remove,
358 .id_table = dummy_id,
362 * i2c_new_dummy - return a new i2c device bound to a dummy driver
363 * @adapter: the adapter managing the device
364 * @address: seven bit address to be used
367 * This returns an I2C client bound to the "dummy" driver, intended for use
368 * with devices that consume multiple addresses. Examples of such chips
369 * include various EEPROMS (like 24c04 and 24c08 models).
371 * These dummy devices have two main uses. First, most I2C and SMBus calls
372 * except i2c_transfer() need a client handle; the dummy will be that handle.
373 * And second, this prevents the specified address from being bound to a
376 * This returns the new i2c client, which should be saved for later use with
377 * i2c_unregister_device(); or NULL to indicate an error.
379 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
381 struct i2c_board_info info = {
382 I2C_BOARD_INFO("dummy", address),
385 return i2c_new_device(adapter, &info);
387 EXPORT_SYMBOL_GPL(i2c_new_dummy);
389 /* ------------------------------------------------------------------------- */
391 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
393 static void i2c_adapter_dev_release(struct device *dev)
395 struct i2c_adapter *adap = to_i2c_adapter(dev);
396 complete(&adap->dev_released);
400 * Let users instantiate I2C devices through sysfs. This can be used when
401 * platform initialization code doesn't contain the proper data for
402 * whatever reason. Also useful for drivers that do device detection and
403 * detection fails, either because the device uses an unexpected address,
404 * or this is a compatible device with different ID register values.
406 * Parameter checking may look overzealous, but we really don't want
407 * the user to provide incorrect parameters.
410 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
411 const char *buf, size_t count)
413 struct i2c_adapter *adap = to_i2c_adapter(dev);
414 struct i2c_board_info info;
415 struct i2c_client *client;
419 dev_warn(dev, "The new_device interface is still experimental "
420 "and may change in a near future\n");
421 memset(&info, 0, sizeof(struct i2c_board_info));
423 blank = strchr(buf, ' ');
425 dev_err(dev, "%s: Missing parameters\n", "new_device");
428 if (blank - buf > I2C_NAME_SIZE - 1) {
429 dev_err(dev, "%s: Invalid device name\n", "new_device");
432 memcpy(info.type, buf, blank - buf);
434 /* Parse remaining parameters, reject extra parameters */
435 res = sscanf(++blank, "%hi%c", &info.addr, &end);
437 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
440 if (res > 1 && end != '\n') {
441 dev_err(dev, "%s: Extra parameters\n", "new_device");
445 if (info.addr < 0x03 || info.addr > 0x77) {
446 dev_err(dev, "%s: Invalid I2C address 0x%hx\n", "new_device",
451 client = i2c_new_device(adap, &info);
455 /* Keep track of the added device */
456 mutex_lock(&core_lock);
457 list_add_tail(&client->detected, &userspace_devices);
458 mutex_unlock(&core_lock);
459 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
460 info.type, info.addr);
466 * And of course let the users delete the devices they instantiated, if
467 * they got it wrong. This interface can only be used to delete devices
468 * instantiated by i2c_sysfs_new_device above. This guarantees that we
469 * don't delete devices to which some kernel code still has references.
471 * Parameter checking may look overzealous, but we really don't want
472 * the user to delete the wrong device.
475 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
476 const char *buf, size_t count)
478 struct i2c_adapter *adap = to_i2c_adapter(dev);
479 struct i2c_client *client, *next;
484 /* Parse parameters, reject extra parameters */
485 res = sscanf(buf, "%hi%c", &addr, &end);
487 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
490 if (res > 1 && end != '\n') {
491 dev_err(dev, "%s: Extra parameters\n", "delete_device");
495 /* Make sure the device was added through sysfs */
497 mutex_lock(&core_lock);
498 list_for_each_entry_safe(client, next, &userspace_devices, detected) {
499 if (client->addr == addr && client->adapter == adap) {
500 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
501 "delete_device", client->name, client->addr);
503 list_del(&client->detected);
504 i2c_unregister_device(client);
509 mutex_unlock(&core_lock);
512 dev_err(dev, "%s: Can't find device in list\n",
517 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
518 static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
520 static struct attribute *i2c_adapter_attrs[] = {
522 &dev_attr_new_device.attr,
523 &dev_attr_delete_device.attr,
527 static struct attribute_group i2c_adapter_attr_group = {
528 .attrs = i2c_adapter_attrs,
531 static const struct attribute_group *i2c_adapter_attr_groups[] = {
532 &i2c_adapter_attr_group,
536 static struct device_type i2c_adapter_type = {
537 .groups = i2c_adapter_attr_groups,
538 .release = i2c_adapter_dev_release,
541 #ifdef CONFIG_I2C_COMPAT
542 static struct class_compat *i2c_adapter_compat_class;
545 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
547 struct i2c_devinfo *devinfo;
549 down_read(&__i2c_board_lock);
550 list_for_each_entry(devinfo, &__i2c_board_list, list) {
551 if (devinfo->busnum == adapter->nr
552 && !i2c_new_device(adapter,
553 &devinfo->board_info))
554 dev_err(&adapter->dev,
555 "Can't create device at 0x%02x\n",
556 devinfo->board_info.addr);
558 up_read(&__i2c_board_lock);
561 static int i2c_do_add_adapter(struct device_driver *d, void *data)
563 struct i2c_driver *driver = to_i2c_driver(d);
564 struct i2c_adapter *adap = data;
566 /* Detect supported devices on that bus, and instantiate them */
567 i2c_detect(adap, driver);
569 /* Let legacy drivers scan this bus for matching devices */
570 if (driver->attach_adapter) {
571 /* We ignore the return code; if it fails, too bad */
572 driver->attach_adapter(adap);
577 static int i2c_register_adapter(struct i2c_adapter *adap)
581 /* Can't register until after driver model init */
582 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
587 mutex_init(&adap->bus_lock);
589 /* Set default timeout to 1 second if not already set */
590 if (adap->timeout == 0)
593 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
594 adap->dev.bus = &i2c_bus_type;
595 adap->dev.type = &i2c_adapter_type;
596 res = device_register(&adap->dev);
600 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
602 #ifdef CONFIG_I2C_COMPAT
603 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
607 "Failed to create compatibility class link\n");
610 /* create pre-declared device nodes */
611 if (adap->nr < __i2c_first_dynamic_bus_num)
612 i2c_scan_static_board_info(adap);
615 mutex_lock(&core_lock);
616 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
618 mutex_unlock(&core_lock);
623 mutex_lock(&core_lock);
624 idr_remove(&i2c_adapter_idr, adap->nr);
625 mutex_unlock(&core_lock);
630 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
631 * @adapter: the adapter to add
634 * This routine is used to declare an I2C adapter when its bus number
635 * doesn't matter. Examples: for I2C adapters dynamically added by
636 * USB links or PCI plugin cards.
638 * When this returns zero, a new bus number was allocated and stored
639 * in adap->nr, and the specified adapter became available for clients.
640 * Otherwise, a negative errno value is returned.
642 int i2c_add_adapter(struct i2c_adapter *adapter)
647 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
650 mutex_lock(&core_lock);
651 /* "above" here means "above or equal to", sigh */
652 res = idr_get_new_above(&i2c_adapter_idr, adapter,
653 __i2c_first_dynamic_bus_num, &id);
654 mutex_unlock(&core_lock);
663 return i2c_register_adapter(adapter);
665 EXPORT_SYMBOL(i2c_add_adapter);
668 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
669 * @adap: the adapter to register (with adap->nr initialized)
672 * This routine is used to declare an I2C adapter when its bus number
673 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
674 * or otherwise built in to the system's mainboard, and where i2c_board_info
675 * is used to properly configure I2C devices.
677 * If no devices have pre-been declared for this bus, then be sure to
678 * register the adapter before any dynamically allocated ones. Otherwise
679 * the required bus ID may not be available.
681 * When this returns zero, the specified adapter became available for
682 * clients using the bus number provided in adap->nr. Also, the table
683 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
684 * and the appropriate driver model device nodes are created. Otherwise, a
685 * negative errno value is returned.
687 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
692 if (adap->nr & ~MAX_ID_MASK)
696 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
699 mutex_lock(&core_lock);
700 /* "above" here means "above or equal to", sigh;
701 * we need the "equal to" result to force the result
703 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
704 if (status == 0 && id != adap->nr) {
706 idr_remove(&i2c_adapter_idr, id);
708 mutex_unlock(&core_lock);
709 if (status == -EAGAIN)
713 status = i2c_register_adapter(adap);
716 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
718 static int i2c_do_del_adapter(struct device_driver *d, void *data)
720 struct i2c_driver *driver = to_i2c_driver(d);
721 struct i2c_adapter *adapter = data;
722 struct i2c_client *client, *_n;
725 /* Remove the devices we created ourselves as the result of hardware
726 * probing (using a driver's detect method) */
727 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
728 if (client->adapter == adapter) {
729 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
730 client->name, client->addr);
731 list_del(&client->detected);
732 i2c_unregister_device(client);
736 if (!driver->detach_adapter)
738 res = driver->detach_adapter(adapter);
740 dev_err(&adapter->dev, "detach_adapter failed (%d) "
741 "for driver [%s]\n", res, driver->driver.name);
745 static int __unregister_client(struct device *dev, void *dummy)
747 struct i2c_client *client = i2c_verify_client(dev);
749 i2c_unregister_device(client);
754 * i2c_del_adapter - unregister I2C adapter
755 * @adap: the adapter being unregistered
758 * This unregisters an I2C adapter which was previously registered
759 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
761 int i2c_del_adapter(struct i2c_adapter *adap)
764 struct i2c_adapter *found;
765 struct i2c_client *client, *next;
767 /* First make sure that this adapter was ever added */
768 mutex_lock(&core_lock);
769 found = idr_find(&i2c_adapter_idr, adap->nr);
770 mutex_unlock(&core_lock);
772 pr_debug("i2c-core: attempting to delete unregistered "
773 "adapter [%s]\n", adap->name);
777 /* Tell drivers about this removal */
778 mutex_lock(&core_lock);
779 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
781 mutex_unlock(&core_lock);
785 /* Remove devices instantiated from sysfs */
786 list_for_each_entry_safe(client, next, &userspace_devices, detected) {
787 if (client->adapter == adap) {
788 dev_dbg(&adap->dev, "Removing %s at 0x%x\n",
789 client->name, client->addr);
790 list_del(&client->detected);
791 i2c_unregister_device(client);
795 /* Detach any active clients. This can't fail, thus we do not
796 checking the returned value. */
797 res = device_for_each_child(&adap->dev, NULL, __unregister_client);
799 #ifdef CONFIG_I2C_COMPAT
800 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
804 /* clean up the sysfs representation */
805 init_completion(&adap->dev_released);
806 device_unregister(&adap->dev);
808 /* wait for sysfs to drop all references */
809 wait_for_completion(&adap->dev_released);
812 mutex_lock(&core_lock);
813 idr_remove(&i2c_adapter_idr, adap->nr);
814 mutex_unlock(&core_lock);
816 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
818 /* Clear the device structure in case this adapter is ever going to be
820 memset(&adap->dev, 0, sizeof(adap->dev));
824 EXPORT_SYMBOL(i2c_del_adapter);
827 /* ------------------------------------------------------------------------- */
829 static int __attach_adapter(struct device *dev, void *data)
831 struct i2c_adapter *adapter;
832 struct i2c_driver *driver = data;
834 if (dev->type != &i2c_adapter_type)
836 adapter = to_i2c_adapter(dev);
838 i2c_detect(adapter, driver);
840 /* Legacy drivers scan i2c busses directly */
841 if (driver->attach_adapter)
842 driver->attach_adapter(adapter);
848 * An i2c_driver is used with one or more i2c_client (device) nodes to access
849 * i2c slave chips, on a bus instance associated with some i2c_adapter.
852 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
856 /* Can't register until after driver model init */
857 if (unlikely(WARN_ON(!i2c_bus_type.p)))
860 /* add the driver to the list of i2c drivers in the driver core */
861 driver->driver.owner = owner;
862 driver->driver.bus = &i2c_bus_type;
864 /* When registration returns, the driver core
865 * will have called probe() for all matching-but-unbound devices.
867 res = driver_register(&driver->driver);
871 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
873 INIT_LIST_HEAD(&driver->clients);
874 /* Walk the adapters that are already present */
875 mutex_lock(&core_lock);
876 bus_for_each_dev(&i2c_bus_type, NULL, driver, __attach_adapter);
877 mutex_unlock(&core_lock);
881 EXPORT_SYMBOL(i2c_register_driver);
883 static int __detach_adapter(struct device *dev, void *data)
885 struct i2c_adapter *adapter;
886 struct i2c_driver *driver = data;
887 struct i2c_client *client, *_n;
889 if (dev->type != &i2c_adapter_type)
891 adapter = to_i2c_adapter(dev);
893 /* Remove the devices we created ourselves as the result of hardware
894 * probing (using a driver's detect method) */
895 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
896 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
897 client->name, client->addr);
898 list_del(&client->detected);
899 i2c_unregister_device(client);
902 if (driver->detach_adapter) {
903 if (driver->detach_adapter(adapter))
904 dev_err(&adapter->dev,
905 "detach_adapter failed for driver [%s]\n",
906 driver->driver.name);
913 * i2c_del_driver - unregister I2C driver
914 * @driver: the driver being unregistered
917 void i2c_del_driver(struct i2c_driver *driver)
919 mutex_lock(&core_lock);
920 bus_for_each_dev(&i2c_bus_type, NULL, driver, __detach_adapter);
921 mutex_unlock(&core_lock);
923 driver_unregister(&driver->driver);
924 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
926 EXPORT_SYMBOL(i2c_del_driver);
928 /* ------------------------------------------------------------------------- */
930 static int __i2c_check_addr(struct device *dev, void *addrp)
932 struct i2c_client *client = i2c_verify_client(dev);
933 int addr = *(int *)addrp;
935 if (client && client->addr == addr)
940 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
942 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
946 * i2c_use_client - increments the reference count of the i2c client structure
947 * @client: the client being referenced
949 * Each live reference to a client should be refcounted. The driver model does
950 * that automatically as part of driver binding, so that most drivers don't
951 * need to do this explicitly: they hold a reference until they're unbound
954 * A pointer to the client with the incremented reference counter is returned.
956 struct i2c_client *i2c_use_client(struct i2c_client *client)
958 if (client && get_device(&client->dev))
962 EXPORT_SYMBOL(i2c_use_client);
965 * i2c_release_client - release a use of the i2c client structure
966 * @client: the client being no longer referenced
968 * Must be called when a user of a client is finished with it.
970 void i2c_release_client(struct i2c_client *client)
973 put_device(&client->dev);
975 EXPORT_SYMBOL(i2c_release_client);
982 static int i2c_cmd(struct device *dev, void *_arg)
984 struct i2c_client *client = i2c_verify_client(dev);
985 struct i2c_cmd_arg *arg = _arg;
987 if (client && client->driver && client->driver->command)
988 client->driver->command(client, arg->cmd, arg->arg);
992 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
994 struct i2c_cmd_arg cmd_arg;
998 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1000 EXPORT_SYMBOL(i2c_clients_command);
1002 static int __init i2c_init(void)
1006 retval = bus_register(&i2c_bus_type);
1009 #ifdef CONFIG_I2C_COMPAT
1010 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1011 if (!i2c_adapter_compat_class) {
1016 retval = i2c_add_driver(&dummy_driver);
1022 #ifdef CONFIG_I2C_COMPAT
1023 class_compat_unregister(i2c_adapter_compat_class);
1026 bus_unregister(&i2c_bus_type);
1030 static void __exit i2c_exit(void)
1032 i2c_del_driver(&dummy_driver);
1033 #ifdef CONFIG_I2C_COMPAT
1034 class_compat_unregister(i2c_adapter_compat_class);
1036 bus_unregister(&i2c_bus_type);
1039 /* We must initialize early, because some subsystems register i2c drivers
1040 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1042 postcore_initcall(i2c_init);
1043 module_exit(i2c_exit);
1045 /* ----------------------------------------------------
1046 * the functional interface to the i2c busses.
1047 * ----------------------------------------------------
1051 * i2c_transfer - execute a single or combined I2C message
1052 * @adap: Handle to I2C bus
1053 * @msgs: One or more messages to execute before STOP is issued to
1054 * terminate the operation; each message begins with a START.
1055 * @num: Number of messages to be executed.
1057 * Returns negative errno, else the number of messages executed.
1059 * Note that there is no requirement that each message be sent to
1060 * the same slave address, although that is the most common model.
1062 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1064 unsigned long orig_jiffies;
1067 /* REVISIT the fault reporting model here is weak:
1069 * - When we get an error after receiving N bytes from a slave,
1070 * there is no way to report "N".
1072 * - When we get a NAK after transmitting N bytes to a slave,
1073 * there is no way to report "N" ... or to let the master
1074 * continue executing the rest of this combined message, if
1075 * that's the appropriate response.
1077 * - When for example "num" is two and we successfully complete
1078 * the first message but get an error part way through the
1079 * second, it's unclear whether that should be reported as
1080 * one (discarding status on the second message) or errno
1081 * (discarding status on the first one).
1084 if (adap->algo->master_xfer) {
1086 for (ret = 0; ret < num; ret++) {
1087 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1088 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1089 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1090 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1094 if (in_atomic() || irqs_disabled()) {
1095 ret = mutex_trylock(&adap->bus_lock);
1097 /* I2C activity is ongoing. */
1100 mutex_lock_nested(&adap->bus_lock, adap->level);
1103 /* Retry automatically on arbitration loss */
1104 orig_jiffies = jiffies;
1105 for (ret = 0, try = 0; try <= adap->retries; try++) {
1106 ret = adap->algo->master_xfer(adap, msgs, num);
1109 if (time_after(jiffies, orig_jiffies + adap->timeout))
1112 mutex_unlock(&adap->bus_lock);
1116 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1120 EXPORT_SYMBOL(i2c_transfer);
1123 * i2c_master_send - issue a single I2C message in master transmit mode
1124 * @client: Handle to slave device
1125 * @buf: Data that will be written to the slave
1126 * @count: How many bytes to write
1128 * Returns negative errno, or else the number of bytes written.
1130 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1133 struct i2c_adapter *adap=client->adapter;
1136 msg.addr = client->addr;
1137 msg.flags = client->flags & I2C_M_TEN;
1139 msg.buf = (char *)buf;
1141 ret = i2c_transfer(adap, &msg, 1);
1143 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1144 transmitted, else error code. */
1145 return (ret == 1) ? count : ret;
1147 EXPORT_SYMBOL(i2c_master_send);
1150 * i2c_master_recv - issue a single I2C message in master receive mode
1151 * @client: Handle to slave device
1152 * @buf: Where to store data read from slave
1153 * @count: How many bytes to read
1155 * Returns negative errno, or else the number of bytes read.
1157 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1159 struct i2c_adapter *adap=client->adapter;
1163 msg.addr = client->addr;
1164 msg.flags = client->flags & I2C_M_TEN;
1165 msg.flags |= I2C_M_RD;
1169 ret = i2c_transfer(adap, &msg, 1);
1171 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1172 transmitted, else error code. */
1173 return (ret == 1) ? count : ret;
1175 EXPORT_SYMBOL(i2c_master_recv);
1177 /* ----------------------------------------------------
1178 * the i2c address scanning function
1179 * Will not work for 10-bit addresses!
1180 * ----------------------------------------------------
1183 static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1184 struct i2c_driver *driver)
1186 struct i2c_board_info info;
1187 struct i2c_adapter *adapter = temp_client->adapter;
1188 int addr = temp_client->addr;
1191 /* Make sure the address is valid */
1192 if (addr < 0x03 || addr > 0x77) {
1193 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1198 /* Skip if already in use */
1199 if (i2c_check_addr(adapter, addr))
1202 /* Make sure there is something at this address, unless forced */
1204 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1205 I2C_SMBUS_QUICK, NULL) < 0)
1208 /* prevent 24RF08 corruption */
1209 if ((addr & ~0x0f) == 0x50)
1210 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1211 I2C_SMBUS_QUICK, NULL);
1214 /* Finally call the custom detection function */
1215 memset(&info, 0, sizeof(struct i2c_board_info));
1217 err = driver->detect(temp_client, kind, &info);
1219 /* -ENODEV is returned if the detection fails. We catch it
1220 here as this isn't an error. */
1221 return err == -ENODEV ? 0 : err;
1224 /* Consistency check */
1225 if (info.type[0] == '\0') {
1226 dev_err(&adapter->dev, "%s detection function provided "
1227 "no name for 0x%x\n", driver->driver.name,
1230 struct i2c_client *client;
1232 /* Detection succeeded, instantiate the device */
1233 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1234 info.type, info.addr);
1235 client = i2c_new_device(adapter, &info);
1237 list_add_tail(&client->detected, &driver->clients);
1239 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1240 info.type, info.addr);
1245 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1247 const struct i2c_client_address_data *address_data;
1248 struct i2c_client *temp_client;
1250 int adap_id = i2c_adapter_id(adapter);
1252 address_data = driver->address_data;
1253 if (!driver->detect || !address_data)
1256 /* Set up a temporary client to help detect callback */
1257 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1260 temp_client->adapter = adapter;
1262 /* Force entries are done first, and are not affected by ignore
1264 if (address_data->forces) {
1265 const unsigned short * const *forces = address_data->forces;
1268 for (kind = 0; forces[kind]; kind++) {
1269 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1271 if (forces[kind][i] == adap_id
1272 || forces[kind][i] == ANY_I2C_BUS) {
1273 dev_dbg(&adapter->dev, "found force "
1274 "parameter for adapter %d, "
1275 "addr 0x%02x, kind %d\n",
1276 adap_id, forces[kind][i + 1],
1278 temp_client->addr = forces[kind][i + 1];
1279 err = i2c_detect_address(temp_client,
1288 /* Stop here if the classes do not match */
1289 if (!(adapter->class & driver->class))
1292 /* Stop here if we can't use SMBUS_QUICK */
1293 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1294 if (address_data->probe[0] == I2C_CLIENT_END
1295 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1298 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1299 "can't probe for chips\n");
1304 /* Probe entries are done second, and are not affected by ignore
1306 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1307 if (address_data->probe[i] == adap_id
1308 || address_data->probe[i] == ANY_I2C_BUS) {
1309 dev_dbg(&adapter->dev, "found probe parameter for "
1310 "adapter %d, addr 0x%02x\n", adap_id,
1311 address_data->probe[i + 1]);
1312 temp_client->addr = address_data->probe[i + 1];
1313 err = i2c_detect_address(temp_client, -1, driver);
1319 /* Normal entries are done last, unless shadowed by an ignore entry */
1320 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1324 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1326 if ((address_data->ignore[j] == adap_id ||
1327 address_data->ignore[j] == ANY_I2C_BUS)
1328 && address_data->ignore[j + 1]
1329 == address_data->normal_i2c[i]) {
1330 dev_dbg(&adapter->dev, "found ignore "
1331 "parameter for adapter %d, "
1332 "addr 0x%02x\n", adap_id,
1333 address_data->ignore[j + 1]);
1341 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1342 "addr 0x%02x\n", adap_id,
1343 address_data->normal_i2c[i]);
1344 temp_client->addr = address_data->normal_i2c[i];
1345 err = i2c_detect_address(temp_client, -1, driver);
1356 i2c_new_probed_device(struct i2c_adapter *adap,
1357 struct i2c_board_info *info,
1358 unsigned short const *addr_list)
1362 /* Stop here if the bus doesn't support probing */
1363 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1364 dev_err(&adap->dev, "Probing not supported\n");
1368 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1369 /* Check address validity */
1370 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1371 dev_warn(&adap->dev, "Invalid 7-bit address "
1372 "0x%02x\n", addr_list[i]);
1376 /* Check address availability */
1377 if (i2c_check_addr(adap, addr_list[i])) {
1378 dev_dbg(&adap->dev, "Address 0x%02x already in "
1379 "use, not probing\n", addr_list[i]);
1383 /* Test address responsiveness
1384 The default probe method is a quick write, but it is known
1385 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1386 and could also irreversibly write-protect some EEPROMs, so
1387 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1388 read instead. Also, some bus drivers don't implement
1389 quick write, so we fallback to a byte read it that case
1391 if ((addr_list[i] & ~0x07) == 0x30
1392 || (addr_list[i] & ~0x0f) == 0x50
1393 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1394 union i2c_smbus_data data;
1396 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1398 I2C_SMBUS_BYTE, &data) >= 0)
1401 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1403 I2C_SMBUS_QUICK, NULL) >= 0)
1408 if (addr_list[i] == I2C_CLIENT_END) {
1409 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1413 info->addr = addr_list[i];
1414 return i2c_new_device(adap, info);
1416 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1418 struct i2c_adapter* i2c_get_adapter(int id)
1420 struct i2c_adapter *adapter;
1422 mutex_lock(&core_lock);
1423 adapter = idr_find(&i2c_adapter_idr, id);
1424 if (adapter && !try_module_get(adapter->owner))
1427 mutex_unlock(&core_lock);
1430 EXPORT_SYMBOL(i2c_get_adapter);
1432 void i2c_put_adapter(struct i2c_adapter *adap)
1434 module_put(adap->owner);
1436 EXPORT_SYMBOL(i2c_put_adapter);
1438 /* The SMBus parts */
1440 #define POLY (0x1070U << 3)
1441 static u8 crc8(u16 data)
1445 for(i = 0; i < 8; i++) {
1450 return (u8)(data >> 8);
1453 /* Incremental CRC8 over count bytes in the array pointed to by p */
1454 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1458 for(i = 0; i < count; i++)
1459 crc = crc8((crc ^ p[i]) << 8);
1463 /* Assume a 7-bit address, which is reasonable for SMBus */
1464 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1466 /* The address will be sent first */
1467 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1468 pec = i2c_smbus_pec(pec, &addr, 1);
1470 /* The data buffer follows */
1471 return i2c_smbus_pec(pec, msg->buf, msg->len);
1474 /* Used for write only transactions */
1475 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1477 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1481 /* Return <0 on CRC error
1482 If there was a write before this read (most cases) we need to take the
1483 partial CRC from the write part into account.
1484 Note that this function does modify the message (we need to decrease the
1485 message length to hide the CRC byte from the caller). */
1486 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1488 u8 rpec = msg->buf[--msg->len];
1489 cpec = i2c_smbus_msg_pec(cpec, msg);
1492 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1500 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1501 * @client: Handle to slave device
1503 * This executes the SMBus "receive byte" protocol, returning negative errno
1504 * else the byte received from the device.
1506 s32 i2c_smbus_read_byte(struct i2c_client *client)
1508 union i2c_smbus_data data;
1511 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1513 I2C_SMBUS_BYTE, &data);
1514 return (status < 0) ? status : data.byte;
1516 EXPORT_SYMBOL(i2c_smbus_read_byte);
1519 * i2c_smbus_write_byte - SMBus "send byte" protocol
1520 * @client: Handle to slave device
1521 * @value: Byte to be sent
1523 * This executes the SMBus "send byte" protocol, returning negative errno
1524 * else zero on success.
1526 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1528 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1529 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1531 EXPORT_SYMBOL(i2c_smbus_write_byte);
1534 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1535 * @client: Handle to slave device
1536 * @command: Byte interpreted by slave
1538 * This executes the SMBus "read byte" protocol, returning negative errno
1539 * else a data byte received from the device.
1541 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1543 union i2c_smbus_data data;
1546 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1547 I2C_SMBUS_READ, command,
1548 I2C_SMBUS_BYTE_DATA, &data);
1549 return (status < 0) ? status : data.byte;
1551 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1554 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1555 * @client: Handle to slave device
1556 * @command: Byte interpreted by slave
1557 * @value: Byte being written
1559 * This executes the SMBus "write byte" protocol, returning negative errno
1560 * else zero on success.
1562 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1564 union i2c_smbus_data data;
1566 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1567 I2C_SMBUS_WRITE,command,
1568 I2C_SMBUS_BYTE_DATA,&data);
1570 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1573 * i2c_smbus_read_word_data - SMBus "read word" protocol
1574 * @client: Handle to slave device
1575 * @command: Byte interpreted by slave
1577 * This executes the SMBus "read word" protocol, returning negative errno
1578 * else a 16-bit unsigned "word" received from the device.
1580 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1582 union i2c_smbus_data data;
1585 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1586 I2C_SMBUS_READ, command,
1587 I2C_SMBUS_WORD_DATA, &data);
1588 return (status < 0) ? status : data.word;
1590 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1593 * i2c_smbus_write_word_data - SMBus "write word" protocol
1594 * @client: Handle to slave device
1595 * @command: Byte interpreted by slave
1596 * @value: 16-bit "word" being written
1598 * This executes the SMBus "write word" protocol, returning negative errno
1599 * else zero on success.
1601 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1603 union i2c_smbus_data data;
1605 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1606 I2C_SMBUS_WRITE,command,
1607 I2C_SMBUS_WORD_DATA,&data);
1609 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1612 * i2c_smbus_process_call - SMBus "process call" protocol
1613 * @client: Handle to slave device
1614 * @command: Byte interpreted by slave
1615 * @value: 16-bit "word" being written
1617 * This executes the SMBus "process call" protocol, returning negative errno
1618 * else a 16-bit unsigned "word" received from the device.
1620 s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1622 union i2c_smbus_data data;
1626 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1627 I2C_SMBUS_WRITE, command,
1628 I2C_SMBUS_PROC_CALL, &data);
1629 return (status < 0) ? status : data.word;
1631 EXPORT_SYMBOL(i2c_smbus_process_call);
1634 * i2c_smbus_read_block_data - SMBus "block read" protocol
1635 * @client: Handle to slave device
1636 * @command: Byte interpreted by slave
1637 * @values: Byte array into which data will be read; big enough to hold
1638 * the data returned by the slave. SMBus allows at most 32 bytes.
1640 * This executes the SMBus "block read" protocol, returning negative errno
1641 * else the number of data bytes in the slave's response.
1643 * Note that using this function requires that the client's adapter support
1644 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1645 * support this; its emulation through I2C messaging relies on a specific
1646 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1648 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1651 union i2c_smbus_data data;
1654 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1655 I2C_SMBUS_READ, command,
1656 I2C_SMBUS_BLOCK_DATA, &data);
1660 memcpy(values, &data.block[1], data.block[0]);
1661 return data.block[0];
1663 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1666 * i2c_smbus_write_block_data - SMBus "block write" protocol
1667 * @client: Handle to slave device
1668 * @command: Byte interpreted by slave
1669 * @length: Size of data block; SMBus allows at most 32 bytes
1670 * @values: Byte array which will be written.
1672 * This executes the SMBus "block write" protocol, returning negative errno
1673 * else zero on success.
1675 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1676 u8 length, const u8 *values)
1678 union i2c_smbus_data data;
1680 if (length > I2C_SMBUS_BLOCK_MAX)
1681 length = I2C_SMBUS_BLOCK_MAX;
1682 data.block[0] = length;
1683 memcpy(&data.block[1], values, length);
1684 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1685 I2C_SMBUS_WRITE,command,
1686 I2C_SMBUS_BLOCK_DATA,&data);
1688 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1690 /* Returns the number of read bytes */
1691 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1692 u8 length, u8 *values)
1694 union i2c_smbus_data data;
1697 if (length > I2C_SMBUS_BLOCK_MAX)
1698 length = I2C_SMBUS_BLOCK_MAX;
1699 data.block[0] = length;
1700 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1701 I2C_SMBUS_READ, command,
1702 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1706 memcpy(values, &data.block[1], data.block[0]);
1707 return data.block[0];
1709 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1711 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1712 u8 length, const u8 *values)
1714 union i2c_smbus_data data;
1716 if (length > I2C_SMBUS_BLOCK_MAX)
1717 length = I2C_SMBUS_BLOCK_MAX;
1718 data.block[0] = length;
1719 memcpy(data.block + 1, values, length);
1720 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1721 I2C_SMBUS_WRITE, command,
1722 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1724 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1726 /* Simulate a SMBus command using the i2c protocol
1727 No checking of parameters is done! */
1728 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1729 unsigned short flags,
1730 char read_write, u8 command, int size,
1731 union i2c_smbus_data * data)
1733 /* So we need to generate a series of msgs. In the case of writing, we
1734 need to use only one message; when reading, we need two. We initialize
1735 most things with sane defaults, to keep the code below somewhat
1737 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1738 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1739 int num = read_write == I2C_SMBUS_READ?2:1;
1740 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1741 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1747 msgbuf0[0] = command;
1749 case I2C_SMBUS_QUICK:
1751 /* Special case: The read/write field is used as data */
1752 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1756 case I2C_SMBUS_BYTE:
1757 if (read_write == I2C_SMBUS_READ) {
1758 /* Special case: only a read! */
1759 msg[0].flags = I2C_M_RD | flags;
1763 case I2C_SMBUS_BYTE_DATA:
1764 if (read_write == I2C_SMBUS_READ)
1768 msgbuf0[1] = data->byte;
1771 case I2C_SMBUS_WORD_DATA:
1772 if (read_write == I2C_SMBUS_READ)
1776 msgbuf0[1] = data->word & 0xff;
1777 msgbuf0[2] = data->word >> 8;
1780 case I2C_SMBUS_PROC_CALL:
1781 num = 2; /* Special case */
1782 read_write = I2C_SMBUS_READ;
1785 msgbuf0[1] = data->word & 0xff;
1786 msgbuf0[2] = data->word >> 8;
1788 case I2C_SMBUS_BLOCK_DATA:
1789 if (read_write == I2C_SMBUS_READ) {
1790 msg[1].flags |= I2C_M_RECV_LEN;
1791 msg[1].len = 1; /* block length will be added by
1792 the underlying bus driver */
1794 msg[0].len = data->block[0] + 2;
1795 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1796 dev_err(&adapter->dev,
1797 "Invalid block write size %d\n",
1801 for (i = 1; i < msg[0].len; i++)
1802 msgbuf0[i] = data->block[i-1];
1805 case I2C_SMBUS_BLOCK_PROC_CALL:
1806 num = 2; /* Another special case */
1807 read_write = I2C_SMBUS_READ;
1808 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1809 dev_err(&adapter->dev,
1810 "Invalid block write size %d\n",
1814 msg[0].len = data->block[0] + 2;
1815 for (i = 1; i < msg[0].len; i++)
1816 msgbuf0[i] = data->block[i-1];
1817 msg[1].flags |= I2C_M_RECV_LEN;
1818 msg[1].len = 1; /* block length will be added by
1819 the underlying bus driver */
1821 case I2C_SMBUS_I2C_BLOCK_DATA:
1822 if (read_write == I2C_SMBUS_READ) {
1823 msg[1].len = data->block[0];
1825 msg[0].len = data->block[0] + 1;
1826 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1827 dev_err(&adapter->dev,
1828 "Invalid block write size %d\n",
1832 for (i = 1; i <= data->block[0]; i++)
1833 msgbuf0[i] = data->block[i];
1837 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1841 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1842 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1844 /* Compute PEC if first message is a write */
1845 if (!(msg[0].flags & I2C_M_RD)) {
1846 if (num == 1) /* Write only */
1847 i2c_smbus_add_pec(&msg[0]);
1848 else /* Write followed by read */
1849 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1851 /* Ask for PEC if last message is a read */
1852 if (msg[num-1].flags & I2C_M_RD)
1856 status = i2c_transfer(adapter, msg, num);
1860 /* Check PEC if last message is a read */
1861 if (i && (msg[num-1].flags & I2C_M_RD)) {
1862 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1867 if (read_write == I2C_SMBUS_READ)
1869 case I2C_SMBUS_BYTE:
1870 data->byte = msgbuf0[0];
1872 case I2C_SMBUS_BYTE_DATA:
1873 data->byte = msgbuf1[0];
1875 case I2C_SMBUS_WORD_DATA:
1876 case I2C_SMBUS_PROC_CALL:
1877 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1879 case I2C_SMBUS_I2C_BLOCK_DATA:
1880 for (i = 0; i < data->block[0]; i++)
1881 data->block[i+1] = msgbuf1[i];
1883 case I2C_SMBUS_BLOCK_DATA:
1884 case I2C_SMBUS_BLOCK_PROC_CALL:
1885 for (i = 0; i < msgbuf1[0] + 1; i++)
1886 data->block[i] = msgbuf1[i];
1893 * i2c_smbus_xfer - execute SMBus protocol operations
1894 * @adapter: Handle to I2C bus
1895 * @addr: Address of SMBus slave on that bus
1896 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1897 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1898 * @command: Byte interpreted by slave, for protocols which use such bytes
1899 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1900 * @data: Data to be read or written
1902 * This executes an SMBus protocol operation, and returns a negative
1903 * errno code else zero on success.
1905 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
1906 char read_write, u8 command, int protocol,
1907 union i2c_smbus_data *data)
1909 unsigned long orig_jiffies;
1913 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1915 if (adapter->algo->smbus_xfer) {
1916 mutex_lock(&adapter->bus_lock);
1918 /* Retry automatically on arbitration loss */
1919 orig_jiffies = jiffies;
1920 for (res = 0, try = 0; try <= adapter->retries; try++) {
1921 res = adapter->algo->smbus_xfer(adapter, addr, flags,
1922 read_write, command,
1926 if (time_after(jiffies,
1927 orig_jiffies + adapter->timeout))
1930 mutex_unlock(&adapter->bus_lock);
1932 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1933 command, protocol, data);
1937 EXPORT_SYMBOL(i2c_smbus_xfer);
1939 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1940 MODULE_DESCRIPTION("I2C-Bus main module");
1941 MODULE_LICENSE("GPL");