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;
269 client->flags = info->flags;
270 client->addr = info->addr;
271 client->irq = info->irq;
273 strlcpy(client->name, info->type, sizeof(client->name));
275 /* a new style driver may be bound to this device when we
276 * return from this function, or any later moment (e.g. maybe
277 * hotplugging will load the driver module). and the device
278 * refcount model is the standard driver model one.
280 status = i2c_attach_client(client);
287 EXPORT_SYMBOL_GPL(i2c_new_device);
291 * i2c_unregister_device - reverse effect of i2c_new_device()
292 * @client: value returned from i2c_new_device()
295 void i2c_unregister_device(struct i2c_client *client)
297 struct i2c_adapter *adapter = client->adapter;
298 struct i2c_driver *driver = client->driver;
300 if (driver && !is_newstyle_driver(driver)) {
301 dev_err(&client->dev, "can't unregister devices "
302 "with legacy drivers\n");
307 if (adapter->client_unregister) {
308 if (adapter->client_unregister(client)) {
309 dev_warn(&client->dev,
310 "client_unregister [%s] failed\n",
315 mutex_lock(&adapter->clist_lock);
316 list_del(&client->list);
317 mutex_unlock(&adapter->clist_lock);
319 device_unregister(&client->dev);
321 EXPORT_SYMBOL_GPL(i2c_unregister_device);
324 static const struct i2c_device_id dummy_id[] = {
329 static int dummy_probe(struct i2c_client *client,
330 const struct i2c_device_id *id)
335 static int dummy_remove(struct i2c_client *client)
340 static struct i2c_driver dummy_driver = {
341 .driver.name = "dummy",
342 .probe = dummy_probe,
343 .remove = dummy_remove,
344 .id_table = dummy_id,
348 * i2c_new_dummy - return a new i2c device bound to a dummy driver
349 * @adapter: the adapter managing the device
350 * @address: seven bit address to be used
353 * This returns an I2C client bound to the "dummy" driver, intended for use
354 * with devices that consume multiple addresses. Examples of such chips
355 * include various EEPROMS (like 24c04 and 24c08 models).
357 * These dummy devices have two main uses. First, most I2C and SMBus calls
358 * except i2c_transfer() need a client handle; the dummy will be that handle.
359 * And second, this prevents the specified address from being bound to a
362 * This returns the new i2c client, which should be saved for later use with
363 * i2c_unregister_device(); or NULL to indicate an error.
366 i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
368 struct i2c_board_info info = {
369 I2C_BOARD_INFO("dummy", address),
372 return i2c_new_device(adapter, &info);
374 EXPORT_SYMBOL_GPL(i2c_new_dummy);
376 /* ------------------------------------------------------------------------- */
378 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
380 static void i2c_adapter_dev_release(struct device *dev)
382 struct i2c_adapter *adap = to_i2c_adapter(dev);
383 complete(&adap->dev_released);
387 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
389 struct i2c_adapter *adap = to_i2c_adapter(dev);
390 return sprintf(buf, "%s\n", adap->name);
393 static struct device_attribute i2c_adapter_attrs[] = {
394 __ATTR(name, S_IRUGO, show_adapter_name, NULL),
398 static struct class i2c_adapter_class = {
399 .owner = THIS_MODULE,
400 .name = "i2c-adapter",
401 .dev_attrs = i2c_adapter_attrs,
404 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
406 struct i2c_devinfo *devinfo;
408 mutex_lock(&__i2c_board_lock);
409 list_for_each_entry(devinfo, &__i2c_board_list, list) {
410 if (devinfo->busnum == adapter->nr
411 && !i2c_new_device(adapter,
412 &devinfo->board_info))
413 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
414 i2c_adapter_id(adapter),
415 devinfo->board_info.addr);
417 mutex_unlock(&__i2c_board_lock);
420 static int i2c_do_add_adapter(struct device_driver *d, void *data)
422 struct i2c_driver *driver = to_i2c_driver(d);
423 struct i2c_adapter *adap = data;
425 /* Detect supported devices on that bus, and instantiate them */
426 i2c_detect(adap, driver);
428 /* Let legacy drivers scan this bus for matching devices */
429 if (driver->attach_adapter) {
430 /* We ignore the return code; if it fails, too bad */
431 driver->attach_adapter(adap);
436 static int i2c_register_adapter(struct i2c_adapter *adap)
440 /* Can't register until after driver model init */
441 if (unlikely(WARN_ON(!i2c_bus_type.p)))
444 mutex_init(&adap->bus_lock);
445 mutex_init(&adap->clist_lock);
446 INIT_LIST_HEAD(&adap->clients);
448 mutex_lock(&core_lock);
450 /* Add the adapter to the driver core.
451 * If the parent pointer is not set up,
452 * we add this adapter to the host bus.
454 if (adap->dev.parent == NULL) {
455 adap->dev.parent = &platform_bus;
456 pr_debug("I2C adapter driver [%s] forgot to specify "
457 "physical device\n", adap->name);
459 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
460 adap->dev.release = &i2c_adapter_dev_release;
461 adap->dev.class = &i2c_adapter_class;
462 res = device_register(&adap->dev);
466 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
468 /* create pre-declared device nodes for new-style drivers */
469 if (adap->nr < __i2c_first_dynamic_bus_num)
470 i2c_scan_static_board_info(adap);
473 dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
477 mutex_unlock(&core_lock);
481 idr_remove(&i2c_adapter_idr, adap->nr);
486 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
487 * @adapter: the adapter to add
490 * This routine is used to declare an I2C adapter when its bus number
491 * doesn't matter. Examples: for I2C adapters dynamically added by
492 * USB links or PCI plugin cards.
494 * When this returns zero, a new bus number was allocated and stored
495 * in adap->nr, and the specified adapter became available for clients.
496 * Otherwise, a negative errno value is returned.
498 int i2c_add_adapter(struct i2c_adapter *adapter)
503 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
506 mutex_lock(&core_lock);
507 /* "above" here means "above or equal to", sigh */
508 res = idr_get_new_above(&i2c_adapter_idr, adapter,
509 __i2c_first_dynamic_bus_num, &id);
510 mutex_unlock(&core_lock);
519 return i2c_register_adapter(adapter);
521 EXPORT_SYMBOL(i2c_add_adapter);
524 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
525 * @adap: the adapter to register (with adap->nr initialized)
528 * This routine is used to declare an I2C adapter when its bus number
529 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
530 * or otherwise built in to the system's mainboard, and where i2c_board_info
531 * is used to properly configure I2C devices.
533 * If no devices have pre-been declared for this bus, then be sure to
534 * register the adapter before any dynamically allocated ones. Otherwise
535 * the required bus ID may not be available.
537 * When this returns zero, the specified adapter became available for
538 * clients using the bus number provided in adap->nr. Also, the table
539 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
540 * and the appropriate driver model device nodes are created. Otherwise, a
541 * negative errno value is returned.
543 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
548 if (adap->nr & ~MAX_ID_MASK)
552 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
555 mutex_lock(&core_lock);
556 /* "above" here means "above or equal to", sigh;
557 * we need the "equal to" result to force the result
559 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
560 if (status == 0 && id != adap->nr) {
562 idr_remove(&i2c_adapter_idr, id);
564 mutex_unlock(&core_lock);
565 if (status == -EAGAIN)
569 status = i2c_register_adapter(adap);
572 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
574 static int i2c_do_del_adapter(struct device_driver *d, void *data)
576 struct i2c_driver *driver = to_i2c_driver(d);
577 struct i2c_adapter *adapter = data;
578 struct i2c_client *client, *_n;
581 /* Remove the devices we created ourselves */
582 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
583 if (client->adapter == adapter) {
584 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
585 client->name, client->addr);
586 list_del(&client->detected);
587 i2c_unregister_device(client);
591 if (!driver->detach_adapter)
593 res = driver->detach_adapter(adapter);
595 dev_err(&adapter->dev, "detach_adapter failed (%d) "
596 "for driver [%s]\n", res, driver->driver.name);
601 * i2c_del_adapter - unregister I2C adapter
602 * @adap: the adapter being unregistered
605 * This unregisters an I2C adapter which was previously registered
606 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
608 int i2c_del_adapter(struct i2c_adapter *adap)
610 struct i2c_client *client, *_n;
613 mutex_lock(&core_lock);
615 /* First make sure that this adapter was ever added */
616 if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
617 pr_debug("i2c-core: attempting to delete unregistered "
618 "adapter [%s]\n", adap->name);
623 /* Tell drivers about this removal */
624 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
629 /* detach any active clients. This must be done first, because
630 * it can fail; in which case we give up. */
631 list_for_each_entry_safe(client, _n, &adap->clients, list) {
632 struct i2c_driver *driver;
634 driver = client->driver;
636 /* new style, follow standard driver model */
637 if (!driver || is_newstyle_driver(driver)) {
638 i2c_unregister_device(client);
642 /* legacy drivers create and remove clients themselves */
643 if ((res = driver->detach_client(client))) {
644 dev_err(&adap->dev, "detach_client failed for client "
645 "[%s] at address 0x%02x\n", client->name,
651 /* clean up the sysfs representation */
652 init_completion(&adap->dev_released);
653 device_unregister(&adap->dev);
655 /* wait for sysfs to drop all references */
656 wait_for_completion(&adap->dev_released);
659 idr_remove(&i2c_adapter_idr, adap->nr);
661 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
663 /* Clear the device structure in case this adapter is ever going to be
665 memset(&adap->dev, 0, sizeof(adap->dev));
668 mutex_unlock(&core_lock);
671 EXPORT_SYMBOL(i2c_del_adapter);
674 /* ------------------------------------------------------------------------- */
676 static int __attach_adapter(struct device *dev, void *data)
678 struct i2c_adapter *adapter = to_i2c_adapter(dev);
679 struct i2c_driver *driver = data;
681 i2c_detect(adapter, driver);
683 /* Legacy drivers scan i2c busses directly */
684 if (driver->attach_adapter)
685 driver->attach_adapter(adapter);
691 * An i2c_driver is used with one or more i2c_client (device) nodes to access
692 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
693 * are two models for binding the driver to its device: "new style" drivers
694 * follow the standard Linux driver model and just respond to probe() calls
695 * issued if the driver core sees they match(); "legacy" drivers create device
699 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
703 /* Can't register until after driver model init */
704 if (unlikely(WARN_ON(!i2c_bus_type.p)))
707 /* new style driver methods can't mix with legacy ones */
708 if (is_newstyle_driver(driver)) {
709 if (driver->attach_adapter || driver->detach_adapter
710 || driver->detach_client) {
712 "i2c-core: driver [%s] is confused\n",
713 driver->driver.name);
718 /* add the driver to the list of i2c drivers in the driver core */
719 driver->driver.owner = owner;
720 driver->driver.bus = &i2c_bus_type;
722 /* for new style drivers, when registration returns the driver core
723 * will have called probe() for all matching-but-unbound devices.
725 res = driver_register(&driver->driver);
729 mutex_lock(&core_lock);
731 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
733 INIT_LIST_HEAD(&driver->clients);
734 /* Walk the adapters that are already present */
735 class_for_each_device(&i2c_adapter_class, NULL, driver,
738 mutex_unlock(&core_lock);
741 EXPORT_SYMBOL(i2c_register_driver);
743 static int __detach_adapter(struct device *dev, void *data)
745 struct i2c_adapter *adapter = to_i2c_adapter(dev);
746 struct i2c_driver *driver = data;
747 struct i2c_client *client, *_n;
749 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
750 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
751 client->name, client->addr);
752 list_del(&client->detected);
753 i2c_unregister_device(client);
756 if (is_newstyle_driver(driver))
759 /* Have a look at each adapter, if clients of this driver are still
760 * attached. If so, detach them to be able to kill the driver
763 if (driver->detach_adapter) {
764 if (driver->detach_adapter(adapter))
765 dev_err(&adapter->dev,
766 "detach_adapter failed for driver [%s]\n",
767 driver->driver.name);
769 struct i2c_client *client, *_n;
771 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
772 if (client->driver != driver)
774 dev_dbg(&adapter->dev,
775 "detaching client [%s] at 0x%02x\n",
776 client->name, client->addr);
777 if (driver->detach_client(client))
778 dev_err(&adapter->dev, "detach_client "
779 "failed for client [%s] at 0x%02x\n",
780 client->name, client->addr);
788 * i2c_del_driver - unregister I2C driver
789 * @driver: the driver being unregistered
792 void i2c_del_driver(struct i2c_driver *driver)
794 mutex_lock(&core_lock);
796 class_for_each_device(&i2c_adapter_class, NULL, driver,
799 driver_unregister(&driver->driver);
800 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
802 mutex_unlock(&core_lock);
804 EXPORT_SYMBOL(i2c_del_driver);
806 /* ------------------------------------------------------------------------- */
808 static int __i2c_check_addr(struct device *dev, void *addrp)
810 struct i2c_client *client = i2c_verify_client(dev);
811 int addr = *(int *)addrp;
813 if (client && client->addr == addr)
818 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
820 return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
823 int i2c_attach_client(struct i2c_client *client)
825 struct i2c_adapter *adapter = client->adapter;
828 /* Check for address business */
829 res = i2c_check_addr(adapter, client->addr);
833 client->dev.parent = &client->adapter->dev;
834 client->dev.bus = &i2c_bus_type;
837 client->dev.driver = &client->driver->driver;
839 if (client->driver && !is_newstyle_driver(client->driver)) {
840 client->dev.release = i2c_client_release;
841 client->dev.uevent_suppress = 1;
843 client->dev.release = i2c_client_dev_release;
845 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
846 "%d-%04x", i2c_adapter_id(adapter), client->addr);
847 res = device_register(&client->dev);
851 mutex_lock(&adapter->clist_lock);
852 list_add_tail(&client->list, &adapter->clients);
853 mutex_unlock(&adapter->clist_lock);
855 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
856 client->name, client->dev.bus_id);
858 if (adapter->client_register) {
859 if (adapter->client_register(client)) {
860 dev_dbg(&adapter->dev, "client_register "
861 "failed for client [%s] at 0x%02x\n",
862 client->name, client->addr);
869 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
870 "(%d)\n", client->name, client->addr, res);
873 EXPORT_SYMBOL(i2c_attach_client);
875 int i2c_detach_client(struct i2c_client *client)
877 struct i2c_adapter *adapter = client->adapter;
880 if (adapter->client_unregister) {
881 res = adapter->client_unregister(client);
883 dev_err(&client->dev,
884 "client_unregister [%s] failed, "
885 "client not detached\n", client->name);
890 mutex_lock(&adapter->clist_lock);
891 list_del(&client->list);
892 mutex_unlock(&adapter->clist_lock);
894 init_completion(&client->released);
895 device_unregister(&client->dev);
896 wait_for_completion(&client->released);
901 EXPORT_SYMBOL(i2c_detach_client);
904 * i2c_use_client - increments the reference count of the i2c client structure
905 * @client: the client being referenced
907 * Each live reference to a client should be refcounted. The driver model does
908 * that automatically as part of driver binding, so that most drivers don't
909 * need to do this explicitly: they hold a reference until they're unbound
912 * A pointer to the client with the incremented reference counter is returned.
914 struct i2c_client *i2c_use_client(struct i2c_client *client)
916 if (client && get_device(&client->dev))
920 EXPORT_SYMBOL(i2c_use_client);
923 * i2c_release_client - release a use of the i2c client structure
924 * @client: the client being no longer referenced
926 * Must be called when a user of a client is finished with it.
928 void i2c_release_client(struct i2c_client *client)
931 put_device(&client->dev);
933 EXPORT_SYMBOL(i2c_release_client);
940 static int i2c_cmd(struct device *dev, void *_arg)
942 struct i2c_client *client = i2c_verify_client(dev);
943 struct i2c_cmd_arg *arg = _arg;
945 if (client && client->driver && client->driver->command)
946 client->driver->command(client, arg->cmd, arg->arg);
950 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
952 struct i2c_cmd_arg cmd_arg;
956 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
958 EXPORT_SYMBOL(i2c_clients_command);
960 static int __init i2c_init(void)
964 retval = bus_register(&i2c_bus_type);
967 retval = class_register(&i2c_adapter_class);
970 retval = i2c_add_driver(&dummy_driver);
976 class_unregister(&i2c_adapter_class);
978 bus_unregister(&i2c_bus_type);
982 static void __exit i2c_exit(void)
984 i2c_del_driver(&dummy_driver);
985 class_unregister(&i2c_adapter_class);
986 bus_unregister(&i2c_bus_type);
989 subsys_initcall(i2c_init);
990 module_exit(i2c_exit);
992 /* ----------------------------------------------------
993 * the functional interface to the i2c busses.
994 * ----------------------------------------------------
998 * i2c_transfer - execute a single or combined I2C message
999 * @adap: Handle to I2C bus
1000 * @msgs: One or more messages to execute before STOP is issued to
1001 * terminate the operation; each message begins with a START.
1002 * @num: Number of messages to be executed.
1004 * Returns negative errno, else the number of messages executed.
1006 * Note that there is no requirement that each message be sent to
1007 * the same slave address, although that is the most common model.
1009 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
1013 /* REVISIT the fault reporting model here is weak:
1015 * - When we get an error after receiving N bytes from a slave,
1016 * there is no way to report "N".
1018 * - When we get a NAK after transmitting N bytes to a slave,
1019 * there is no way to report "N" ... or to let the master
1020 * continue executing the rest of this combined message, if
1021 * that's the appropriate response.
1023 * - When for example "num" is two and we successfully complete
1024 * the first message but get an error part way through the
1025 * second, it's unclear whether that should be reported as
1026 * one (discarding status on the second message) or errno
1027 * (discarding status on the first one).
1030 if (adap->algo->master_xfer) {
1032 for (ret = 0; ret < num; ret++) {
1033 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1034 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1035 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1036 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1040 if (in_atomic() || irqs_disabled()) {
1041 ret = mutex_trylock(&adap->bus_lock);
1043 /* I2C activity is ongoing. */
1046 mutex_lock_nested(&adap->bus_lock, adap->level);
1049 ret = adap->algo->master_xfer(adap,msgs,num);
1050 mutex_unlock(&adap->bus_lock);
1054 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1058 EXPORT_SYMBOL(i2c_transfer);
1061 * i2c_master_send - issue a single I2C message in master transmit mode
1062 * @client: Handle to slave device
1063 * @buf: Data that will be written to the slave
1064 * @count: How many bytes to write
1066 * Returns negative errno, or else the number of bytes written.
1068 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1071 struct i2c_adapter *adap=client->adapter;
1074 msg.addr = client->addr;
1075 msg.flags = client->flags & I2C_M_TEN;
1077 msg.buf = (char *)buf;
1079 ret = i2c_transfer(adap, &msg, 1);
1081 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1082 transmitted, else error code. */
1083 return (ret == 1) ? count : ret;
1085 EXPORT_SYMBOL(i2c_master_send);
1088 * i2c_master_recv - issue a single I2C message in master receive mode
1089 * @client: Handle to slave device
1090 * @buf: Where to store data read from slave
1091 * @count: How many bytes to read
1093 * Returns negative errno, or else the number of bytes read.
1095 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1097 struct i2c_adapter *adap=client->adapter;
1101 msg.addr = client->addr;
1102 msg.flags = client->flags & I2C_M_TEN;
1103 msg.flags |= I2C_M_RD;
1107 ret = i2c_transfer(adap, &msg, 1);
1109 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1110 transmitted, else error code. */
1111 return (ret == 1) ? count : ret;
1113 EXPORT_SYMBOL(i2c_master_recv);
1115 /* ----------------------------------------------------
1116 * the i2c address scanning function
1117 * Will not work for 10-bit addresses!
1118 * ----------------------------------------------------
1120 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1121 int (*found_proc) (struct i2c_adapter *, int, int))
1125 /* Make sure the address is valid */
1126 if (addr < 0x03 || addr > 0x77) {
1127 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1132 /* Skip if already in use */
1133 if (i2c_check_addr(adapter, addr))
1136 /* Make sure there is something at this address, unless forced */
1138 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1139 I2C_SMBUS_QUICK, NULL) < 0)
1142 /* prevent 24RF08 corruption */
1143 if ((addr & ~0x0f) == 0x50)
1144 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1145 I2C_SMBUS_QUICK, NULL);
1148 /* Finally call the custom detection function */
1149 err = found_proc(adapter, addr, kind);
1150 /* -ENODEV can be returned if there is a chip at the given address
1151 but it isn't supported by this chip driver. We catch it here as
1152 this isn't an error. */
1157 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1162 int i2c_probe(struct i2c_adapter *adapter,
1163 const struct i2c_client_address_data *address_data,
1164 int (*found_proc) (struct i2c_adapter *, int, int))
1167 int adap_id = i2c_adapter_id(adapter);
1169 /* Force entries are done first, and are not affected by ignore
1171 if (address_data->forces) {
1172 const unsigned short * const *forces = address_data->forces;
1175 for (kind = 0; forces[kind]; kind++) {
1176 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1178 if (forces[kind][i] == adap_id
1179 || forces[kind][i] == ANY_I2C_BUS) {
1180 dev_dbg(&adapter->dev, "found force "
1181 "parameter for adapter %d, "
1182 "addr 0x%02x, kind %d\n",
1183 adap_id, forces[kind][i + 1],
1185 err = i2c_probe_address(adapter,
1186 forces[kind][i + 1],
1195 /* Stop here if we can't use SMBUS_QUICK */
1196 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1197 if (address_data->probe[0] == I2C_CLIENT_END
1198 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1201 dev_dbg(&adapter->dev, "SMBus Quick command not supported, "
1202 "can't probe for chips\n");
1206 /* Probe entries are done second, and are not affected by ignore
1208 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1209 if (address_data->probe[i] == adap_id
1210 || address_data->probe[i] == ANY_I2C_BUS) {
1211 dev_dbg(&adapter->dev, "found probe parameter for "
1212 "adapter %d, addr 0x%02x\n", adap_id,
1213 address_data->probe[i + 1]);
1214 err = i2c_probe_address(adapter,
1215 address_data->probe[i + 1],
1222 /* Normal entries are done last, unless shadowed by an ignore entry */
1223 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1227 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1229 if ((address_data->ignore[j] == adap_id ||
1230 address_data->ignore[j] == ANY_I2C_BUS)
1231 && address_data->ignore[j + 1]
1232 == address_data->normal_i2c[i]) {
1233 dev_dbg(&adapter->dev, "found ignore "
1234 "parameter for adapter %d, "
1235 "addr 0x%02x\n", adap_id,
1236 address_data->ignore[j + 1]);
1244 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1245 "addr 0x%02x\n", adap_id,
1246 address_data->normal_i2c[i]);
1247 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1255 EXPORT_SYMBOL(i2c_probe);
1257 /* Separate detection function for new-style drivers */
1258 static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1259 struct i2c_driver *driver)
1261 struct i2c_board_info info;
1262 struct i2c_adapter *adapter = temp_client->adapter;
1263 int addr = temp_client->addr;
1266 /* Make sure the address is valid */
1267 if (addr < 0x03 || addr > 0x77) {
1268 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1273 /* Skip if already in use */
1274 if (i2c_check_addr(adapter, addr))
1277 /* Make sure there is something at this address, unless forced */
1279 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1280 I2C_SMBUS_QUICK, NULL) < 0)
1283 /* prevent 24RF08 corruption */
1284 if ((addr & ~0x0f) == 0x50)
1285 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1286 I2C_SMBUS_QUICK, NULL);
1289 /* Finally call the custom detection function */
1290 memset(&info, 0, sizeof(struct i2c_board_info));
1292 err = driver->detect(temp_client, kind, &info);
1294 /* -ENODEV is returned if the detection fails. We catch it
1295 here as this isn't an error. */
1296 return err == -ENODEV ? 0 : err;
1299 /* Consistency check */
1300 if (info.type[0] == '\0') {
1301 dev_err(&adapter->dev, "%s detection function provided "
1302 "no name for 0x%x\n", driver->driver.name,
1305 struct i2c_client *client;
1307 /* Detection succeeded, instantiate the device */
1308 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1309 info.type, info.addr);
1310 client = i2c_new_device(adapter, &info);
1312 list_add_tail(&client->detected, &driver->clients);
1314 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1315 info.type, info.addr);
1320 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1322 const struct i2c_client_address_data *address_data;
1323 struct i2c_client *temp_client;
1325 int adap_id = i2c_adapter_id(adapter);
1327 address_data = driver->address_data;
1328 if (!driver->detect || !address_data)
1331 /* Set up a temporary client to help detect callback */
1332 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1335 temp_client->adapter = adapter;
1337 /* Force entries are done first, and are not affected by ignore
1339 if (address_data->forces) {
1340 const unsigned short * const *forces = address_data->forces;
1343 for (kind = 0; forces[kind]; kind++) {
1344 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1346 if (forces[kind][i] == adap_id
1347 || forces[kind][i] == ANY_I2C_BUS) {
1348 dev_dbg(&adapter->dev, "found force "
1349 "parameter for adapter %d, "
1350 "addr 0x%02x, kind %d\n",
1351 adap_id, forces[kind][i + 1],
1353 temp_client->addr = forces[kind][i + 1];
1354 err = i2c_detect_address(temp_client,
1363 /* Stop here if the classes do not match */
1364 if (!(adapter->class & driver->class))
1367 /* Stop here if we can't use SMBUS_QUICK */
1368 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1369 if (address_data->probe[0] == I2C_CLIENT_END
1370 && address_data->normal_i2c[0] == I2C_CLIENT_END)
1373 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1374 "can't probe for chips\n");
1379 /* Probe entries are done second, and are not affected by ignore
1381 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1382 if (address_data->probe[i] == adap_id
1383 || address_data->probe[i] == ANY_I2C_BUS) {
1384 dev_dbg(&adapter->dev, "found probe parameter for "
1385 "adapter %d, addr 0x%02x\n", adap_id,
1386 address_data->probe[i + 1]);
1387 temp_client->addr = address_data->probe[i + 1];
1388 err = i2c_detect_address(temp_client, -1, driver);
1394 /* Normal entries are done last, unless shadowed by an ignore entry */
1395 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1399 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1401 if ((address_data->ignore[j] == adap_id ||
1402 address_data->ignore[j] == ANY_I2C_BUS)
1403 && address_data->ignore[j + 1]
1404 == address_data->normal_i2c[i]) {
1405 dev_dbg(&adapter->dev, "found ignore "
1406 "parameter for adapter %d, "
1407 "addr 0x%02x\n", adap_id,
1408 address_data->ignore[j + 1]);
1416 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1417 "addr 0x%02x\n", adap_id,
1418 address_data->normal_i2c[i]);
1419 temp_client->addr = address_data->normal_i2c[i];
1420 err = i2c_detect_address(temp_client, -1, driver);
1431 i2c_new_probed_device(struct i2c_adapter *adap,
1432 struct i2c_board_info *info,
1433 unsigned short const *addr_list)
1437 /* Stop here if the bus doesn't support probing */
1438 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1439 dev_err(&adap->dev, "Probing not supported\n");
1443 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1444 /* Check address validity */
1445 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1446 dev_warn(&adap->dev, "Invalid 7-bit address "
1447 "0x%02x\n", addr_list[i]);
1451 /* Check address availability */
1452 if (i2c_check_addr(adap, addr_list[i])) {
1453 dev_dbg(&adap->dev, "Address 0x%02x already in "
1454 "use, not probing\n", addr_list[i]);
1458 /* Test address responsiveness
1459 The default probe method is a quick write, but it is known
1460 to corrupt the 24RF08 EEPROMs due to a state machine bug,
1461 and could also irreversibly write-protect some EEPROMs, so
1462 for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1463 read instead. Also, some bus drivers don't implement
1464 quick write, so we fallback to a byte read it that case
1466 if ((addr_list[i] & ~0x07) == 0x30
1467 || (addr_list[i] & ~0x0f) == 0x50
1468 || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1469 union i2c_smbus_data data;
1471 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1473 I2C_SMBUS_BYTE, &data) >= 0)
1476 if (i2c_smbus_xfer(adap, addr_list[i], 0,
1478 I2C_SMBUS_QUICK, NULL) >= 0)
1483 if (addr_list[i] == I2C_CLIENT_END) {
1484 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1488 info->addr = addr_list[i];
1489 return i2c_new_device(adap, info);
1491 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1493 struct i2c_adapter* i2c_get_adapter(int id)
1495 struct i2c_adapter *adapter;
1497 mutex_lock(&core_lock);
1498 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1499 if (adapter && !try_module_get(adapter->owner))
1502 mutex_unlock(&core_lock);
1505 EXPORT_SYMBOL(i2c_get_adapter);
1507 void i2c_put_adapter(struct i2c_adapter *adap)
1509 module_put(adap->owner);
1511 EXPORT_SYMBOL(i2c_put_adapter);
1513 /* The SMBus parts */
1515 #define POLY (0x1070U << 3)
1521 for(i = 0; i < 8; i++) {
1526 return (u8)(data >> 8);
1529 /* Incremental CRC8 over count bytes in the array pointed to by p */
1530 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1534 for(i = 0; i < count; i++)
1535 crc = crc8((crc ^ p[i]) << 8);
1539 /* Assume a 7-bit address, which is reasonable for SMBus */
1540 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1542 /* The address will be sent first */
1543 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1544 pec = i2c_smbus_pec(pec, &addr, 1);
1546 /* The data buffer follows */
1547 return i2c_smbus_pec(pec, msg->buf, msg->len);
1550 /* Used for write only transactions */
1551 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1553 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1557 /* Return <0 on CRC error
1558 If there was a write before this read (most cases) we need to take the
1559 partial CRC from the write part into account.
1560 Note that this function does modify the message (we need to decrease the
1561 message length to hide the CRC byte from the caller). */
1562 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1564 u8 rpec = msg->buf[--msg->len];
1565 cpec = i2c_smbus_msg_pec(cpec, msg);
1568 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1576 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1577 * @client: Handle to slave device
1579 * This executes the SMBus "receive byte" protocol, returning negative errno
1580 * else the byte received from the device.
1582 s32 i2c_smbus_read_byte(struct i2c_client *client)
1584 union i2c_smbus_data data;
1587 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1589 I2C_SMBUS_BYTE, &data);
1590 return (status < 0) ? status : data.byte;
1592 EXPORT_SYMBOL(i2c_smbus_read_byte);
1595 * i2c_smbus_write_byte - SMBus "send byte" protocol
1596 * @client: Handle to slave device
1597 * @value: Byte to be sent
1599 * This executes the SMBus "send byte" protocol, returning negative errno
1600 * else zero on success.
1602 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1604 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1605 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1607 EXPORT_SYMBOL(i2c_smbus_write_byte);
1610 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1611 * @client: Handle to slave device
1612 * @command: Byte interpreted by slave
1614 * This executes the SMBus "read byte" protocol, returning negative errno
1615 * else a data byte received from the device.
1617 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1619 union i2c_smbus_data data;
1622 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1623 I2C_SMBUS_READ, command,
1624 I2C_SMBUS_BYTE_DATA, &data);
1625 return (status < 0) ? status : data.byte;
1627 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1630 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1631 * @client: Handle to slave device
1632 * @command: Byte interpreted by slave
1633 * @value: Byte being written
1635 * This executes the SMBus "write byte" protocol, returning negative errno
1636 * else zero on success.
1638 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1640 union i2c_smbus_data data;
1642 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1643 I2C_SMBUS_WRITE,command,
1644 I2C_SMBUS_BYTE_DATA,&data);
1646 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1649 * i2c_smbus_read_word_data - SMBus "read word" protocol
1650 * @client: Handle to slave device
1651 * @command: Byte interpreted by slave
1653 * This executes the SMBus "read word" protocol, returning negative errno
1654 * else a 16-bit unsigned "word" received from the device.
1656 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1658 union i2c_smbus_data data;
1661 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1662 I2C_SMBUS_READ, command,
1663 I2C_SMBUS_WORD_DATA, &data);
1664 return (status < 0) ? status : data.word;
1666 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1669 * i2c_smbus_write_word_data - SMBus "write word" protocol
1670 * @client: Handle to slave device
1671 * @command: Byte interpreted by slave
1672 * @value: 16-bit "word" being written
1674 * This executes the SMBus "write word" protocol, returning negative errno
1675 * else zero on success.
1677 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1679 union i2c_smbus_data data;
1681 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1682 I2C_SMBUS_WRITE,command,
1683 I2C_SMBUS_WORD_DATA,&data);
1685 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1688 * i2c_smbus_read_block_data - SMBus "block read" protocol
1689 * @client: Handle to slave device
1690 * @command: Byte interpreted by slave
1691 * @values: Byte array into which data will be read; big enough to hold
1692 * the data returned by the slave. SMBus allows at most 32 bytes.
1694 * This executes the SMBus "block read" protocol, returning negative errno
1695 * else the number of data bytes in the slave's response.
1697 * Note that using this function requires that the client's adapter support
1698 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
1699 * support this; its emulation through I2C messaging relies on a specific
1700 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1702 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1705 union i2c_smbus_data data;
1708 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1709 I2C_SMBUS_READ, command,
1710 I2C_SMBUS_BLOCK_DATA, &data);
1714 memcpy(values, &data.block[1], data.block[0]);
1715 return data.block[0];
1717 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1720 * i2c_smbus_write_block_data - SMBus "block write" protocol
1721 * @client: Handle to slave device
1722 * @command: Byte interpreted by slave
1723 * @length: Size of data block; SMBus allows at most 32 bytes
1724 * @values: Byte array which will be written.
1726 * This executes the SMBus "block write" protocol, returning negative errno
1727 * else zero on success.
1729 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1730 u8 length, const u8 *values)
1732 union i2c_smbus_data data;
1734 if (length > I2C_SMBUS_BLOCK_MAX)
1735 length = I2C_SMBUS_BLOCK_MAX;
1736 data.block[0] = length;
1737 memcpy(&data.block[1], values, length);
1738 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1739 I2C_SMBUS_WRITE,command,
1740 I2C_SMBUS_BLOCK_DATA,&data);
1742 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1744 /* Returns the number of read bytes */
1745 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1746 u8 length, u8 *values)
1748 union i2c_smbus_data data;
1751 if (length > I2C_SMBUS_BLOCK_MAX)
1752 length = I2C_SMBUS_BLOCK_MAX;
1753 data.block[0] = length;
1754 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1755 I2C_SMBUS_READ, command,
1756 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1760 memcpy(values, &data.block[1], data.block[0]);
1761 return data.block[0];
1763 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1765 s32 i2c_smbus_write_i2c_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_I2C_BLOCK_DATA, &data);
1778 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1780 /* Simulate a SMBus command using the i2c protocol
1781 No checking of parameters is done! */
1782 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1783 unsigned short flags,
1784 char read_write, u8 command, int size,
1785 union i2c_smbus_data * data)
1787 /* So we need to generate a series of msgs. In the case of writing, we
1788 need to use only one message; when reading, we need two. We initialize
1789 most things with sane defaults, to keep the code below somewhat
1791 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1792 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1793 int num = read_write == I2C_SMBUS_READ?2:1;
1794 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1795 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1801 msgbuf0[0] = command;
1803 case I2C_SMBUS_QUICK:
1805 /* Special case: The read/write field is used as data */
1806 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1809 case I2C_SMBUS_BYTE:
1810 if (read_write == I2C_SMBUS_READ) {
1811 /* Special case: only a read! */
1812 msg[0].flags = I2C_M_RD | flags;
1816 case I2C_SMBUS_BYTE_DATA:
1817 if (read_write == I2C_SMBUS_READ)
1821 msgbuf0[1] = data->byte;
1824 case I2C_SMBUS_WORD_DATA:
1825 if (read_write == I2C_SMBUS_READ)
1829 msgbuf0[1] = data->word & 0xff;
1830 msgbuf0[2] = data->word >> 8;
1833 case I2C_SMBUS_PROC_CALL:
1834 num = 2; /* Special case */
1835 read_write = I2C_SMBUS_READ;
1838 msgbuf0[1] = data->word & 0xff;
1839 msgbuf0[2] = data->word >> 8;
1841 case I2C_SMBUS_BLOCK_DATA:
1842 if (read_write == I2C_SMBUS_READ) {
1843 msg[1].flags |= I2C_M_RECV_LEN;
1844 msg[1].len = 1; /* block length will be added by
1845 the underlying bus driver */
1847 msg[0].len = data->block[0] + 2;
1848 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1849 dev_err(&adapter->dev,
1850 "Invalid block write size %d\n",
1854 for (i = 1; i < msg[0].len; i++)
1855 msgbuf0[i] = data->block[i-1];
1858 case I2C_SMBUS_BLOCK_PROC_CALL:
1859 num = 2; /* Another special case */
1860 read_write = I2C_SMBUS_READ;
1861 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1862 dev_err(&adapter->dev,
1863 "Invalid block write size %d\n",
1867 msg[0].len = data->block[0] + 2;
1868 for (i = 1; i < msg[0].len; i++)
1869 msgbuf0[i] = data->block[i-1];
1870 msg[1].flags |= I2C_M_RECV_LEN;
1871 msg[1].len = 1; /* block length will be added by
1872 the underlying bus driver */
1874 case I2C_SMBUS_I2C_BLOCK_DATA:
1875 if (read_write == I2C_SMBUS_READ) {
1876 msg[1].len = data->block[0];
1878 msg[0].len = data->block[0] + 1;
1879 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1880 dev_err(&adapter->dev,
1881 "Invalid block write size %d\n",
1885 for (i = 1; i <= data->block[0]; i++)
1886 msgbuf0[i] = data->block[i];
1890 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1894 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1895 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1897 /* Compute PEC if first message is a write */
1898 if (!(msg[0].flags & I2C_M_RD)) {
1899 if (num == 1) /* Write only */
1900 i2c_smbus_add_pec(&msg[0]);
1901 else /* Write followed by read */
1902 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1904 /* Ask for PEC if last message is a read */
1905 if (msg[num-1].flags & I2C_M_RD)
1909 status = i2c_transfer(adapter, msg, num);
1913 /* Check PEC if last message is a read */
1914 if (i && (msg[num-1].flags & I2C_M_RD)) {
1915 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1920 if (read_write == I2C_SMBUS_READ)
1922 case I2C_SMBUS_BYTE:
1923 data->byte = msgbuf0[0];
1925 case I2C_SMBUS_BYTE_DATA:
1926 data->byte = msgbuf1[0];
1928 case I2C_SMBUS_WORD_DATA:
1929 case I2C_SMBUS_PROC_CALL:
1930 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1932 case I2C_SMBUS_I2C_BLOCK_DATA:
1933 for (i = 0; i < data->block[0]; i++)
1934 data->block[i+1] = msgbuf1[i];
1936 case I2C_SMBUS_BLOCK_DATA:
1937 case I2C_SMBUS_BLOCK_PROC_CALL:
1938 for (i = 0; i < msgbuf1[0] + 1; i++)
1939 data->block[i] = msgbuf1[i];
1946 * i2c_smbus_xfer - execute SMBus protocol operations
1947 * @adapter: Handle to I2C bus
1948 * @addr: Address of SMBus slave on that bus
1949 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1950 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1951 * @command: Byte interpreted by slave, for protocols which use such bytes
1952 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1953 * @data: Data to be read or written
1955 * This executes an SMBus protocol operation, and returns a negative
1956 * errno code else zero on success.
1958 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1959 char read_write, u8 command, int protocol,
1960 union i2c_smbus_data * data)
1964 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1966 if (adapter->algo->smbus_xfer) {
1967 mutex_lock(&adapter->bus_lock);
1968 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1969 command, protocol, data);
1970 mutex_unlock(&adapter->bus_lock);
1972 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1973 command, protocol, data);
1977 EXPORT_SYMBOL(i2c_smbus_xfer);
1979 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1980 MODULE_DESCRIPTION("I2C-Bus main module");
1981 MODULE_LICENSE("GPL");