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., 51 Franklin Street, Fifth Floor, Boston,
19 /* ------------------------------------------------------------------------- */
21 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
22 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
23 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
24 Jean Delvare <khali@linux-fr.org>
25 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
26 Michael Lawnick <michael.lawnick.ext@nsn.com>
27 OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
28 (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
29 (c) 2013 Wolfram Sang <wsa@the-dreams.de>
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/delay.h>
35 #include <linux/errno.h>
36 #include <linux/gpio.h>
37 #include <linux/slab.h>
38 #include <linux/i2c.h>
39 #include <linux/init.h>
40 #include <linux/idr.h>
41 #include <linux/mutex.h>
43 #include <linux/of_device.h>
44 #include <linux/of_irq.h>
45 #include <linux/completion.h>
46 #include <linux/hardirq.h>
47 #include <linux/irqflags.h>
48 #include <linux/rwsem.h>
49 #include <linux/pm_runtime.h>
50 #include <linux/acpi.h>
51 #include <asm/uaccess.h>
56 /* core_lock protects i2c_adapter_idr, and guarantees
57 that device detection, deletion of detected devices, and attach_adapter
58 calls are serialized */
59 static DEFINE_MUTEX(core_lock);
60 static DEFINE_IDR(i2c_adapter_idr);
62 static struct device_type i2c_client_type;
63 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
65 /* ------------------------------------------------------------------------- */
67 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
68 const struct i2c_client *client)
71 if (strcmp(client->name, id->name) == 0)
78 static int i2c_device_match(struct device *dev, struct device_driver *drv)
80 struct i2c_client *client = i2c_verify_client(dev);
81 struct i2c_driver *driver;
86 /* Attempt an OF style match */
87 if (of_driver_match_device(dev, drv))
90 /* Then ACPI style match */
91 if (acpi_driver_match_device(dev, drv))
94 driver = to_i2c_driver(drv);
95 /* match on an id table if there is one */
97 return i2c_match_id(driver->id_table, client) != NULL;
103 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
104 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
106 struct i2c_client *client = to_i2c_client(dev);
108 if (add_uevent_var(env, "MODALIAS=%s%s",
109 I2C_MODULE_PREFIX, client->name))
111 dev_dbg(dev, "uevent\n");
115 /* i2c bus recovery routines */
116 static int get_scl_gpio_value(struct i2c_adapter *adap)
118 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
121 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
123 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
126 static int get_sda_gpio_value(struct i2c_adapter *adap)
128 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
131 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
133 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
134 struct device *dev = &adap->dev;
137 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
138 GPIOF_OUT_INIT_HIGH, "i2c-scl");
140 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
145 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
146 /* work without SDA polling */
147 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
156 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
158 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
161 gpio_free(bri->sda_gpio);
163 gpio_free(bri->scl_gpio);
167 * We are generating clock pulses. ndelay() determines durating of clk pulses.
168 * We will generate clock with rate 100 KHz and so duration of both clock levels
169 * is: delay in ns = (10^6 / 100) / 2
171 #define RECOVERY_NDELAY 5000
172 #define RECOVERY_CLK_CNT 9
174 static int i2c_generic_recovery(struct i2c_adapter *adap)
176 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
177 int i = 0, val = 1, ret = 0;
179 if (bri->prepare_recovery)
180 bri->prepare_recovery(bri);
183 * By this time SCL is high, as we need to give 9 falling-rising edges
185 while (i++ < RECOVERY_CLK_CNT * 2) {
187 /* Break if SDA is high */
188 if (bri->get_sda && bri->get_sda(adap))
190 /* SCL shouldn't be low here */
191 if (!bri->get_scl(adap)) {
193 "SCL is stuck low, exit recovery\n");
200 bri->set_scl(adap, val);
201 ndelay(RECOVERY_NDELAY);
204 if (bri->unprepare_recovery)
205 bri->unprepare_recovery(bri);
210 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
212 adap->bus_recovery_info->set_scl(adap, 1);
213 return i2c_generic_recovery(adap);
216 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
220 ret = i2c_get_gpios_for_recovery(adap);
224 ret = i2c_generic_recovery(adap);
225 i2c_put_gpios_for_recovery(adap);
230 int i2c_recover_bus(struct i2c_adapter *adap)
232 if (!adap->bus_recovery_info)
235 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
236 return adap->bus_recovery_info->recover_bus(adap);
239 static int i2c_device_probe(struct device *dev)
241 struct i2c_client *client = i2c_verify_client(dev);
242 struct i2c_driver *driver;
248 driver = to_i2c_driver(dev->driver);
249 if (!driver->probe || !driver->id_table)
252 if (!device_can_wakeup(&client->dev))
253 device_init_wakeup(&client->dev,
254 client->flags & I2C_CLIENT_WAKE);
255 dev_dbg(dev, "probe\n");
257 acpi_dev_pm_attach(&client->dev, true);
258 status = driver->probe(client, i2c_match_id(driver->id_table, client));
260 acpi_dev_pm_detach(&client->dev, true);
265 static int i2c_device_remove(struct device *dev)
267 struct i2c_client *client = i2c_verify_client(dev);
268 struct i2c_driver *driver;
271 if (!client || !dev->driver)
274 driver = to_i2c_driver(dev->driver);
275 if (driver->remove) {
276 dev_dbg(dev, "remove\n");
277 status = driver->remove(client);
280 acpi_dev_pm_detach(&client->dev, true);
284 static void i2c_device_shutdown(struct device *dev)
286 struct i2c_client *client = i2c_verify_client(dev);
287 struct i2c_driver *driver;
289 if (!client || !dev->driver)
291 driver = to_i2c_driver(dev->driver);
292 if (driver->shutdown)
293 driver->shutdown(client);
296 #ifdef CONFIG_PM_SLEEP
297 static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
299 struct i2c_client *client = i2c_verify_client(dev);
300 struct i2c_driver *driver;
302 if (!client || !dev->driver)
304 driver = to_i2c_driver(dev->driver);
305 if (!driver->suspend)
307 return driver->suspend(client, mesg);
310 static int i2c_legacy_resume(struct device *dev)
312 struct i2c_client *client = i2c_verify_client(dev);
313 struct i2c_driver *driver;
315 if (!client || !dev->driver)
317 driver = to_i2c_driver(dev->driver);
320 return driver->resume(client);
323 static int i2c_device_pm_suspend(struct device *dev)
325 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
328 return pm_generic_suspend(dev);
330 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
333 static int i2c_device_pm_resume(struct device *dev)
335 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
338 return pm_generic_resume(dev);
340 return i2c_legacy_resume(dev);
343 static int i2c_device_pm_freeze(struct device *dev)
345 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
348 return pm_generic_freeze(dev);
350 return i2c_legacy_suspend(dev, PMSG_FREEZE);
353 static int i2c_device_pm_thaw(struct device *dev)
355 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
358 return pm_generic_thaw(dev);
360 return i2c_legacy_resume(dev);
363 static int i2c_device_pm_poweroff(struct device *dev)
365 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
368 return pm_generic_poweroff(dev);
370 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
373 static int i2c_device_pm_restore(struct device *dev)
375 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
378 return pm_generic_restore(dev);
380 return i2c_legacy_resume(dev);
382 #else /* !CONFIG_PM_SLEEP */
383 #define i2c_device_pm_suspend NULL
384 #define i2c_device_pm_resume NULL
385 #define i2c_device_pm_freeze NULL
386 #define i2c_device_pm_thaw NULL
387 #define i2c_device_pm_poweroff NULL
388 #define i2c_device_pm_restore NULL
389 #endif /* !CONFIG_PM_SLEEP */
391 static void i2c_client_dev_release(struct device *dev)
393 kfree(to_i2c_client(dev));
397 show_name(struct device *dev, struct device_attribute *attr, char *buf)
399 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
400 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
404 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
406 struct i2c_client *client = to_i2c_client(dev);
407 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
410 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
411 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
413 static struct attribute *i2c_dev_attrs[] = {
415 /* modalias helps coldplug: modprobe $(cat .../modalias) */
416 &dev_attr_modalias.attr,
420 static struct attribute_group i2c_dev_attr_group = {
421 .attrs = i2c_dev_attrs,
424 static const struct attribute_group *i2c_dev_attr_groups[] = {
429 static const struct dev_pm_ops i2c_device_pm_ops = {
430 .suspend = i2c_device_pm_suspend,
431 .resume = i2c_device_pm_resume,
432 .freeze = i2c_device_pm_freeze,
433 .thaw = i2c_device_pm_thaw,
434 .poweroff = i2c_device_pm_poweroff,
435 .restore = i2c_device_pm_restore,
437 pm_generic_runtime_suspend,
438 pm_generic_runtime_resume,
443 struct bus_type i2c_bus_type = {
445 .match = i2c_device_match,
446 .probe = i2c_device_probe,
447 .remove = i2c_device_remove,
448 .shutdown = i2c_device_shutdown,
449 .pm = &i2c_device_pm_ops,
451 EXPORT_SYMBOL_GPL(i2c_bus_type);
453 static struct device_type i2c_client_type = {
454 .groups = i2c_dev_attr_groups,
455 .uevent = i2c_device_uevent,
456 .release = i2c_client_dev_release,
461 * i2c_verify_client - return parameter as i2c_client, or NULL
462 * @dev: device, probably from some driver model iterator
464 * When traversing the driver model tree, perhaps using driver model
465 * iterators like @device_for_each_child(), you can't assume very much
466 * about the nodes you find. Use this function to avoid oopses caused
467 * by wrongly treating some non-I2C device as an i2c_client.
469 struct i2c_client *i2c_verify_client(struct device *dev)
471 return (dev->type == &i2c_client_type)
475 EXPORT_SYMBOL(i2c_verify_client);
478 /* This is a permissive address validity check, I2C address map constraints
479 * are purposely not enforced, except for the general call address. */
480 static int i2c_check_client_addr_validity(const struct i2c_client *client)
482 if (client->flags & I2C_CLIENT_TEN) {
483 /* 10-bit address, all values are valid */
484 if (client->addr > 0x3ff)
487 /* 7-bit address, reject the general call address */
488 if (client->addr == 0x00 || client->addr > 0x7f)
494 /* And this is a strict address validity check, used when probing. If a
495 * device uses a reserved address, then it shouldn't be probed. 7-bit
496 * addressing is assumed, 10-bit address devices are rare and should be
497 * explicitly enumerated. */
498 static int i2c_check_addr_validity(unsigned short addr)
501 * Reserved addresses per I2C specification:
502 * 0x00 General call address / START byte
504 * 0x02 Reserved for different bus format
505 * 0x03 Reserved for future purposes
506 * 0x04-0x07 Hs-mode master code
507 * 0x78-0x7b 10-bit slave addressing
508 * 0x7c-0x7f Reserved for future purposes
510 if (addr < 0x08 || addr > 0x77)
515 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
517 struct i2c_client *client = i2c_verify_client(dev);
518 int addr = *(int *)addrp;
520 if (client && client->addr == addr)
525 /* walk up mux tree */
526 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
528 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
531 result = device_for_each_child(&adapter->dev, &addr,
532 __i2c_check_addr_busy);
534 if (!result && parent)
535 result = i2c_check_mux_parents(parent, addr);
540 /* recurse down mux tree */
541 static int i2c_check_mux_children(struct device *dev, void *addrp)
545 if (dev->type == &i2c_adapter_type)
546 result = device_for_each_child(dev, addrp,
547 i2c_check_mux_children);
549 result = __i2c_check_addr_busy(dev, addrp);
554 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
556 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
560 result = i2c_check_mux_parents(parent, addr);
563 result = device_for_each_child(&adapter->dev, &addr,
564 i2c_check_mux_children);
570 * i2c_lock_adapter - Get exclusive access to an I2C bus segment
571 * @adapter: Target I2C bus segment
573 void i2c_lock_adapter(struct i2c_adapter *adapter)
575 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
578 i2c_lock_adapter(parent);
580 rt_mutex_lock(&adapter->bus_lock);
582 EXPORT_SYMBOL_GPL(i2c_lock_adapter);
585 * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
586 * @adapter: Target I2C bus segment
588 static int i2c_trylock_adapter(struct i2c_adapter *adapter)
590 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
593 return i2c_trylock_adapter(parent);
595 return rt_mutex_trylock(&adapter->bus_lock);
599 * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
600 * @adapter: Target I2C bus segment
602 void i2c_unlock_adapter(struct i2c_adapter *adapter)
604 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
607 i2c_unlock_adapter(parent);
609 rt_mutex_unlock(&adapter->bus_lock);
611 EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
613 static void i2c_dev_set_name(struct i2c_adapter *adap,
614 struct i2c_client *client)
616 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
619 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
623 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
624 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
625 client->addr | ((client->flags & I2C_CLIENT_TEN)
630 * i2c_new_device - instantiate an i2c device
631 * @adap: the adapter managing the device
632 * @info: describes one I2C device; bus_num is ignored
635 * Create an i2c device. Binding is handled through driver model
636 * probe()/remove() methods. A driver may be bound to this device when we
637 * return from this function, or any later moment (e.g. maybe hotplugging will
638 * load the driver module). This call is not appropriate for use by mainboard
639 * initialization logic, which usually runs during an arch_initcall() long
640 * before any i2c_adapter could exist.
642 * This returns the new i2c client, which may be saved for later use with
643 * i2c_unregister_device(); or NULL to indicate an error.
646 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
648 struct i2c_client *client;
651 client = kzalloc(sizeof *client, GFP_KERNEL);
655 client->adapter = adap;
657 client->dev.platform_data = info->platform_data;
660 client->dev.archdata = *info->archdata;
662 client->flags = info->flags;
663 client->addr = info->addr;
664 client->irq = info->irq;
666 strlcpy(client->name, info->type, sizeof(client->name));
668 /* Check for address validity */
669 status = i2c_check_client_addr_validity(client);
671 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
672 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
676 /* Check for address business */
677 status = i2c_check_addr_busy(adap, client->addr);
681 client->dev.parent = &client->adapter->dev;
682 client->dev.bus = &i2c_bus_type;
683 client->dev.type = &i2c_client_type;
684 client->dev.of_node = info->of_node;
685 ACPI_COMPANION_SET(&client->dev, info->acpi_node.companion);
687 i2c_dev_set_name(adap, client);
688 status = device_register(&client->dev);
692 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
693 client->name, dev_name(&client->dev));
698 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
699 "(%d)\n", client->name, client->addr, status);
704 EXPORT_SYMBOL_GPL(i2c_new_device);
708 * i2c_unregister_device - reverse effect of i2c_new_device()
709 * @client: value returned from i2c_new_device()
712 void i2c_unregister_device(struct i2c_client *client)
714 device_unregister(&client->dev);
716 EXPORT_SYMBOL_GPL(i2c_unregister_device);
719 static const struct i2c_device_id dummy_id[] = {
724 static int dummy_probe(struct i2c_client *client,
725 const struct i2c_device_id *id)
730 static int dummy_remove(struct i2c_client *client)
735 static struct i2c_driver dummy_driver = {
736 .driver.name = "dummy",
737 .probe = dummy_probe,
738 .remove = dummy_remove,
739 .id_table = dummy_id,
743 * i2c_new_dummy - return a new i2c device bound to a dummy driver
744 * @adapter: the adapter managing the device
745 * @address: seven bit address to be used
748 * This returns an I2C client bound to the "dummy" driver, intended for use
749 * with devices that consume multiple addresses. Examples of such chips
750 * include various EEPROMS (like 24c04 and 24c08 models).
752 * These dummy devices have two main uses. First, most I2C and SMBus calls
753 * except i2c_transfer() need a client handle; the dummy will be that handle.
754 * And second, this prevents the specified address from being bound to a
757 * This returns the new i2c client, which should be saved for later use with
758 * i2c_unregister_device(); or NULL to indicate an error.
760 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
762 struct i2c_board_info info = {
763 I2C_BOARD_INFO("dummy", address),
766 return i2c_new_device(adapter, &info);
768 EXPORT_SYMBOL_GPL(i2c_new_dummy);
770 /* ------------------------------------------------------------------------- */
772 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
774 static void i2c_adapter_dev_release(struct device *dev)
776 struct i2c_adapter *adap = to_i2c_adapter(dev);
777 complete(&adap->dev_released);
781 * This function is only needed for mutex_lock_nested, so it is never
782 * called unless locking correctness checking is enabled. Thus we
783 * make it inline to avoid a compiler warning. That's what gcc ends up
786 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
788 unsigned int depth = 0;
790 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
797 * Let users instantiate I2C devices through sysfs. This can be used when
798 * platform initialization code doesn't contain the proper data for
799 * whatever reason. Also useful for drivers that do device detection and
800 * detection fails, either because the device uses an unexpected address,
801 * or this is a compatible device with different ID register values.
803 * Parameter checking may look overzealous, but we really don't want
804 * the user to provide incorrect parameters.
807 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
808 const char *buf, size_t count)
810 struct i2c_adapter *adap = to_i2c_adapter(dev);
811 struct i2c_board_info info;
812 struct i2c_client *client;
816 memset(&info, 0, sizeof(struct i2c_board_info));
818 blank = strchr(buf, ' ');
820 dev_err(dev, "%s: Missing parameters\n", "new_device");
823 if (blank - buf > I2C_NAME_SIZE - 1) {
824 dev_err(dev, "%s: Invalid device name\n", "new_device");
827 memcpy(info.type, buf, blank - buf);
829 /* Parse remaining parameters, reject extra parameters */
830 res = sscanf(++blank, "%hi%c", &info.addr, &end);
832 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
835 if (res > 1 && end != '\n') {
836 dev_err(dev, "%s: Extra parameters\n", "new_device");
840 client = i2c_new_device(adap, &info);
844 /* Keep track of the added device */
845 mutex_lock(&adap->userspace_clients_lock);
846 list_add_tail(&client->detected, &adap->userspace_clients);
847 mutex_unlock(&adap->userspace_clients_lock);
848 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
849 info.type, info.addr);
855 * And of course let the users delete the devices they instantiated, if
856 * they got it wrong. This interface can only be used to delete devices
857 * instantiated by i2c_sysfs_new_device above. This guarantees that we
858 * don't delete devices to which some kernel code still has references.
860 * Parameter checking may look overzealous, but we really don't want
861 * the user to delete the wrong device.
864 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
865 const char *buf, size_t count)
867 struct i2c_adapter *adap = to_i2c_adapter(dev);
868 struct i2c_client *client, *next;
873 /* Parse parameters, reject extra parameters */
874 res = sscanf(buf, "%hi%c", &addr, &end);
876 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
879 if (res > 1 && end != '\n') {
880 dev_err(dev, "%s: Extra parameters\n", "delete_device");
884 /* Make sure the device was added through sysfs */
886 mutex_lock_nested(&adap->userspace_clients_lock,
887 i2c_adapter_depth(adap));
888 list_for_each_entry_safe(client, next, &adap->userspace_clients,
890 if (client->addr == addr) {
891 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
892 "delete_device", client->name, client->addr);
894 list_del(&client->detected);
895 i2c_unregister_device(client);
900 mutex_unlock(&adap->userspace_clients_lock);
903 dev_err(dev, "%s: Can't find device in list\n",
908 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
909 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
910 i2c_sysfs_delete_device);
912 static struct attribute *i2c_adapter_attrs[] = {
914 &dev_attr_new_device.attr,
915 &dev_attr_delete_device.attr,
919 static struct attribute_group i2c_adapter_attr_group = {
920 .attrs = i2c_adapter_attrs,
923 static const struct attribute_group *i2c_adapter_attr_groups[] = {
924 &i2c_adapter_attr_group,
928 struct device_type i2c_adapter_type = {
929 .groups = i2c_adapter_attr_groups,
930 .release = i2c_adapter_dev_release,
932 EXPORT_SYMBOL_GPL(i2c_adapter_type);
935 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
936 * @dev: device, probably from some driver model iterator
938 * When traversing the driver model tree, perhaps using driver model
939 * iterators like @device_for_each_child(), you can't assume very much
940 * about the nodes you find. Use this function to avoid oopses caused
941 * by wrongly treating some non-I2C device as an i2c_adapter.
943 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
945 return (dev->type == &i2c_adapter_type)
946 ? to_i2c_adapter(dev)
949 EXPORT_SYMBOL(i2c_verify_adapter);
951 #ifdef CONFIG_I2C_COMPAT
952 static struct class_compat *i2c_adapter_compat_class;
955 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
957 struct i2c_devinfo *devinfo;
959 down_read(&__i2c_board_lock);
960 list_for_each_entry(devinfo, &__i2c_board_list, list) {
961 if (devinfo->busnum == adapter->nr
962 && !i2c_new_device(adapter,
963 &devinfo->board_info))
964 dev_err(&adapter->dev,
965 "Can't create device at 0x%02x\n",
966 devinfo->board_info.addr);
968 up_read(&__i2c_board_lock);
971 /* OF support code */
973 #if IS_ENABLED(CONFIG_OF)
974 static void of_i2c_register_devices(struct i2c_adapter *adap)
977 struct device_node *node;
979 /* Only register child devices if the adapter has a node pointer set */
980 if (!adap->dev.of_node)
983 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
985 for_each_available_child_of_node(adap->dev.of_node, node) {
986 struct i2c_board_info info = {};
987 struct dev_archdata dev_ad = {};
991 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
993 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
994 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
999 addr = of_get_property(node, "reg", &len);
1000 if (!addr || (len < sizeof(int))) {
1001 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1006 info.addr = be32_to_cpup(addr);
1007 if (info.addr > (1 << 10) - 1) {
1008 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1009 info.addr, node->full_name);
1013 info.irq = irq_of_parse_and_map(node, 0);
1014 info.of_node = of_node_get(node);
1015 info.archdata = &dev_ad;
1017 if (of_get_property(node, "wakeup-source", NULL))
1018 info.flags |= I2C_CLIENT_WAKE;
1020 request_module("%s%s", I2C_MODULE_PREFIX, info.type);
1022 result = i2c_new_device(adap, &info);
1023 if (result == NULL) {
1024 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1027 irq_dispose_mapping(info.irq);
1033 static int of_dev_node_match(struct device *dev, void *data)
1035 return dev->of_node == data;
1038 /* must call put_device() when done with returned i2c_client device */
1039 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1043 dev = bus_find_device(&i2c_bus_type, NULL, node,
1048 return i2c_verify_client(dev);
1050 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1052 /* must call put_device() when done with returned i2c_adapter device */
1053 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1057 dev = bus_find_device(&i2c_bus_type, NULL, node,
1062 return i2c_verify_adapter(dev);
1064 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1066 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1067 #endif /* CONFIG_OF */
1069 /* ACPI support code */
1071 #if IS_ENABLED(CONFIG_ACPI)
1072 static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
1074 struct i2c_board_info *info = data;
1076 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
1077 struct acpi_resource_i2c_serialbus *sb;
1079 sb = &ares->data.i2c_serial_bus;
1080 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
1081 info->addr = sb->slave_address;
1082 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
1083 info->flags |= I2C_CLIENT_TEN;
1085 } else if (info->irq < 0) {
1088 if (acpi_dev_resource_interrupt(ares, 0, &r))
1089 info->irq = r.start;
1092 /* Tell the ACPI core to skip this resource */
1096 static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
1097 void *data, void **return_value)
1099 struct i2c_adapter *adapter = data;
1100 struct list_head resource_list;
1101 struct i2c_board_info info;
1102 struct acpi_device *adev;
1105 if (acpi_bus_get_device(handle, &adev))
1107 if (acpi_bus_get_status(adev) || !adev->status.present)
1110 memset(&info, 0, sizeof(info));
1111 info.acpi_node.companion = adev;
1114 INIT_LIST_HEAD(&resource_list);
1115 ret = acpi_dev_get_resources(adev, &resource_list,
1116 acpi_i2c_add_resource, &info);
1117 acpi_dev_free_resource_list(&resource_list);
1119 if (ret < 0 || !info.addr)
1122 adev->power.flags.ignore_parent = true;
1123 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
1124 if (!i2c_new_device(adapter, &info)) {
1125 adev->power.flags.ignore_parent = false;
1126 dev_err(&adapter->dev,
1127 "failed to add I2C device %s from ACPI\n",
1128 dev_name(&adev->dev));
1135 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
1136 * @adap: pointer to adapter
1138 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
1139 * namespace. When a device is found it will be added to the Linux device
1140 * model and bound to the corresponding ACPI handle.
1142 static void acpi_i2c_register_devices(struct i2c_adapter *adap)
1147 if (!adap->dev.parent)
1150 handle = ACPI_HANDLE(adap->dev.parent);
1154 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
1155 acpi_i2c_add_device, NULL,
1157 if (ACPI_FAILURE(status))
1158 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
1161 static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) {}
1162 #endif /* CONFIG_ACPI */
1164 static int i2c_do_add_adapter(struct i2c_driver *driver,
1165 struct i2c_adapter *adap)
1167 /* Detect supported devices on that bus, and instantiate them */
1168 i2c_detect(adap, driver);
1170 /* Let legacy drivers scan this bus for matching devices */
1171 if (driver->attach_adapter) {
1172 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1173 driver->driver.name);
1174 dev_warn(&adap->dev, "Please use another way to instantiate "
1175 "your i2c_client\n");
1176 /* We ignore the return code; if it fails, too bad */
1177 driver->attach_adapter(adap);
1182 static int __process_new_adapter(struct device_driver *d, void *data)
1184 return i2c_do_add_adapter(to_i2c_driver(d), data);
1187 static int i2c_register_adapter(struct i2c_adapter *adap)
1191 /* Can't register until after driver model init */
1192 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
1198 if (unlikely(adap->name[0] == '\0')) {
1199 pr_err("i2c-core: Attempt to register an adapter with "
1203 if (unlikely(!adap->algo)) {
1204 pr_err("i2c-core: Attempt to register adapter '%s' with "
1205 "no algo!\n", adap->name);
1209 rt_mutex_init(&adap->bus_lock);
1210 mutex_init(&adap->userspace_clients_lock);
1211 INIT_LIST_HEAD(&adap->userspace_clients);
1213 /* Set default timeout to 1 second if not already set */
1214 if (adap->timeout == 0)
1217 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1218 adap->dev.bus = &i2c_bus_type;
1219 adap->dev.type = &i2c_adapter_type;
1220 res = device_register(&adap->dev);
1224 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1226 #ifdef CONFIG_I2C_COMPAT
1227 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1230 dev_warn(&adap->dev,
1231 "Failed to create compatibility class link\n");
1234 /* bus recovery specific initialization */
1235 if (adap->bus_recovery_info) {
1236 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1238 if (!bri->recover_bus) {
1239 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1240 adap->bus_recovery_info = NULL;
1244 /* Generic GPIO recovery */
1245 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1246 if (!gpio_is_valid(bri->scl_gpio)) {
1247 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1248 adap->bus_recovery_info = NULL;
1252 if (gpio_is_valid(bri->sda_gpio))
1253 bri->get_sda = get_sda_gpio_value;
1255 bri->get_sda = NULL;
1257 bri->get_scl = get_scl_gpio_value;
1258 bri->set_scl = set_scl_gpio_value;
1259 } else if (!bri->set_scl || !bri->get_scl) {
1260 /* Generic SCL recovery */
1261 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1262 adap->bus_recovery_info = NULL;
1267 /* create pre-declared device nodes */
1268 of_i2c_register_devices(adap);
1269 acpi_i2c_register_devices(adap);
1271 if (adap->nr < __i2c_first_dynamic_bus_num)
1272 i2c_scan_static_board_info(adap);
1274 /* Notify drivers */
1275 mutex_lock(&core_lock);
1276 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1277 mutex_unlock(&core_lock);
1282 mutex_lock(&core_lock);
1283 idr_remove(&i2c_adapter_idr, adap->nr);
1284 mutex_unlock(&core_lock);
1289 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1290 * @adap: the adapter to register (with adap->nr initialized)
1291 * Context: can sleep
1293 * See i2c_add_numbered_adapter() for details.
1295 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1299 mutex_lock(&core_lock);
1300 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1302 mutex_unlock(&core_lock);
1304 return id == -ENOSPC ? -EBUSY : id;
1306 return i2c_register_adapter(adap);
1310 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1311 * @adapter: the adapter to add
1312 * Context: can sleep
1314 * This routine is used to declare an I2C adapter when its bus number
1315 * doesn't matter or when its bus number is specified by an dt alias.
1316 * Examples of bases when the bus number doesn't matter: I2C adapters
1317 * dynamically added by USB links or PCI plugin cards.
1319 * When this returns zero, a new bus number was allocated and stored
1320 * in adap->nr, and the specified adapter became available for clients.
1321 * Otherwise, a negative errno value is returned.
1323 int i2c_add_adapter(struct i2c_adapter *adapter)
1325 struct device *dev = &adapter->dev;
1329 id = of_alias_get_id(dev->of_node, "i2c");
1332 return __i2c_add_numbered_adapter(adapter);
1336 mutex_lock(&core_lock);
1337 id = idr_alloc(&i2c_adapter_idr, adapter,
1338 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1339 mutex_unlock(&core_lock);
1345 return i2c_register_adapter(adapter);
1347 EXPORT_SYMBOL(i2c_add_adapter);
1350 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1351 * @adap: the adapter to register (with adap->nr initialized)
1352 * Context: can sleep
1354 * This routine is used to declare an I2C adapter when its bus number
1355 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1356 * or otherwise built in to the system's mainboard, and where i2c_board_info
1357 * is used to properly configure I2C devices.
1359 * If the requested bus number is set to -1, then this function will behave
1360 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1362 * If no devices have pre-been declared for this bus, then be sure to
1363 * register the adapter before any dynamically allocated ones. Otherwise
1364 * the required bus ID may not be available.
1366 * When this returns zero, the specified adapter became available for
1367 * clients using the bus number provided in adap->nr. Also, the table
1368 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1369 * and the appropriate driver model device nodes are created. Otherwise, a
1370 * negative errno value is returned.
1372 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1374 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1375 return i2c_add_adapter(adap);
1377 return __i2c_add_numbered_adapter(adap);
1379 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1381 static void i2c_do_del_adapter(struct i2c_driver *driver,
1382 struct i2c_adapter *adapter)
1384 struct i2c_client *client, *_n;
1386 /* Remove the devices we created ourselves as the result of hardware
1387 * probing (using a driver's detect method) */
1388 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1389 if (client->adapter == adapter) {
1390 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1391 client->name, client->addr);
1392 list_del(&client->detected);
1393 i2c_unregister_device(client);
1398 static int __unregister_client(struct device *dev, void *dummy)
1400 struct i2c_client *client = i2c_verify_client(dev);
1401 if (client && strcmp(client->name, "dummy"))
1402 i2c_unregister_device(client);
1406 static int __unregister_dummy(struct device *dev, void *dummy)
1408 struct i2c_client *client = i2c_verify_client(dev);
1410 i2c_unregister_device(client);
1414 static int __process_removed_adapter(struct device_driver *d, void *data)
1416 i2c_do_del_adapter(to_i2c_driver(d), data);
1421 * i2c_del_adapter - unregister I2C adapter
1422 * @adap: the adapter being unregistered
1423 * Context: can sleep
1425 * This unregisters an I2C adapter which was previously registered
1426 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1428 void i2c_del_adapter(struct i2c_adapter *adap)
1430 struct i2c_adapter *found;
1431 struct i2c_client *client, *next;
1433 /* First make sure that this adapter was ever added */
1434 mutex_lock(&core_lock);
1435 found = idr_find(&i2c_adapter_idr, adap->nr);
1436 mutex_unlock(&core_lock);
1437 if (found != adap) {
1438 pr_debug("i2c-core: attempting to delete unregistered "
1439 "adapter [%s]\n", adap->name);
1443 /* Tell drivers about this removal */
1444 mutex_lock(&core_lock);
1445 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1446 __process_removed_adapter);
1447 mutex_unlock(&core_lock);
1449 /* Remove devices instantiated from sysfs */
1450 mutex_lock_nested(&adap->userspace_clients_lock,
1451 i2c_adapter_depth(adap));
1452 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1454 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1456 list_del(&client->detected);
1457 i2c_unregister_device(client);
1459 mutex_unlock(&adap->userspace_clients_lock);
1461 /* Detach any active clients. This can't fail, thus we do not
1462 * check the returned value. This is a two-pass process, because
1463 * we can't remove the dummy devices during the first pass: they
1464 * could have been instantiated by real devices wishing to clean
1465 * them up properly, so we give them a chance to do that first. */
1466 device_for_each_child(&adap->dev, NULL, __unregister_client);
1467 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1469 #ifdef CONFIG_I2C_COMPAT
1470 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1474 /* device name is gone after device_unregister */
1475 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1477 /* clean up the sysfs representation */
1478 init_completion(&adap->dev_released);
1479 device_unregister(&adap->dev);
1481 /* wait for sysfs to drop all references */
1482 wait_for_completion(&adap->dev_released);
1485 mutex_lock(&core_lock);
1486 idr_remove(&i2c_adapter_idr, adap->nr);
1487 mutex_unlock(&core_lock);
1489 /* Clear the device structure in case this adapter is ever going to be
1491 memset(&adap->dev, 0, sizeof(adap->dev));
1493 EXPORT_SYMBOL(i2c_del_adapter);
1495 /* ------------------------------------------------------------------------- */
1497 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1501 mutex_lock(&core_lock);
1502 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1503 mutex_unlock(&core_lock);
1507 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1509 static int __process_new_driver(struct device *dev, void *data)
1511 if (dev->type != &i2c_adapter_type)
1513 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1517 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1518 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1521 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1525 /* Can't register until after driver model init */
1526 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1529 /* add the driver to the list of i2c drivers in the driver core */
1530 driver->driver.owner = owner;
1531 driver->driver.bus = &i2c_bus_type;
1533 /* When registration returns, the driver core
1534 * will have called probe() for all matching-but-unbound devices.
1536 res = driver_register(&driver->driver);
1540 /* Drivers should switch to dev_pm_ops instead. */
1541 if (driver->suspend)
1542 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1543 driver->driver.name);
1545 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1546 driver->driver.name);
1548 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1550 INIT_LIST_HEAD(&driver->clients);
1551 /* Walk the adapters that are already present */
1552 i2c_for_each_dev(driver, __process_new_driver);
1556 EXPORT_SYMBOL(i2c_register_driver);
1558 static int __process_removed_driver(struct device *dev, void *data)
1560 if (dev->type == &i2c_adapter_type)
1561 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1566 * i2c_del_driver - unregister I2C driver
1567 * @driver: the driver being unregistered
1568 * Context: can sleep
1570 void i2c_del_driver(struct i2c_driver *driver)
1572 i2c_for_each_dev(driver, __process_removed_driver);
1574 driver_unregister(&driver->driver);
1575 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1577 EXPORT_SYMBOL(i2c_del_driver);
1579 /* ------------------------------------------------------------------------- */
1582 * i2c_use_client - increments the reference count of the i2c client structure
1583 * @client: the client being referenced
1585 * Each live reference to a client should be refcounted. The driver model does
1586 * that automatically as part of driver binding, so that most drivers don't
1587 * need to do this explicitly: they hold a reference until they're unbound
1590 * A pointer to the client with the incremented reference counter is returned.
1592 struct i2c_client *i2c_use_client(struct i2c_client *client)
1594 if (client && get_device(&client->dev))
1598 EXPORT_SYMBOL(i2c_use_client);
1601 * i2c_release_client - release a use of the i2c client structure
1602 * @client: the client being no longer referenced
1604 * Must be called when a user of a client is finished with it.
1606 void i2c_release_client(struct i2c_client *client)
1609 put_device(&client->dev);
1611 EXPORT_SYMBOL(i2c_release_client);
1613 struct i2c_cmd_arg {
1618 static int i2c_cmd(struct device *dev, void *_arg)
1620 struct i2c_client *client = i2c_verify_client(dev);
1621 struct i2c_cmd_arg *arg = _arg;
1622 struct i2c_driver *driver;
1624 if (!client || !client->dev.driver)
1627 driver = to_i2c_driver(client->dev.driver);
1628 if (driver->command)
1629 driver->command(client, arg->cmd, arg->arg);
1633 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1635 struct i2c_cmd_arg cmd_arg;
1639 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1641 EXPORT_SYMBOL(i2c_clients_command);
1643 static int __init i2c_init(void)
1647 retval = bus_register(&i2c_bus_type);
1650 #ifdef CONFIG_I2C_COMPAT
1651 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1652 if (!i2c_adapter_compat_class) {
1657 retval = i2c_add_driver(&dummy_driver);
1663 #ifdef CONFIG_I2C_COMPAT
1664 class_compat_unregister(i2c_adapter_compat_class);
1667 bus_unregister(&i2c_bus_type);
1671 static void __exit i2c_exit(void)
1673 i2c_del_driver(&dummy_driver);
1674 #ifdef CONFIG_I2C_COMPAT
1675 class_compat_unregister(i2c_adapter_compat_class);
1677 bus_unregister(&i2c_bus_type);
1680 /* We must initialize early, because some subsystems register i2c drivers
1681 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1683 postcore_initcall(i2c_init);
1684 module_exit(i2c_exit);
1686 /* ----------------------------------------------------
1687 * the functional interface to the i2c busses.
1688 * ----------------------------------------------------
1692 * __i2c_transfer - unlocked flavor of i2c_transfer
1693 * @adap: Handle to I2C bus
1694 * @msgs: One or more messages to execute before STOP is issued to
1695 * terminate the operation; each message begins with a START.
1696 * @num: Number of messages to be executed.
1698 * Returns negative errno, else the number of messages executed.
1700 * Adapter lock must be held when calling this function. No debug logging
1701 * takes place. adap->algo->master_xfer existence isn't checked.
1703 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1705 unsigned long orig_jiffies;
1708 /* Retry automatically on arbitration loss */
1709 orig_jiffies = jiffies;
1710 for (ret = 0, try = 0; try <= adap->retries; try++) {
1711 ret = adap->algo->master_xfer(adap, msgs, num);
1714 if (time_after(jiffies, orig_jiffies + adap->timeout))
1720 EXPORT_SYMBOL(__i2c_transfer);
1723 * i2c_transfer - execute a single or combined I2C message
1724 * @adap: Handle to I2C bus
1725 * @msgs: One or more messages to execute before STOP is issued to
1726 * terminate the operation; each message begins with a START.
1727 * @num: Number of messages to be executed.
1729 * Returns negative errno, else the number of messages executed.
1731 * Note that there is no requirement that each message be sent to
1732 * the same slave address, although that is the most common model.
1734 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1738 /* REVISIT the fault reporting model here is weak:
1740 * - When we get an error after receiving N bytes from a slave,
1741 * there is no way to report "N".
1743 * - When we get a NAK after transmitting N bytes to a slave,
1744 * there is no way to report "N" ... or to let the master
1745 * continue executing the rest of this combined message, if
1746 * that's the appropriate response.
1748 * - When for example "num" is two and we successfully complete
1749 * the first message but get an error part way through the
1750 * second, it's unclear whether that should be reported as
1751 * one (discarding status on the second message) or errno
1752 * (discarding status on the first one).
1755 if (adap->algo->master_xfer) {
1757 for (ret = 0; ret < num; ret++) {
1758 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1759 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1760 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1761 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1765 if (in_atomic() || irqs_disabled()) {
1766 ret = i2c_trylock_adapter(adap);
1768 /* I2C activity is ongoing. */
1771 i2c_lock_adapter(adap);
1774 ret = __i2c_transfer(adap, msgs, num);
1775 i2c_unlock_adapter(adap);
1779 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1783 EXPORT_SYMBOL(i2c_transfer);
1786 * i2c_master_send - issue a single I2C message in master transmit mode
1787 * @client: Handle to slave device
1788 * @buf: Data that will be written to the slave
1789 * @count: How many bytes to write, must be less than 64k since msg.len is u16
1791 * Returns negative errno, or else the number of bytes written.
1793 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1796 struct i2c_adapter *adap = client->adapter;
1799 msg.addr = client->addr;
1800 msg.flags = client->flags & I2C_M_TEN;
1802 msg.buf = (char *)buf;
1804 ret = i2c_transfer(adap, &msg, 1);
1807 * If everything went ok (i.e. 1 msg transmitted), return #bytes
1808 * transmitted, else error code.
1810 return (ret == 1) ? count : ret;
1812 EXPORT_SYMBOL(i2c_master_send);
1815 * i2c_master_recv - issue a single I2C message in master receive mode
1816 * @client: Handle to slave device
1817 * @buf: Where to store data read from slave
1818 * @count: How many bytes to read, must be less than 64k since msg.len is u16
1820 * Returns negative errno, or else the number of bytes read.
1822 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1824 struct i2c_adapter *adap = client->adapter;
1828 msg.addr = client->addr;
1829 msg.flags = client->flags & I2C_M_TEN;
1830 msg.flags |= I2C_M_RD;
1834 ret = i2c_transfer(adap, &msg, 1);
1837 * If everything went ok (i.e. 1 msg received), return #bytes received,
1840 return (ret == 1) ? count : ret;
1842 EXPORT_SYMBOL(i2c_master_recv);
1844 /* ----------------------------------------------------
1845 * the i2c address scanning function
1846 * Will not work for 10-bit addresses!
1847 * ----------------------------------------------------
1851 * Legacy default probe function, mostly relevant for SMBus. The default
1852 * probe method is a quick write, but it is known to corrupt the 24RF08
1853 * EEPROMs due to a state machine bug, and could also irreversibly
1854 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1855 * we use a short byte read instead. Also, some bus drivers don't implement
1856 * quick write, so we fallback to a byte read in that case too.
1857 * On x86, there is another special case for FSC hardware monitoring chips,
1858 * which want regular byte reads (address 0x73.) Fortunately, these are the
1859 * only known chips using this I2C address on PC hardware.
1860 * Returns 1 if probe succeeded, 0 if not.
1862 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1865 union i2c_smbus_data dummy;
1868 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1869 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1870 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1871 I2C_SMBUS_BYTE_DATA, &dummy);
1874 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1875 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1876 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1877 I2C_SMBUS_QUICK, NULL);
1878 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1879 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1880 I2C_SMBUS_BYTE, &dummy);
1882 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
1890 static int i2c_detect_address(struct i2c_client *temp_client,
1891 struct i2c_driver *driver)
1893 struct i2c_board_info info;
1894 struct i2c_adapter *adapter = temp_client->adapter;
1895 int addr = temp_client->addr;
1898 /* Make sure the address is valid */
1899 err = i2c_check_addr_validity(addr);
1901 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1906 /* Skip if already in use */
1907 if (i2c_check_addr_busy(adapter, addr))
1910 /* Make sure there is something at this address */
1911 if (!i2c_default_probe(adapter, addr))
1914 /* Finally call the custom detection function */
1915 memset(&info, 0, sizeof(struct i2c_board_info));
1917 err = driver->detect(temp_client, &info);
1919 /* -ENODEV is returned if the detection fails. We catch it
1920 here as this isn't an error. */
1921 return err == -ENODEV ? 0 : err;
1924 /* Consistency check */
1925 if (info.type[0] == '\0') {
1926 dev_err(&adapter->dev, "%s detection function provided "
1927 "no name for 0x%x\n", driver->driver.name,
1930 struct i2c_client *client;
1932 /* Detection succeeded, instantiate the device */
1933 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1934 info.type, info.addr);
1935 client = i2c_new_device(adapter, &info);
1937 list_add_tail(&client->detected, &driver->clients);
1939 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1940 info.type, info.addr);
1945 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1947 const unsigned short *address_list;
1948 struct i2c_client *temp_client;
1950 int adap_id = i2c_adapter_id(adapter);
1952 address_list = driver->address_list;
1953 if (!driver->detect || !address_list)
1956 /* Stop here if the classes do not match */
1957 if (!(adapter->class & driver->class))
1960 /* Set up a temporary client to help detect callback */
1961 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1964 temp_client->adapter = adapter;
1966 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1967 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1968 "addr 0x%02x\n", adap_id, address_list[i]);
1969 temp_client->addr = address_list[i];
1970 err = i2c_detect_address(temp_client, driver);
1979 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1981 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1982 I2C_SMBUS_QUICK, NULL) >= 0;
1984 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1987 i2c_new_probed_device(struct i2c_adapter *adap,
1988 struct i2c_board_info *info,
1989 unsigned short const *addr_list,
1990 int (*probe)(struct i2c_adapter *, unsigned short addr))
1995 probe = i2c_default_probe;
1997 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1998 /* Check address validity */
1999 if (i2c_check_addr_validity(addr_list[i]) < 0) {
2000 dev_warn(&adap->dev, "Invalid 7-bit address "
2001 "0x%02x\n", addr_list[i]);
2005 /* Check address availability */
2006 if (i2c_check_addr_busy(adap, addr_list[i])) {
2007 dev_dbg(&adap->dev, "Address 0x%02x already in "
2008 "use, not probing\n", addr_list[i]);
2012 /* Test address responsiveness */
2013 if (probe(adap, addr_list[i]))
2017 if (addr_list[i] == I2C_CLIENT_END) {
2018 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2022 info->addr = addr_list[i];
2023 return i2c_new_device(adap, info);
2025 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2027 struct i2c_adapter *i2c_get_adapter(int nr)
2029 struct i2c_adapter *adapter;
2031 mutex_lock(&core_lock);
2032 adapter = idr_find(&i2c_adapter_idr, nr);
2033 if (adapter && !try_module_get(adapter->owner))
2036 mutex_unlock(&core_lock);
2039 EXPORT_SYMBOL(i2c_get_adapter);
2041 void i2c_put_adapter(struct i2c_adapter *adap)
2044 module_put(adap->owner);
2046 EXPORT_SYMBOL(i2c_put_adapter);
2048 /* The SMBus parts */
2050 #define POLY (0x1070U << 3)
2051 static u8 crc8(u16 data)
2055 for (i = 0; i < 8; i++) {
2060 return (u8)(data >> 8);
2063 /* Incremental CRC8 over count bytes in the array pointed to by p */
2064 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2068 for (i = 0; i < count; i++)
2069 crc = crc8((crc ^ p[i]) << 8);
2073 /* Assume a 7-bit address, which is reasonable for SMBus */
2074 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2076 /* The address will be sent first */
2077 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2078 pec = i2c_smbus_pec(pec, &addr, 1);
2080 /* The data buffer follows */
2081 return i2c_smbus_pec(pec, msg->buf, msg->len);
2084 /* Used for write only transactions */
2085 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2087 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2091 /* Return <0 on CRC error
2092 If there was a write before this read (most cases) we need to take the
2093 partial CRC from the write part into account.
2094 Note that this function does modify the message (we need to decrease the
2095 message length to hide the CRC byte from the caller). */
2096 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2098 u8 rpec = msg->buf[--msg->len];
2099 cpec = i2c_smbus_msg_pec(cpec, msg);
2102 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2110 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2111 * @client: Handle to slave device
2113 * This executes the SMBus "receive byte" protocol, returning negative errno
2114 * else the byte received from the device.
2116 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2118 union i2c_smbus_data data;
2121 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2123 I2C_SMBUS_BYTE, &data);
2124 return (status < 0) ? status : data.byte;
2126 EXPORT_SYMBOL(i2c_smbus_read_byte);
2129 * i2c_smbus_write_byte - SMBus "send byte" protocol
2130 * @client: Handle to slave device
2131 * @value: Byte to be sent
2133 * This executes the SMBus "send byte" protocol, returning negative errno
2134 * else zero on success.
2136 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2138 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2139 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2141 EXPORT_SYMBOL(i2c_smbus_write_byte);
2144 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2145 * @client: Handle to slave device
2146 * @command: Byte interpreted by slave
2148 * This executes the SMBus "read byte" protocol, returning negative errno
2149 * else a data byte received from the device.
2151 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2153 union i2c_smbus_data data;
2156 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2157 I2C_SMBUS_READ, command,
2158 I2C_SMBUS_BYTE_DATA, &data);
2159 return (status < 0) ? status : data.byte;
2161 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2164 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2165 * @client: Handle to slave device
2166 * @command: Byte interpreted by slave
2167 * @value: Byte being written
2169 * This executes the SMBus "write byte" protocol, returning negative errno
2170 * else zero on success.
2172 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2175 union i2c_smbus_data data;
2177 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2178 I2C_SMBUS_WRITE, command,
2179 I2C_SMBUS_BYTE_DATA, &data);
2181 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2184 * i2c_smbus_read_word_data - SMBus "read word" protocol
2185 * @client: Handle to slave device
2186 * @command: Byte interpreted by slave
2188 * This executes the SMBus "read word" protocol, returning negative errno
2189 * else a 16-bit unsigned "word" received from the device.
2191 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2193 union i2c_smbus_data data;
2196 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2197 I2C_SMBUS_READ, command,
2198 I2C_SMBUS_WORD_DATA, &data);
2199 return (status < 0) ? status : data.word;
2201 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2204 * i2c_smbus_write_word_data - SMBus "write word" protocol
2205 * @client: Handle to slave device
2206 * @command: Byte interpreted by slave
2207 * @value: 16-bit "word" being written
2209 * This executes the SMBus "write word" protocol, returning negative errno
2210 * else zero on success.
2212 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2215 union i2c_smbus_data data;
2217 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2218 I2C_SMBUS_WRITE, command,
2219 I2C_SMBUS_WORD_DATA, &data);
2221 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2224 * i2c_smbus_read_block_data - SMBus "block read" protocol
2225 * @client: Handle to slave device
2226 * @command: Byte interpreted by slave
2227 * @values: Byte array into which data will be read; big enough to hold
2228 * the data returned by the slave. SMBus allows at most 32 bytes.
2230 * This executes the SMBus "block read" protocol, returning negative errno
2231 * else the number of data bytes in the slave's response.
2233 * Note that using this function requires that the client's adapter support
2234 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2235 * support this; its emulation through I2C messaging relies on a specific
2236 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2238 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2241 union i2c_smbus_data data;
2244 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2245 I2C_SMBUS_READ, command,
2246 I2C_SMBUS_BLOCK_DATA, &data);
2250 memcpy(values, &data.block[1], data.block[0]);
2251 return data.block[0];
2253 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2256 * i2c_smbus_write_block_data - SMBus "block write" protocol
2257 * @client: Handle to slave device
2258 * @command: Byte interpreted by slave
2259 * @length: Size of data block; SMBus allows at most 32 bytes
2260 * @values: Byte array which will be written.
2262 * This executes the SMBus "block write" protocol, returning negative errno
2263 * else zero on success.
2265 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2266 u8 length, const u8 *values)
2268 union i2c_smbus_data data;
2270 if (length > I2C_SMBUS_BLOCK_MAX)
2271 length = I2C_SMBUS_BLOCK_MAX;
2272 data.block[0] = length;
2273 memcpy(&data.block[1], values, length);
2274 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2275 I2C_SMBUS_WRITE, command,
2276 I2C_SMBUS_BLOCK_DATA, &data);
2278 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2280 /* Returns the number of read bytes */
2281 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2282 u8 length, u8 *values)
2284 union i2c_smbus_data data;
2287 if (length > I2C_SMBUS_BLOCK_MAX)
2288 length = I2C_SMBUS_BLOCK_MAX;
2289 data.block[0] = length;
2290 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2291 I2C_SMBUS_READ, command,
2292 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2296 memcpy(values, &data.block[1], data.block[0]);
2297 return data.block[0];
2299 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2301 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2302 u8 length, const u8 *values)
2304 union i2c_smbus_data data;
2306 if (length > I2C_SMBUS_BLOCK_MAX)
2307 length = I2C_SMBUS_BLOCK_MAX;
2308 data.block[0] = length;
2309 memcpy(data.block + 1, values, length);
2310 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2311 I2C_SMBUS_WRITE, command,
2312 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2314 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2316 /* Simulate a SMBus command using the i2c protocol
2317 No checking of parameters is done! */
2318 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2319 unsigned short flags,
2320 char read_write, u8 command, int size,
2321 union i2c_smbus_data *data)
2323 /* So we need to generate a series of msgs. In the case of writing, we
2324 need to use only one message; when reading, we need two. We initialize
2325 most things with sane defaults, to keep the code below somewhat
2327 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2328 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2329 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2333 struct i2c_msg msg[2] = {
2341 .flags = flags | I2C_M_RD,
2347 msgbuf0[0] = command;
2349 case I2C_SMBUS_QUICK:
2351 /* Special case: The read/write field is used as data */
2352 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2356 case I2C_SMBUS_BYTE:
2357 if (read_write == I2C_SMBUS_READ) {
2358 /* Special case: only a read! */
2359 msg[0].flags = I2C_M_RD | flags;
2363 case I2C_SMBUS_BYTE_DATA:
2364 if (read_write == I2C_SMBUS_READ)
2368 msgbuf0[1] = data->byte;
2371 case I2C_SMBUS_WORD_DATA:
2372 if (read_write == I2C_SMBUS_READ)
2376 msgbuf0[1] = data->word & 0xff;
2377 msgbuf0[2] = data->word >> 8;
2380 case I2C_SMBUS_PROC_CALL:
2381 num = 2; /* Special case */
2382 read_write = I2C_SMBUS_READ;
2385 msgbuf0[1] = data->word & 0xff;
2386 msgbuf0[2] = data->word >> 8;
2388 case I2C_SMBUS_BLOCK_DATA:
2389 if (read_write == I2C_SMBUS_READ) {
2390 msg[1].flags |= I2C_M_RECV_LEN;
2391 msg[1].len = 1; /* block length will be added by
2392 the underlying bus driver */
2394 msg[0].len = data->block[0] + 2;
2395 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2396 dev_err(&adapter->dev,
2397 "Invalid block write size %d\n",
2401 for (i = 1; i < msg[0].len; i++)
2402 msgbuf0[i] = data->block[i-1];
2405 case I2C_SMBUS_BLOCK_PROC_CALL:
2406 num = 2; /* Another special case */
2407 read_write = I2C_SMBUS_READ;
2408 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2409 dev_err(&adapter->dev,
2410 "Invalid block write size %d\n",
2414 msg[0].len = data->block[0] + 2;
2415 for (i = 1; i < msg[0].len; i++)
2416 msgbuf0[i] = data->block[i-1];
2417 msg[1].flags |= I2C_M_RECV_LEN;
2418 msg[1].len = 1; /* block length will be added by
2419 the underlying bus driver */
2421 case I2C_SMBUS_I2C_BLOCK_DATA:
2422 if (read_write == I2C_SMBUS_READ) {
2423 msg[1].len = data->block[0];
2425 msg[0].len = data->block[0] + 1;
2426 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2427 dev_err(&adapter->dev,
2428 "Invalid block write size %d\n",
2432 for (i = 1; i <= data->block[0]; i++)
2433 msgbuf0[i] = data->block[i];
2437 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2441 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2442 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2444 /* Compute PEC if first message is a write */
2445 if (!(msg[0].flags & I2C_M_RD)) {
2446 if (num == 1) /* Write only */
2447 i2c_smbus_add_pec(&msg[0]);
2448 else /* Write followed by read */
2449 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2451 /* Ask for PEC if last message is a read */
2452 if (msg[num-1].flags & I2C_M_RD)
2456 status = i2c_transfer(adapter, msg, num);
2460 /* Check PEC if last message is a read */
2461 if (i && (msg[num-1].flags & I2C_M_RD)) {
2462 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2467 if (read_write == I2C_SMBUS_READ)
2469 case I2C_SMBUS_BYTE:
2470 data->byte = msgbuf0[0];
2472 case I2C_SMBUS_BYTE_DATA:
2473 data->byte = msgbuf1[0];
2475 case I2C_SMBUS_WORD_DATA:
2476 case I2C_SMBUS_PROC_CALL:
2477 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2479 case I2C_SMBUS_I2C_BLOCK_DATA:
2480 for (i = 0; i < data->block[0]; i++)
2481 data->block[i+1] = msgbuf1[i];
2483 case I2C_SMBUS_BLOCK_DATA:
2484 case I2C_SMBUS_BLOCK_PROC_CALL:
2485 for (i = 0; i < msgbuf1[0] + 1; i++)
2486 data->block[i] = msgbuf1[i];
2493 * i2c_smbus_xfer - execute SMBus protocol operations
2494 * @adapter: Handle to I2C bus
2495 * @addr: Address of SMBus slave on that bus
2496 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2497 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2498 * @command: Byte interpreted by slave, for protocols which use such bytes
2499 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2500 * @data: Data to be read or written
2502 * This executes an SMBus protocol operation, and returns a negative
2503 * errno code else zero on success.
2505 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2506 char read_write, u8 command, int protocol,
2507 union i2c_smbus_data *data)
2509 unsigned long orig_jiffies;
2513 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
2515 if (adapter->algo->smbus_xfer) {
2516 i2c_lock_adapter(adapter);
2518 /* Retry automatically on arbitration loss */
2519 orig_jiffies = jiffies;
2520 for (res = 0, try = 0; try <= adapter->retries; try++) {
2521 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2522 read_write, command,
2526 if (time_after(jiffies,
2527 orig_jiffies + adapter->timeout))
2530 i2c_unlock_adapter(adapter);
2532 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
2535 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2536 * implement native support for the SMBus operation.
2540 return i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2541 command, protocol, data);
2543 EXPORT_SYMBOL(i2c_smbus_xfer);
2545 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2546 MODULE_DESCRIPTION("I2C-Bus main module");
2547 MODULE_LICENSE("GPL");