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/platform_device.h>
33 #include <linux/mutex.h>
34 #include <linux/completion.h>
35 #include <linux/hardirq.h>
36 #include <linux/irqflags.h>
37 #include <asm/uaccess.h>
42 static DEFINE_MUTEX(core_lock);
43 static DEFINE_IDR(i2c_adapter_idr);
45 #define is_newstyle_driver(d) ((d)->probe || (d)->remove || (d)->detect)
47 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
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;
82 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
83 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
85 struct i2c_client *client = to_i2c_client(dev);
87 /* by definition, legacy drivers can't hotplug */
91 if (add_uevent_var(env, "MODALIAS=%s%s",
92 I2C_MODULE_PREFIX, client->name))
94 dev_dbg(dev, "uevent\n");
99 #define i2c_device_uevent NULL
100 #endif /* CONFIG_HOTPLUG */
102 static int i2c_device_probe(struct device *dev)
104 struct i2c_client *client = to_i2c_client(dev);
105 struct i2c_driver *driver = to_i2c_driver(dev->driver);
108 if (!driver->probe || !driver->id_table)
110 client->driver = driver;
111 if (!device_can_wakeup(&client->dev))
112 device_init_wakeup(&client->dev,
113 client->flags & I2C_CLIENT_WAKE);
114 dev_dbg(dev, "probe\n");
116 status = driver->probe(client, i2c_match_id(driver->id_table, client));
118 client->driver = NULL;
122 static int i2c_device_remove(struct device *dev)
124 struct i2c_client *client = to_i2c_client(dev);
125 struct i2c_driver *driver;
131 driver = to_i2c_driver(dev->driver);
132 if (driver->remove) {
133 dev_dbg(dev, "remove\n");
134 status = driver->remove(client);
140 client->driver = NULL;
144 static void i2c_device_shutdown(struct device *dev)
146 struct i2c_driver *driver;
150 driver = to_i2c_driver(dev->driver);
151 if (driver->shutdown)
152 driver->shutdown(to_i2c_client(dev));
155 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
157 struct i2c_driver *driver;
161 driver = to_i2c_driver(dev->driver);
162 if (!driver->suspend)
164 return driver->suspend(to_i2c_client(dev), mesg);
167 static int i2c_device_resume(struct device * dev)
169 struct i2c_driver *driver;
173 driver = to_i2c_driver(dev->driver);
176 return driver->resume(to_i2c_client(dev));
179 static void i2c_client_release(struct device *dev)
181 struct i2c_client *client = to_i2c_client(dev);
182 complete(&client->released);
185 static void i2c_client_dev_release(struct device *dev)
187 kfree(to_i2c_client(dev));
190 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
192 struct i2c_client *client = to_i2c_client(dev);
193 return sprintf(buf, "%s\n", client->name);
196 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
198 struct i2c_client *client = to_i2c_client(dev);
199 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
202 static struct device_attribute i2c_dev_attrs[] = {
203 __ATTR(name, S_IRUGO, show_client_name, NULL),
204 /* modalias helps coldplug: modprobe $(cat .../modalias) */
205 __ATTR(modalias, S_IRUGO, show_modalias, NULL),
209 struct bus_type i2c_bus_type = {
211 .dev_attrs = i2c_dev_attrs,
212 .match = i2c_device_match,
213 .uevent = i2c_device_uevent,
214 .probe = i2c_device_probe,
215 .remove = i2c_device_remove,
216 .shutdown = i2c_device_shutdown,
217 .suspend = i2c_device_suspend,
218 .resume = i2c_device_resume,
220 EXPORT_SYMBOL_GPL(i2c_bus_type);
224 * i2c_verify_client - return parameter as i2c_client, or NULL
225 * @dev: device, probably from some driver model iterator
227 * When traversing the driver model tree, perhaps using driver model
228 * iterators like @device_for_each_child(), you can't assume very much
229 * about the nodes you find. Use this function to avoid oopses caused
230 * by wrongly treating some non-I2C device as an i2c_client.
232 struct i2c_client *i2c_verify_client(struct device *dev)
234 return (dev->bus == &i2c_bus_type)
238 EXPORT_SYMBOL(i2c_verify_client);
242 * i2c_new_device - instantiate an i2c device for use with a new style driver
243 * @adap: the adapter managing the device
244 * @info: describes one I2C device; bus_num is ignored
247 * Create a device to work with a new style i2c driver, where binding is
248 * handled through driver model probe()/remove() methods. This call is not
249 * appropriate for use by mainboad initialization logic, which usually runs
250 * during an arch_initcall() long before any i2c_adapter could exist.
252 * This returns the new i2c client, which may be saved for later use with
253 * i2c_unregister_device(); or NULL to indicate an error.
256 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
258 struct i2c_client *client;
261 client = kzalloc(sizeof *client, GFP_KERNEL);
265 client->adapter = adap;
267 client->dev.platform_data = info->platform_data;
270 client->dev.archdata = *info->archdata;
272 client->flags = info->flags;
273 client->addr = info->addr;
274 client->irq = info->irq;
276 strlcpy(client->name, info->type, sizeof(client->name));
278 /* a new style driver may be bound to this device when we
279 * return from this function, or any later moment (e.g. maybe
280 * hotplugging will load the driver module). and the device
281 * refcount model is the standard driver model one.
283 status = i2c_attach_client(client);
290 EXPORT_SYMBOL_GPL(i2c_new_device);
294 * i2c_unregister_device - reverse effect of i2c_new_device()
295 * @client: value returned from i2c_new_device()
298 void i2c_unregister_device(struct i2c_client *client)
300 struct i2c_adapter *adapter = client->adapter;
301 struct i2c_driver *driver = client->driver;
303 if (driver && !is_newstyle_driver(driver)) {
304 dev_err(&client->dev, "can't unregister devices "
305 "with legacy drivers\n");
310 if (adapter->client_unregister) {
311 if (adapter->client_unregister(client)) {
312 dev_warn(&client->dev,
313 "client_unregister [%s] failed\n",
318 mutex_lock(&adapter->clist_lock);
319 list_del(&client->list);
320 mutex_unlock(&adapter->clist_lock);
322 device_unregister(&client->dev);
324 EXPORT_SYMBOL_GPL(i2c_unregister_device);
327 static const struct i2c_device_id dummy_id[] = {
332 static int dummy_probe(struct i2c_client *client,
333 const struct i2c_device_id *id)
338 static int dummy_remove(struct i2c_client *client)
343 static struct i2c_driver dummy_driver = {
344 .driver.name = "dummy",
345 .probe = dummy_probe,
346 .remove = dummy_remove,
347 .id_table = dummy_id,
351 * i2c_new_dummy - return a new i2c device bound to a dummy driver
352 * @adapter: the adapter managing the device
353 * @address: seven bit address to be used
356 * This returns an I2C client bound to the "dummy" driver, intended for use
357 * with devices that consume multiple addresses. Examples of such chips
358 * include various EEPROMS (like 24c04 and 24c08 models).
360 * These dummy devices have two main uses. First, most I2C and SMBus calls
361 * except i2c_transfer() need a client handle; the dummy will be that handle.
362 * And second, this prevents the specified address from being bound to a
365 * This returns the new i2c client, which should be saved for later use with
366 * i2c_unregister_device(); or NULL to indicate an error.
369 i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
371 struct i2c_board_info info = {
372 I2C_BOARD_INFO("dummy", address),
375 return i2c_new_device(adapter, &info);
377 EXPORT_SYMBOL_GPL(i2c_new_dummy);
379 /* ------------------------------------------------------------------------- */
381 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
383 static void i2c_adapter_dev_release(struct device *dev)
385 struct i2c_adapter *adap = to_i2c_adapter(dev);
386 complete(&adap->dev_released);
390 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
392 struct i2c_adapter *adap = to_i2c_adapter(dev);
393 return sprintf(buf, "%s\n", adap->name);
396 static struct device_attribute i2c_adapter_attrs[] = {
397 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
401 static struct class i2c_adapter_class = {
402 .owner = THIS_MODULE,
403 .name = "i2c-adapter",
404 .dev_attrs = i2c_adapter_attrs,
407 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
409 struct i2c_devinfo *devinfo;
411 mutex_lock(&__i2c_board_lock);
412 list_for_each_entry(devinfo, &__i2c_board_list, list) {
413 if (devinfo->busnum == adapter->nr
414 && !i2c_new_device(adapter,
415 &devinfo->board_info))
416 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
417 i2c_adapter_id(adapter),
418 devinfo->board_info.addr);
420 mutex_unlock(&__i2c_board_lock);
423 static int i2c_do_add_adapter(struct device_driver *d, void *data)
425 struct i2c_driver *driver = to_i2c_driver(d);
426 struct i2c_adapter *adap = data;
428 /* Detect supported devices on that bus, and instantiate them */
429 i2c_detect(adap, driver);
431 /* Let legacy drivers scan this bus for matching devices */
432 if (driver->attach_adapter) {
433 /* We ignore the return code; if it fails, too bad */
434 driver->attach_adapter(adap);
439 static int i2c_register_adapter(struct i2c_adapter *adap)
443 /* Can't register until after driver model init */
444 if (unlikely(WARN_ON(!i2c_bus_type.p)))
447 mutex_init(&adap->bus_lock);
448 mutex_init(&adap->clist_lock);
449 INIT_LIST_HEAD(&adap->clients);
451 mutex_lock(&core_lock);
453 /* Add the adapter to the driver core.
454 * If the parent pointer is not set up,
455 * we add this adapter to the host bus.
457 if (adap->dev.parent == NULL) {
458 adap->dev.parent = &platform_bus;
459 pr_debug("I2C adapter driver [%s] forgot to specify "
460 "physical device\n", adap->name);
463 /* Set default timeout to 1 second if not already set */
464 if (adap->timeout == 0)
467 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
468 adap->dev.release = &i2c_adapter_dev_release;
469 adap->dev.class = &i2c_adapter_class;
470 res = device_register(&adap->dev);
474 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
476 /* create pre-declared device nodes for new-style drivers */
477 if (adap->nr < __i2c_first_dynamic_bus_num)
478 i2c_scan_static_board_info(adap);
481 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
485 mutex_unlock(&core_lock);
489 idr_remove(&i2c_adapter_idr, adap->nr);
494 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
495 * @adapter: the adapter to add
498 * This routine is used to declare an I2C adapter when its bus number
499 * doesn't matter. Examples: for I2C adapters dynamically added by
500 * USB links or PCI plugin cards.
502 * When this returns zero, a new bus number was allocated and stored
503 * in adap->nr, and the specified adapter became available for clients.
504 * Otherwise, a negative errno value is returned.
506 int i2c_add_adapter(struct i2c_adapter *adapter)
511 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
514 mutex_lock(&core_lock);
515 /* "above" here means "above or equal to", sigh */
516 res = idr_get_new_above(&i2c_adapter_idr, adapter,
517 __i2c_first_dynamic_bus_num, &id);
518 mutex_unlock(&core_lock);
527 return i2c_register_adapter(adapter);
529 EXPORT_SYMBOL(i2c_add_adapter);
532 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
533 * @adap: the adapter to register (with adap->nr initialized)
536 * This routine is used to declare an I2C adapter when its bus number
537 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
538 * or otherwise built in to the system's mainboard, and where i2c_board_info
539 * is used to properly configure I2C devices.
541 * If no devices have pre-been declared for this bus, then be sure to
542 * register the adapter before any dynamically allocated ones. Otherwise
543 * the required bus ID may not be available.
545 * When this returns zero, the specified adapter became available for
546 * clients using the bus number provided in adap->nr. Also, the table
547 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
548 * and the appropriate driver model device nodes are created. Otherwise, a
549 * negative errno value is returned.
551 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
556 if (adap->nr & ~MAX_ID_MASK)
560 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
563 mutex_lock(&core_lock);
564 /* "above" here means "above or equal to", sigh;
565 * we need the "equal to" result to force the result
567 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
568 if (status == 0 && id != adap->nr) {
570 idr_remove(&i2c_adapter_idr, id);
572 mutex_unlock(&core_lock);
573 if (status == -EAGAIN)
577 status = i2c_register_adapter(adap);
580 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
582 static int i2c_do_del_adapter(struct device_driver *d, void *data)
584 struct i2c_driver *driver = to_i2c_driver(d);
585 struct i2c_adapter *adapter = data;
586 struct i2c_client *client, *_n;
589 /* Remove the devices we created ourselves as the result of hardware
590 * probing (using a driver's detect method) */
591 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
592 if (client->adapter == adapter) {
593 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
594 client->name, client->addr);
595 list_del(&client->detected);
596 i2c_unregister_device(client);
600 if (!driver->detach_adapter)
602 res = driver->detach_adapter(adapter);
604 dev_err(&adapter->dev, "detach_adapter failed (%d) "
605 "for driver [%s]\n", res, driver->driver.name);
610 * i2c_del_adapter - unregister I2C adapter
611 * @adap: the adapter being unregistered
614 * This unregisters an I2C adapter which was previously registered
615 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
617 int i2c_del_adapter(struct i2c_adapter *adap)
619 struct i2c_client *client, *_n;
622 mutex_lock(&core_lock);
624 /* First make sure that this adapter was ever added */
625 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
626 pr_debug("i2c-core: attempting to delete unregistered "
627 "adapter [%s]\n", adap->name);
632 /* Tell drivers about this removal */
633 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
638 /* detach any active clients. This must be done first, because
639 * it can fail; in which case we give up. */
640 list_for_each_entry_safe_reverse(client, _n, &adap->clients, list) {
641 struct i2c_driver *driver;
643 driver = client->driver;
645 /* new style, follow standard driver model */
646 if (!driver || is_newstyle_driver(driver)) {
647 i2c_unregister_device(client);
651 /* legacy drivers create and remove clients themselves */
652 if ((res = driver->detach_client(client))) {
653 dev_err(&adap->dev, "detach_client failed for client "
654 "[%s] at address 0x%02x\n", client->name,
660 /* clean up the sysfs representation */
661 init_completion(&adap->dev_released);
662 device_unregister(&adap->dev);
664 /* wait for sysfs to drop all references */
665 wait_for_completion(&adap->dev_released);
668 idr_remove(&i2c_adapter_idr, adap->nr);
670 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
672 /* Clear the device structure in case this adapter is ever going to be
674 memset(&adap->dev, 0, sizeof(adap->dev));
677 mutex_unlock(&core_lock);
680 EXPORT_SYMBOL(i2c_del_adapter);
683 /* ------------------------------------------------------------------------- */
685 static int __attach_adapter(struct device *dev, void *data)
687 struct i2c_adapter *adapter = to_i2c_adapter(dev);
688 struct i2c_driver *driver = data;
690 i2c_detect(adapter, driver);
692 /* Legacy drivers scan i2c busses directly */
693 if (driver->attach_adapter)
694 driver->attach_adapter(adapter);
700 * An i2c_driver is used with one or more i2c_client (device) nodes to access
701 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
702 * are two models for binding the driver to its device: "new style" drivers
703 * follow the standard Linux driver model and just respond to probe() calls
704 * issued if the driver core sees they match(); "legacy" drivers create device
708 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
712 /* Can't register until after driver model init */
713 if (unlikely(WARN_ON(!i2c_bus_type.p)))
716 /* new style driver methods can't mix with legacy ones */
717 if (is_newstyle_driver(driver)) {
718 if (driver->attach_adapter || driver->detach_adapter
719 || driver->detach_client) {
721 "i2c-core: driver [%s] is confused\n",
722 driver->driver.name);
727 /* add the driver to the list of i2c drivers in the driver core */
728 driver->driver.owner = owner;
729 driver->driver.bus = &i2c_bus_type;
731 /* for new style drivers, when registration returns the driver core
732 * will have called probe() for all matching-but-unbound devices.
734 res = driver_register(&driver->driver);
738 mutex_lock(&core_lock);
740 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
742 INIT_LIST_HEAD(&driver->clients);
743 /* Walk the adapters that are already present */
744 class_for_each_device(&i2c_adapter_class, NULL, driver,
747 mutex_unlock(&core_lock);
750 EXPORT_SYMBOL(i2c_register_driver);
752 static int __detach_adapter(struct device *dev, void *data)
754 struct i2c_adapter *adapter = to_i2c_adapter(dev);
755 struct i2c_driver *driver = data;
756 struct i2c_client *client, *_n;
758 /* Remove the devices we created ourselves as the result of hardware
759 * probing (using a driver's detect method) */
760 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
761 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
762 client->name, client->addr);
763 list_del(&client->detected);
764 i2c_unregister_device(client);
767 if (is_newstyle_driver(driver))
770 /* Have a look at each adapter, if clients of this driver are still
771 * attached. If so, detach them to be able to kill the driver
774 if (driver->detach_adapter) {
775 if (driver->detach_adapter(adapter))
776 dev_err(&adapter->dev,
777 "detach_adapter failed for driver [%s]\n",
778 driver->driver.name);
780 struct i2c_client *client, *_n;
782 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
783 if (client->driver != driver)
785 dev_dbg(&adapter->dev,
786 "detaching client [%s] at 0x%02x\n",
787 client->name, client->addr);
788 if (driver->detach_client(client))
789 dev_err(&adapter->dev, "detach_client "
790 "failed for client [%s] at 0x%02x\n",
791 client->name, client->addr);
799 * i2c_del_driver - unregister I2C driver
800 * @driver: the driver being unregistered
803 void i2c_del_driver(struct i2c_driver *driver)
805 mutex_lock(&core_lock);
807 class_for_each_device(&i2c_adapter_class, NULL, driver,
810 driver_unregister(&driver->driver);
811 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
813 mutex_unlock(&core_lock);
815 EXPORT_SYMBOL(i2c_del_driver);
817 /* ------------------------------------------------------------------------- */
819 static int __i2c_check_addr(struct device *dev, void *addrp)
821 struct i2c_client *client = i2c_verify_client(dev);
822 int addr = *(int *)addrp;
824 if (client && client->addr == addr)
829 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
831 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
834 int i2c_attach_client(struct i2c_client *client)
836 struct i2c_adapter *adapter = client->adapter;
839 /* Check for address business */
840 res = i2c_check_addr(adapter, client->addr);
844 client->dev.parent = &client->adapter->dev;
845 client->dev.bus = &i2c_bus_type;
848 client->dev.driver = &client->driver->driver;
850 if (client->driver && !is_newstyle_driver(client->driver)) {
851 client->dev.release = i2c_client_release;
852 dev_set_uevent_suppress(&client->dev, 1);
854 client->dev.release = i2c_client_dev_release;
856 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adapter),
858 res = device_register(&client->dev);
862 mutex_lock(&adapter->clist_lock);
863 list_add_tail(&client->list, &adapter->clients);
864 mutex_unlock(&adapter->clist_lock);
866 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
867 client->name, dev_name(&client->dev));
869 if (adapter->client_register) {
870 if (adapter->client_register(client)) {
871 dev_dbg(&adapter->dev, "client_register "
872 "failed for client [%s] at 0x%02x\n",
873 client->name, client->addr);
880 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
881 "(%d)\n", client->name, client->addr, res);
884 EXPORT_SYMBOL(i2c_attach_client);
886 int i2c_detach_client(struct i2c_client *client)
888 struct i2c_adapter *adapter = client->adapter;
891 if (adapter->client_unregister) {
892 res = adapter->client_unregister(client);
894 dev_err(&client->dev,
895 "client_unregister [%s] failed, "
896 "client not detached\n", client->name);
901 mutex_lock(&adapter->clist_lock);
902 list_del(&client->list);
903 mutex_unlock(&adapter->clist_lock);
905 init_completion(&client->released);
906 device_unregister(&client->dev);
907 wait_for_completion(&client->released);
912 EXPORT_SYMBOL(i2c_detach_client);
915 * i2c_use_client - increments the reference count of the i2c client structure
916 * @client: the client being referenced
918 * Each live reference to a client should be refcounted. The driver model does
919 * that automatically as part of driver binding, so that most drivers don't
920 * need to do this explicitly: they hold a reference until they're unbound
923 * A pointer to the client with the incremented reference counter is returned.
925 struct i2c_client *i2c_use_client(struct i2c_client *client)
927 if (client && get_device(&client->dev))
931 EXPORT_SYMBOL(i2c_use_client);
934 * i2c_release_client - release a use of the i2c client structure
935 * @client: the client being no longer referenced
937 * Must be called when a user of a client is finished with it.
939 void i2c_release_client(struct i2c_client *client)
942 put_device(&client->dev);
944 EXPORT_SYMBOL(i2c_release_client);
951 static int i2c_cmd(struct device *dev, void *_arg)
953 struct i2c_client *client = i2c_verify_client(dev);
954 struct i2c_cmd_arg *arg = _arg;
956 if (client && client->driver && client->driver->command)
957 client->driver->command(client, arg->cmd, arg->arg);
961 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
963 struct i2c_cmd_arg cmd_arg;
967 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
969 EXPORT_SYMBOL(i2c_clients_command);
971 static int __init i2c_init(void)
975 retval = bus_register(&i2c_bus_type);
978 retval = class_register(&i2c_adapter_class);
981 retval = i2c_add_driver(&dummy_driver);
987 class_unregister(&i2c_adapter_class);
989 bus_unregister(&i2c_bus_type);
993 static void __exit i2c_exit(void)
995 i2c_del_driver(&dummy_driver);
996 class_unregister(&i2c_adapter_class);
997 bus_unregister(&i2c_bus_type);
1000 /* We must initialize early, because some subsystems register i2c drivers
1001 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1003 postcore_initcall(i2c_init);
1004 module_exit(i2c_exit);
1006 /* ----------------------------------------------------
1007 * the functional interface to the i2c busses.
1008 * ----------------------------------------------------
1012 * i2c_transfer - execute a single or combined I2C message
1013 * @adap: Handle to I2C bus
1014 * @msgs: One or more messages to execute before STOP is issued to
1015 * terminate the operation; each message begins with a START.
1016 * @num: Number of messages to be executed.
1018 * Returns negative errno, else the number of messages executed.
1020 * Note that there is no requirement that each message be sent to
1021 * the same slave address, although that is the most common model.
1023 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
1027 /* REVISIT the fault reporting model here is weak:
1029 * - When we get an error after receiving N bytes from a slave,
1030 * there is no way to report "N".
1032 * - When we get a NAK after transmitting N bytes to a slave,
1033 * there is no way to report "N" ... or to let the master
1034 * continue executing the rest of this combined message, if
1035 * that's the appropriate response.
1037 * - When for example "num" is two and we successfully complete
1038 * the first message but get an error part way through the
1039 * second, it's unclear whether that should be reported as
1040 * one (discarding status on the second message) or errno
1041 * (discarding status on the first one).
1044 if (adap->algo->master_xfer) {
1046 for (ret = 0; ret < num; ret++) {
1047 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1048 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1049 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1050 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1054 if (in_atomic() || irqs_disabled()) {
1055 ret = mutex_trylock(&adap->bus_lock);
1057 /* I2C activity is ongoing. */
1060 mutex_lock_nested(&adap->bus_lock, adap->level);
1063 ret = adap->algo->master_xfer(adap,msgs,num);
1064 mutex_unlock(&adap->bus_lock);
1068 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1072 EXPORT_SYMBOL(i2c_transfer);
1075 * i2c_master_send - issue a single I2C message in master transmit mode
1076 * @client: Handle to slave device
1077 * @buf: Data that will be written to the slave
1078 * @count: How many bytes to write
1080 * Returns negative errno, or else the number of bytes written.
1082 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1085 struct i2c_adapter *adap=client->adapter;
1088 msg.addr = client->addr;
1089 msg.flags = client->flags & I2C_M_TEN;
1091 msg.buf = (char *)buf;
1093 ret = i2c_transfer(adap, &msg, 1);
1095 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1096 transmitted, else error code. */
1097 return (ret == 1) ? count : ret;
1099 EXPORT_SYMBOL(i2c_master_send);
1102 * i2c_master_recv - issue a single I2C message in master receive mode
1103 * @client: Handle to slave device
1104 * @buf: Where to store data read from slave
1105 * @count: How many bytes to read
1107 * Returns negative errno, or else the number of bytes read.
1109 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1111 struct i2c_adapter *adap=client->adapter;
1115 msg.addr = client->addr;
1116 msg.flags = client->flags & I2C_M_TEN;
1117 msg.flags |= I2C_M_RD;
1121 ret = i2c_transfer(adap, &msg, 1);
1123 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1124 transmitted, else error code. */
1125 return (ret == 1) ? count : ret;
1127 EXPORT_SYMBOL(i2c_master_recv);
1129 /* ----------------------------------------------------
1130 * the i2c address scanning function
1131 * Will not work for 10-bit addresses!
1132 * ----------------------------------------------------
1134 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1135 int (*found_proc) (struct i2c_adapter *, int, int))
1139 /* Make sure the address is valid */
1140 if (addr < 0x03 || addr > 0x77) {
1141 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1146 /* Skip if already in use */
1147 if (i2c_check_addr(adapter, addr))
1150 /* Make sure there is something at this address, unless forced */
1152 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1153 I2C_SMBUS_QUICK, NULL) < 0)
1156 /* prevent 24RF08 corruption */
1157 if ((addr & ~0x0f) == 0x50)
1158 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1159 I2C_SMBUS_QUICK, NULL);
1162 /* Finally call the custom detection function */
1163 err = found_proc(adapter, addr, kind);
1164 /* -ENODEV can be returned if there is a chip at the given address
1165 but it isn't supported by this chip driver. We catch it here as
1166 this isn't an error. */
1171 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1176 int i2c_probe(struct i2c_adapter *adapter,
1177 const struct i2c_client_address_data *address_data,
1178 int (*found_proc) (struct i2c_adapter *, int, int))
1181 int adap_id = i2c_adapter_id(adapter);
1183 /* Force entries are done first, and are not affected by ignore
1185 if (address_data->forces) {
1186 const unsigned short * const *forces = address_data->forces;
1189 for (kind = 0; forces[kind]; kind++) {
1190 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1192 if (forces[kind][i] == adap_id
1193 || forces[kind][i] == ANY_I2C_BUS) {
1194 dev_dbg(&adapter->dev, "found force "
1195 "parameter for adapter %d, "
1196 "addr 0x%02x, kind %d\n",
1197 adap_id, forces[kind][i + 1],
1199 err = i2c_probe_address(adapter,
1200 forces[kind][i + 1],
1209 /* Stop here if we can't use SMBUS_QUICK */
1210 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1211 if (address_data->probe[0] == I2C_CLIENT_END
1212 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1215 dev_dbg(&adapter->dev, "SMBus Quick command not supported, "
1216 "can't probe for chips\n");
1220 /* Probe entries are done second, and are not affected by ignore
1222 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1223 if (address_data->probe[i] == adap_id
1224 || address_data->probe[i] == ANY_I2C_BUS) {
1225 dev_dbg(&adapter->dev, "found probe parameter for "
1226 "adapter %d, addr 0x%02x\n", adap_id,
1227 address_data->probe[i + 1]);
1228 err = i2c_probe_address(adapter,
1229 address_data->probe[i + 1],
1236 /* Normal entries are done last, unless shadowed by an ignore entry */
1237 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1241 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1243 if ((address_data->ignore[j] == adap_id ||
1244 address_data->ignore[j] == ANY_I2C_BUS)
1245 && address_data->ignore[j + 1]
1246 == address_data->normal_i2c[i]) {
1247 dev_dbg(&adapter->dev, "found ignore "
1248 "parameter for adapter %d, "
1249 "addr 0x%02x\n", adap_id,
1250 address_data->ignore[j + 1]);
1258 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1259 "addr 0x%02x\n", adap_id,
1260 address_data->normal_i2c[i]);
1261 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1269 EXPORT_SYMBOL(i2c_probe);
1271 /* Separate detection function for new-style drivers */
1272 static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1273 struct i2c_driver *driver)
1275 struct i2c_board_info info;
1276 struct i2c_adapter *adapter = temp_client->adapter;
1277 int addr = temp_client->addr;
1280 /* Make sure the address is valid */
1281 if (addr < 0x03 || addr > 0x77) {
1282 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1287 /* Skip if already in use */
1288 if (i2c_check_addr(adapter, addr))
1291 /* Make sure there is something at this address, unless forced */
1293 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1294 I2C_SMBUS_QUICK, NULL) < 0)
1297 /* prevent 24RF08 corruption */
1298 if ((addr & ~0x0f) == 0x50)
1299 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1300 I2C_SMBUS_QUICK, NULL);
1303 /* Finally call the custom detection function */
1304 memset(&info, 0, sizeof(struct i2c_board_info));
1306 err = driver->detect(temp_client, kind, &info);
1308 /* -ENODEV is returned if the detection fails. We catch it
1309 here as this isn't an error. */
1310 return err == -ENODEV ? 0 : err;
1313 /* Consistency check */
1314 if (info.type[0] == '\0') {
1315 dev_err(&adapter->dev, "%s detection function provided "
1316 "no name for 0x%x\n", driver->driver.name,
1319 struct i2c_client *client;
1321 /* Detection succeeded, instantiate the device */
1322 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1323 info.type, info.addr);
1324 client = i2c_new_device(adapter, &info);
1326 list_add_tail(&client->detected, &driver->clients);
1328 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1329 info.type, info.addr);
1334 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1336 const struct i2c_client_address_data *address_data;
1337 struct i2c_client *temp_client;
1339 int adap_id = i2c_adapter_id(adapter);
1341 address_data = driver->address_data;
1342 if (!driver->detect || !address_data)
1345 /* Set up a temporary client to help detect callback */
1346 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1349 temp_client->adapter = adapter;
1351 /* Force entries are done first, and are not affected by ignore
1353 if (address_data->forces) {
1354 const unsigned short * const *forces = address_data->forces;
1357 for (kind = 0; forces[kind]; kind++) {
1358 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1360 if (forces[kind][i] == adap_id
1361 || forces[kind][i] == ANY_I2C_BUS) {
1362 dev_dbg(&adapter->dev, "found force "
1363 "parameter for adapter %d, "
1364 "addr 0x%02x, kind %d\n",
1365 adap_id, forces[kind][i + 1],
1367 temp_client->addr = forces[kind][i + 1];
1368 err = i2c_detect_address(temp_client,
1377 /* Stop here if the classes do not match */
1378 if (!(adapter->class & driver->class))
1381 /* Stop here if we can't use SMBUS_QUICK */
1382 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1383 if (address_data->probe[0] == I2C_CLIENT_END
1384 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1387 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1388 "can't probe for chips\n");
1393 /* Probe entries are done second, and are not affected by ignore
1395 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1396 if (address_data->probe[i] == adap_id
1397 || address_data->probe[i] == ANY_I2C_BUS) {
1398 dev_dbg(&adapter->dev, "found probe parameter for "
1399 "adapter %d, addr 0x%02x\n", adap_id,
1400 address_data->probe[i + 1]);
1401 temp_client->addr = address_data->probe[i + 1];
1402 err = i2c_detect_address(temp_client, -1, driver);
1408 /* Normal entries are done last, unless shadowed by an ignore entry */
1409 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1413 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1415 if ((address_data->ignore[j] == adap_id ||
1416 address_data->ignore[j] == ANY_I2C_BUS)
1417 && address_data->ignore[j + 1]
1418 == address_data->normal_i2c[i]) {
1419 dev_dbg(&adapter->dev, "found ignore "
1420 "parameter for adapter %d, "
1421 "addr 0x%02x\n", adap_id,
1422 address_data->ignore[j + 1]);
1430 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1431 "addr 0x%02x\n", adap_id,
1432 address_data->normal_i2c[i]);
1433 temp_client->addr = address_data->normal_i2c[i];
1434 err = i2c_detect_address(temp_client, -1, driver);
1445 i2c_new_probed_device(struct i2c_adapter *adap,
1446 struct i2c_board_info *info,
1447 unsigned short const *addr_list)
1451 /* Stop here if the bus doesn't support probing */
1452 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1453 dev_err(&adap->dev, "Probing not supported\n");
1457 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1458 /* Check address validity */
1459 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1460 dev_warn(&adap->dev, "Invalid 7-bit address "
1461 "0x%02x\n", addr_list[i]);
1465 /* Check address availability */
1466 if (i2c_check_addr(adap, addr_list[i])) {
1467 dev_dbg(&adap->dev, "Address 0x%02x already in "
1468 "use, not probing\n", addr_list[i]);
1472 /* Test address responsiveness
1473 The default probe method is a quick write, but it is known
1474 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1475 and could also irreversibly write-protect some EEPROMs, so
1476 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1477 read instead. Also, some bus drivers don't implement
1478 quick write, so we fallback to a byte read it that case
1480 if ((addr_list[i] & ~0x07) == 0x30
1481 || (addr_list[i] & ~0x0f) == 0x50
1482 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1483 union i2c_smbus_data data;
1485 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1487 I2C_SMBUS_BYTE, &data) >= 0)
1490 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1492 I2C_SMBUS_QUICK, NULL) >= 0)
1497 if (addr_list[i] == I2C_CLIENT_END) {
1498 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1502 info->addr = addr_list[i];
1503 return i2c_new_device(adap, info);
1505 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1507 struct i2c_adapter* i2c_get_adapter(int id)
1509 struct i2c_adapter *adapter;
1511 mutex_lock(&core_lock);
1512 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1513 if (adapter && !try_module_get(adapter->owner))
1516 mutex_unlock(&core_lock);
1519 EXPORT_SYMBOL(i2c_get_adapter);
1521 void i2c_put_adapter(struct i2c_adapter *adap)
1523 module_put(adap->owner);
1525 EXPORT_SYMBOL(i2c_put_adapter);
1527 /* The SMBus parts */
1529 #define POLY (0x1070U << 3)
1535 for(i = 0; i < 8; i++) {
1540 return (u8)(data >> 8);
1543 /* Incremental CRC8 over count bytes in the array pointed to by p */
1544 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1548 for(i = 0; i < count; i++)
1549 crc = crc8((crc ^ p[i]) << 8);
1553 /* Assume a 7-bit address, which is reasonable for SMBus */
1554 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1556 /* The address will be sent first */
1557 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1558 pec = i2c_smbus_pec(pec, &addr, 1);
1560 /* The data buffer follows */
1561 return i2c_smbus_pec(pec, msg->buf, msg->len);
1564 /* Used for write only transactions */
1565 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1567 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1571 /* Return <0 on CRC error
1572 If there was a write before this read (most cases) we need to take the
1573 partial CRC from the write part into account.
1574 Note that this function does modify the message (we need to decrease the
1575 message length to hide the CRC byte from the caller). */
1576 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1578 u8 rpec = msg->buf[--msg->len];
1579 cpec = i2c_smbus_msg_pec(cpec, msg);
1582 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1590 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1591 * @client: Handle to slave device
1593 * This executes the SMBus "receive byte" protocol, returning negative errno
1594 * else the byte received from the device.
1596 s32 i2c_smbus_read_byte(struct i2c_client *client)
1598 union i2c_smbus_data data;
1601 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1603 I2C_SMBUS_BYTE, &data);
1604 return (status < 0) ? status : data.byte;
1606 EXPORT_SYMBOL(i2c_smbus_read_byte);
1609 * i2c_smbus_write_byte - SMBus "send byte" protocol
1610 * @client: Handle to slave device
1611 * @value: Byte to be sent
1613 * This executes the SMBus "send byte" protocol, returning negative errno
1614 * else zero on success.
1616 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1618 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1619 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1621 EXPORT_SYMBOL(i2c_smbus_write_byte);
1624 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1625 * @client: Handle to slave device
1626 * @command: Byte interpreted by slave
1628 * This executes the SMBus "read byte" protocol, returning negative errno
1629 * else a data byte received from the device.
1631 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1633 union i2c_smbus_data data;
1636 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1637 I2C_SMBUS_READ, command,
1638 I2C_SMBUS_BYTE_DATA, &data);
1639 return (status < 0) ? status : data.byte;
1641 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1644 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1645 * @client: Handle to slave device
1646 * @command: Byte interpreted by slave
1647 * @value: Byte being written
1649 * This executes the SMBus "write byte" protocol, returning negative errno
1650 * else zero on success.
1652 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1654 union i2c_smbus_data data;
1656 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1657 I2C_SMBUS_WRITE,command,
1658 I2C_SMBUS_BYTE_DATA,&data);
1660 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1663 * i2c_smbus_read_word_data - SMBus "read word" protocol
1664 * @client: Handle to slave device
1665 * @command: Byte interpreted by slave
1667 * This executes the SMBus "read word" protocol, returning negative errno
1668 * else a 16-bit unsigned "word" received from the device.
1670 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1672 union i2c_smbus_data data;
1675 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1676 I2C_SMBUS_READ, command,
1677 I2C_SMBUS_WORD_DATA, &data);
1678 return (status < 0) ? status : data.word;
1680 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1683 * i2c_smbus_write_word_data - SMBus "write word" protocol
1684 * @client: Handle to slave device
1685 * @command: Byte interpreted by slave
1686 * @value: 16-bit "word" being written
1688 * This executes the SMBus "write word" protocol, returning negative errno
1689 * else zero on success.
1691 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1693 union i2c_smbus_data data;
1695 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1696 I2C_SMBUS_WRITE,command,
1697 I2C_SMBUS_WORD_DATA,&data);
1699 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1702 * i2c_smbus_process_call - SMBus "process call" protocol
1703 * @client: Handle to slave device
1704 * @command: Byte interpreted by slave
1705 * @value: 16-bit "word" being written
1707 * This executes the SMBus "process call" protocol, returning negative errno
1708 * else a 16-bit unsigned "word" received from the device.
1710 s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1712 union i2c_smbus_data data;
1716 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1717 I2C_SMBUS_WRITE, command,
1718 I2C_SMBUS_PROC_CALL, &data);
1719 return (status < 0) ? status : data.word;
1721 EXPORT_SYMBOL(i2c_smbus_process_call);
1724 * i2c_smbus_read_block_data - SMBus "block read" protocol
1725 * @client: Handle to slave device
1726 * @command: Byte interpreted by slave
1727 * @values: Byte array into which data will be read; big enough to hold
1728 * the data returned by the slave. SMBus allows at most 32 bytes.
1730 * This executes the SMBus "block read" protocol, returning negative errno
1731 * else the number of data bytes in the slave's response.
1733 * Note that using this function requires that the client's adapter support
1734 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1735 * support this; its emulation through I2C messaging relies on a specific
1736 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1738 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1741 union i2c_smbus_data data;
1744 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1745 I2C_SMBUS_READ, command,
1746 I2C_SMBUS_BLOCK_DATA, &data);
1750 memcpy(values, &data.block[1], data.block[0]);
1751 return data.block[0];
1753 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1756 * i2c_smbus_write_block_data - SMBus "block write" protocol
1757 * @client: Handle to slave device
1758 * @command: Byte interpreted by slave
1759 * @length: Size of data block; SMBus allows at most 32 bytes
1760 * @values: Byte array which will be written.
1762 * This executes the SMBus "block write" protocol, returning negative errno
1763 * else zero on success.
1765 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1766 u8 length, const u8 *values)
1768 union i2c_smbus_data data;
1770 if (length > I2C_SMBUS_BLOCK_MAX)
1771 length = I2C_SMBUS_BLOCK_MAX;
1772 data.block[0] = length;
1773 memcpy(&data.block[1], values, length);
1774 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1775 I2C_SMBUS_WRITE,command,
1776 I2C_SMBUS_BLOCK_DATA,&data);
1778 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1780 /* Returns the number of read bytes */
1781 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1782 u8 length, u8 *values)
1784 union i2c_smbus_data data;
1787 if (length > I2C_SMBUS_BLOCK_MAX)
1788 length = I2C_SMBUS_BLOCK_MAX;
1789 data.block[0] = length;
1790 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1791 I2C_SMBUS_READ, command,
1792 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1796 memcpy(values, &data.block[1], data.block[0]);
1797 return data.block[0];
1799 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1801 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1802 u8 length, const u8 *values)
1804 union i2c_smbus_data data;
1806 if (length > I2C_SMBUS_BLOCK_MAX)
1807 length = I2C_SMBUS_BLOCK_MAX;
1808 data.block[0] = length;
1809 memcpy(data.block + 1, values, length);
1810 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1811 I2C_SMBUS_WRITE, command,
1812 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1814 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1816 /* Simulate a SMBus command using the i2c protocol
1817 No checking of parameters is done! */
1818 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1819 unsigned short flags,
1820 char read_write, u8 command, int size,
1821 union i2c_smbus_data * data)
1823 /* So we need to generate a series of msgs. In the case of writing, we
1824 need to use only one message; when reading, we need two. We initialize
1825 most things with sane defaults, to keep the code below somewhat
1827 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1828 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1829 int num = read_write == I2C_SMBUS_READ?2:1;
1830 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1831 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1837 msgbuf0[0] = command;
1839 case I2C_SMBUS_QUICK:
1841 /* Special case: The read/write field is used as data */
1842 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1846 case I2C_SMBUS_BYTE:
1847 if (read_write == I2C_SMBUS_READ) {
1848 /* Special case: only a read! */
1849 msg[0].flags = I2C_M_RD | flags;
1853 case I2C_SMBUS_BYTE_DATA:
1854 if (read_write == I2C_SMBUS_READ)
1858 msgbuf0[1] = data->byte;
1861 case I2C_SMBUS_WORD_DATA:
1862 if (read_write == I2C_SMBUS_READ)
1866 msgbuf0[1] = data->word & 0xff;
1867 msgbuf0[2] = data->word >> 8;
1870 case I2C_SMBUS_PROC_CALL:
1871 num = 2; /* Special case */
1872 read_write = I2C_SMBUS_READ;
1875 msgbuf0[1] = data->word & 0xff;
1876 msgbuf0[2] = data->word >> 8;
1878 case I2C_SMBUS_BLOCK_DATA:
1879 if (read_write == I2C_SMBUS_READ) {
1880 msg[1].flags |= I2C_M_RECV_LEN;
1881 msg[1].len = 1; /* block length will be added by
1882 the underlying bus driver */
1884 msg[0].len = data->block[0] + 2;
1885 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1886 dev_err(&adapter->dev,
1887 "Invalid block write size %d\n",
1891 for (i = 1; i < msg[0].len; i++)
1892 msgbuf0[i] = data->block[i-1];
1895 case I2C_SMBUS_BLOCK_PROC_CALL:
1896 num = 2; /* Another special case */
1897 read_write = I2C_SMBUS_READ;
1898 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1899 dev_err(&adapter->dev,
1900 "Invalid block write size %d\n",
1904 msg[0].len = data->block[0] + 2;
1905 for (i = 1; i < msg[0].len; i++)
1906 msgbuf0[i] = data->block[i-1];
1907 msg[1].flags |= I2C_M_RECV_LEN;
1908 msg[1].len = 1; /* block length will be added by
1909 the underlying bus driver */
1911 case I2C_SMBUS_I2C_BLOCK_DATA:
1912 if (read_write == I2C_SMBUS_READ) {
1913 msg[1].len = data->block[0];
1915 msg[0].len = data->block[0] + 1;
1916 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1917 dev_err(&adapter->dev,
1918 "Invalid block write size %d\n",
1922 for (i = 1; i <= data->block[0]; i++)
1923 msgbuf0[i] = data->block[i];
1927 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1931 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1932 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1934 /* Compute PEC if first message is a write */
1935 if (!(msg[0].flags & I2C_M_RD)) {
1936 if (num == 1) /* Write only */
1937 i2c_smbus_add_pec(&msg[0]);
1938 else /* Write followed by read */
1939 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1941 /* Ask for PEC if last message is a read */
1942 if (msg[num-1].flags & I2C_M_RD)
1946 status = i2c_transfer(adapter, msg, num);
1950 /* Check PEC if last message is a read */
1951 if (i && (msg[num-1].flags & I2C_M_RD)) {
1952 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1957 if (read_write == I2C_SMBUS_READ)
1959 case I2C_SMBUS_BYTE:
1960 data->byte = msgbuf0[0];
1962 case I2C_SMBUS_BYTE_DATA:
1963 data->byte = msgbuf1[0];
1965 case I2C_SMBUS_WORD_DATA:
1966 case I2C_SMBUS_PROC_CALL:
1967 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1969 case I2C_SMBUS_I2C_BLOCK_DATA:
1970 for (i = 0; i < data->block[0]; i++)
1971 data->block[i+1] = msgbuf1[i];
1973 case I2C_SMBUS_BLOCK_DATA:
1974 case I2C_SMBUS_BLOCK_PROC_CALL:
1975 for (i = 0; i < msgbuf1[0] + 1; i++)
1976 data->block[i] = msgbuf1[i];
1983 * i2c_smbus_xfer - execute SMBus protocol operations
1984 * @adapter: Handle to I2C bus
1985 * @addr: Address of SMBus slave on that bus
1986 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1987 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1988 * @command: Byte interpreted by slave, for protocols which use such bytes
1989 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1990 * @data: Data to be read or written
1992 * This executes an SMBus protocol operation, and returns a negative
1993 * errno code else zero on success.
1995 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1996 char read_write, u8 command, int protocol,
1997 union i2c_smbus_data * data)
2001 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
2003 if (adapter->algo->smbus_xfer) {
2004 mutex_lock(&adapter->bus_lock);
2005 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
2006 command, protocol, data);
2007 mutex_unlock(&adapter->bus_lock);
2009 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
2010 command, protocol, data);
2014 EXPORT_SYMBOL(i2c_smbus_xfer);
2016 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2017 MODULE_DESCRIPTION("I2C-Bus main module");
2018 MODULE_LICENSE("GPL");