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. */
14 /* ------------------------------------------------------------------------- */
16 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
17 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
18 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
19 Jean Delvare <jdelvare@suse.de>
20 Mux support by Rodolfo Giometti <giometti@enneenne.com> and
21 Michael Lawnick <michael.lawnick.ext@nsn.com>
22 OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
23 (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
24 (c) 2013 Wolfram Sang <wsa@the-dreams.de>
25 I2C ACPI code Copyright (C) 2014 Intel Corp
26 Author: Lan Tianyu <tianyu.lan@intel.com>
27 I2C slave support (c) 2014 by Wolfram Sang <wsa@sang-engineering.com>
30 #include <dt-bindings/i2c/i2c.h>
31 #include <asm/uaccess.h>
32 #include <linux/acpi.h>
33 #include <linux/clk/clk-conf.h>
34 #include <linux/completion.h>
35 #include <linux/delay.h>
36 #include <linux/err.h>
37 #include <linux/errno.h>
38 #include <linux/gpio.h>
39 #include <linux/hardirq.h>
40 #include <linux/i2c.h>
41 #include <linux/idr.h>
42 #include <linux/init.h>
43 #include <linux/irqflags.h>
44 #include <linux/jump_label.h>
45 #include <linux/kernel.h>
46 #include <linux/module.h>
47 #include <linux/mutex.h>
48 #include <linux/of_device.h>
50 #include <linux/of_irq.h>
51 #include <linux/pm_domain.h>
52 #include <linux/pm_runtime.h>
53 #include <linux/pm_wakeirq.h>
54 #include <linux/property.h>
55 #include <linux/rwsem.h>
56 #include <linux/slab.h>
60 #define CREATE_TRACE_POINTS
61 #include <trace/events/i2c.h>
63 #define I2C_ADDR_OFFSET_TEN_BIT 0xa000
64 #define I2C_ADDR_OFFSET_SLAVE 0x1000
66 /* core_lock protects i2c_adapter_idr, and guarantees
67 that device detection, deletion of detected devices, and attach_adapter
68 calls are serialized */
69 static DEFINE_MUTEX(core_lock);
70 static DEFINE_IDR(i2c_adapter_idr);
72 static struct device_type i2c_client_type;
73 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
75 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
76 static bool is_registered;
78 void i2c_transfer_trace_reg(void)
80 static_key_slow_inc(&i2c_trace_msg);
83 void i2c_transfer_trace_unreg(void)
85 static_key_slow_dec(&i2c_trace_msg);
88 #if defined(CONFIG_ACPI)
89 struct acpi_i2c_handler_data {
90 struct acpi_connection_info info;
91 struct i2c_adapter *adapter;
104 struct acpi_i2c_lookup {
105 struct i2c_board_info *info;
106 acpi_handle adapter_handle;
107 acpi_handle device_handle;
110 static int acpi_i2c_find_address(struct acpi_resource *ares, void *data)
112 struct acpi_i2c_lookup *lookup = data;
113 struct i2c_board_info *info = lookup->info;
114 struct acpi_resource_i2c_serialbus *sb;
115 acpi_handle adapter_handle;
118 if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
121 sb = &ares->data.i2c_serial_bus;
122 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
126 * Extract the ResourceSource and make sure that the handle matches
127 * with the I2C adapter handle.
129 status = acpi_get_handle(lookup->device_handle,
130 sb->resource_source.string_ptr,
132 if (ACPI_SUCCESS(status) && adapter_handle == lookup->adapter_handle) {
133 info->addr = sb->slave_address;
134 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
135 info->flags |= I2C_CLIENT_TEN;
141 static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
142 void *data, void **return_value)
144 struct i2c_adapter *adapter = data;
145 struct list_head resource_list;
146 struct acpi_i2c_lookup lookup;
147 struct resource_entry *entry;
148 struct i2c_board_info info;
149 struct acpi_device *adev;
152 if (acpi_bus_get_device(handle, &adev))
154 if (acpi_bus_get_status(adev) || !adev->status.present)
157 memset(&info, 0, sizeof(info));
158 info.fwnode = acpi_fwnode_handle(adev);
160 memset(&lookup, 0, sizeof(lookup));
161 lookup.adapter_handle = ACPI_HANDLE(&adapter->dev);
162 lookup.device_handle = handle;
166 * Look up for I2cSerialBus resource with ResourceSource that
167 * matches with this adapter.
169 INIT_LIST_HEAD(&resource_list);
170 ret = acpi_dev_get_resources(adev, &resource_list,
171 acpi_i2c_find_address, &lookup);
172 acpi_dev_free_resource_list(&resource_list);
174 if (ret < 0 || !info.addr)
177 /* Then fill IRQ number if any */
178 ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
182 resource_list_for_each_entry(entry, &resource_list) {
183 if (resource_type(entry->res) == IORESOURCE_IRQ) {
184 info.irq = entry->res->start;
189 acpi_dev_free_resource_list(&resource_list);
191 adev->power.flags.ignore_parent = true;
192 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
193 if (!i2c_new_device(adapter, &info)) {
194 adev->power.flags.ignore_parent = false;
195 dev_err(&adapter->dev,
196 "failed to add I2C device %s from ACPI\n",
197 dev_name(&adev->dev));
203 #define ACPI_I2C_MAX_SCAN_DEPTH 32
206 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
207 * @adap: pointer to adapter
209 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
210 * namespace. When a device is found it will be added to the Linux device
211 * model and bound to the corresponding ACPI handle.
213 static void acpi_i2c_register_devices(struct i2c_adapter *adap)
217 if (!has_acpi_companion(&adap->dev))
220 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
221 ACPI_I2C_MAX_SCAN_DEPTH,
222 acpi_i2c_add_device, NULL,
224 if (ACPI_FAILURE(status))
225 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
228 #else /* CONFIG_ACPI */
229 static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) { }
230 #endif /* CONFIG_ACPI */
232 #ifdef CONFIG_ACPI_I2C_OPREGION
233 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
234 u8 cmd, u8 *data, u8 data_len)
237 struct i2c_msg msgs[2];
241 buffer = kzalloc(data_len, GFP_KERNEL);
245 msgs[0].addr = client->addr;
246 msgs[0].flags = client->flags;
250 msgs[1].addr = client->addr;
251 msgs[1].flags = client->flags | I2C_M_RD;
252 msgs[1].len = data_len;
253 msgs[1].buf = buffer;
255 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
257 dev_err(&client->adapter->dev, "i2c read failed\n");
259 memcpy(data, buffer, data_len);
265 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
266 u8 cmd, u8 *data, u8 data_len)
269 struct i2c_msg msgs[1];
273 buffer = kzalloc(data_len + 1, GFP_KERNEL);
278 memcpy(buffer + 1, data, data_len);
280 msgs[0].addr = client->addr;
281 msgs[0].flags = client->flags;
282 msgs[0].len = data_len + 1;
283 msgs[0].buf = buffer;
285 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
287 dev_err(&client->adapter->dev, "i2c write failed\n");
294 acpi_i2c_space_handler(u32 function, acpi_physical_address command,
295 u32 bits, u64 *value64,
296 void *handler_context, void *region_context)
298 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
299 struct acpi_i2c_handler_data *data = handler_context;
300 struct acpi_connection_info *info = &data->info;
301 struct acpi_resource_i2c_serialbus *sb;
302 struct i2c_adapter *adapter = data->adapter;
303 struct i2c_client *client;
304 struct acpi_resource *ares;
305 u32 accessor_type = function >> 16;
306 u8 action = function & ACPI_IO_MASK;
310 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
311 if (ACPI_FAILURE(ret))
314 client = kzalloc(sizeof(*client), GFP_KERNEL);
320 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
321 ret = AE_BAD_PARAMETER;
325 sb = &ares->data.i2c_serial_bus;
326 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
327 ret = AE_BAD_PARAMETER;
331 client->adapter = adapter;
332 client->addr = sb->slave_address;
334 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
335 client->flags |= I2C_CLIENT_TEN;
337 switch (accessor_type) {
338 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
339 if (action == ACPI_READ) {
340 status = i2c_smbus_read_byte(client);
346 status = i2c_smbus_write_byte(client, gsb->bdata);
350 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
351 if (action == ACPI_READ) {
352 status = i2c_smbus_read_byte_data(client, command);
358 status = i2c_smbus_write_byte_data(client, command,
363 case ACPI_GSB_ACCESS_ATTRIB_WORD:
364 if (action == ACPI_READ) {
365 status = i2c_smbus_read_word_data(client, command);
371 status = i2c_smbus_write_word_data(client, command,
376 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
377 if (action == ACPI_READ) {
378 status = i2c_smbus_read_block_data(client, command,
385 status = i2c_smbus_write_block_data(client, command,
386 gsb->len, gsb->data);
390 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
391 if (action == ACPI_READ) {
392 status = acpi_gsb_i2c_read_bytes(client, command,
393 gsb->data, info->access_length);
397 status = acpi_gsb_i2c_write_bytes(client, command,
398 gsb->data, info->access_length);
403 pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
404 ret = AE_BAD_PARAMETER;
408 gsb->status = status;
417 static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
420 struct acpi_i2c_handler_data *data;
423 if (!adapter->dev.parent)
426 handle = ACPI_HANDLE(adapter->dev.parent);
431 data = kzalloc(sizeof(struct acpi_i2c_handler_data),
436 data->adapter = adapter;
437 status = acpi_bus_attach_private_data(handle, (void *)data);
438 if (ACPI_FAILURE(status)) {
443 status = acpi_install_address_space_handler(handle,
444 ACPI_ADR_SPACE_GSBUS,
445 &acpi_i2c_space_handler,
448 if (ACPI_FAILURE(status)) {
449 dev_err(&adapter->dev, "Error installing i2c space handler\n");
450 acpi_bus_detach_private_data(handle);
455 acpi_walk_dep_device_list(handle);
459 static void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
462 struct acpi_i2c_handler_data *data;
465 if (!adapter->dev.parent)
468 handle = ACPI_HANDLE(adapter->dev.parent);
473 acpi_remove_address_space_handler(handle,
474 ACPI_ADR_SPACE_GSBUS,
475 &acpi_i2c_space_handler);
477 status = acpi_bus_get_private_data(handle, (void **)&data);
478 if (ACPI_SUCCESS(status))
481 acpi_bus_detach_private_data(handle);
483 #else /* CONFIG_ACPI_I2C_OPREGION */
484 static inline void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
487 static inline int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
489 #endif /* CONFIG_ACPI_I2C_OPREGION */
491 /* ------------------------------------------------------------------------- */
493 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
494 const struct i2c_client *client)
496 while (id->name[0]) {
497 if (strcmp(client->name, id->name) == 0)
504 static int i2c_device_match(struct device *dev, struct device_driver *drv)
506 struct i2c_client *client = i2c_verify_client(dev);
507 struct i2c_driver *driver;
512 /* Attempt an OF style match */
513 if (of_driver_match_device(dev, drv))
516 /* Then ACPI style match */
517 if (acpi_driver_match_device(dev, drv))
520 driver = to_i2c_driver(drv);
521 /* match on an id table if there is one */
522 if (driver->id_table)
523 return i2c_match_id(driver->id_table, client) != NULL;
528 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
530 struct i2c_client *client = to_i2c_client(dev);
533 rc = acpi_device_uevent_modalias(dev, env);
537 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
540 /* i2c bus recovery routines */
541 static int get_scl_gpio_value(struct i2c_adapter *adap)
543 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
546 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
548 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
551 static int get_sda_gpio_value(struct i2c_adapter *adap)
553 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
556 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
558 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
559 struct device *dev = &adap->dev;
562 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
563 GPIOF_OUT_INIT_HIGH, "i2c-scl");
565 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
570 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
571 /* work without SDA polling */
572 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
581 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
583 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
586 gpio_free(bri->sda_gpio);
588 gpio_free(bri->scl_gpio);
592 * We are generating clock pulses. ndelay() determines durating of clk pulses.
593 * We will generate clock with rate 100 KHz and so duration of both clock levels
594 * is: delay in ns = (10^6 / 100) / 2
596 #define RECOVERY_NDELAY 5000
597 #define RECOVERY_CLK_CNT 9
599 static int i2c_generic_recovery(struct i2c_adapter *adap)
601 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
602 int i = 0, val = 1, ret = 0;
604 if (bri->prepare_recovery)
605 bri->prepare_recovery(adap);
607 bri->set_scl(adap, val);
608 ndelay(RECOVERY_NDELAY);
611 * By this time SCL is high, as we need to give 9 falling-rising edges
613 while (i++ < RECOVERY_CLK_CNT * 2) {
615 /* Break if SDA is high */
616 if (bri->get_sda && bri->get_sda(adap))
618 /* SCL shouldn't be low here */
619 if (!bri->get_scl(adap)) {
621 "SCL is stuck low, exit recovery\n");
628 bri->set_scl(adap, val);
629 ndelay(RECOVERY_NDELAY);
632 if (bri->unprepare_recovery)
633 bri->unprepare_recovery(adap);
638 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
640 return i2c_generic_recovery(adap);
642 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
644 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
648 ret = i2c_get_gpios_for_recovery(adap);
652 ret = i2c_generic_recovery(adap);
653 i2c_put_gpios_for_recovery(adap);
657 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
659 int i2c_recover_bus(struct i2c_adapter *adap)
661 if (!adap->bus_recovery_info)
664 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
665 return adap->bus_recovery_info->recover_bus(adap);
667 EXPORT_SYMBOL_GPL(i2c_recover_bus);
669 static int i2c_device_probe(struct device *dev)
671 struct i2c_client *client = i2c_verify_client(dev);
672 struct i2c_driver *driver;
682 irq = of_irq_get_byname(dev->of_node, "irq");
683 if (irq == -EINVAL || irq == -ENODATA)
684 irq = of_irq_get(dev->of_node, 0);
685 } else if (ACPI_COMPANION(dev)) {
686 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
688 if (irq == -EPROBE_DEFER)
696 driver = to_i2c_driver(dev->driver);
697 if (!driver->probe || !driver->id_table)
700 if (client->flags & I2C_CLIENT_WAKE) {
701 int wakeirq = -ENOENT;
704 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
705 if (wakeirq == -EPROBE_DEFER)
709 device_init_wakeup(&client->dev, true);
711 if (wakeirq > 0 && wakeirq != client->irq)
712 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
713 else if (client->irq > 0)
714 status = dev_pm_set_wake_irq(dev, client->irq);
719 dev_warn(&client->dev, "failed to set up wakeup irq");
722 dev_dbg(dev, "probe\n");
724 status = of_clk_set_defaults(dev->of_node, false);
726 goto err_clear_wakeup_irq;
728 status = dev_pm_domain_attach(&client->dev, true);
729 if (status == -EPROBE_DEFER)
730 goto err_clear_wakeup_irq;
732 status = driver->probe(client, i2c_match_id(driver->id_table, client));
734 goto err_detach_pm_domain;
738 err_detach_pm_domain:
739 dev_pm_domain_detach(&client->dev, true);
740 err_clear_wakeup_irq:
741 dev_pm_clear_wake_irq(&client->dev);
742 device_init_wakeup(&client->dev, false);
746 static int i2c_device_remove(struct device *dev)
748 struct i2c_client *client = i2c_verify_client(dev);
749 struct i2c_driver *driver;
752 if (!client || !dev->driver)
755 driver = to_i2c_driver(dev->driver);
756 if (driver->remove) {
757 dev_dbg(dev, "remove\n");
758 status = driver->remove(client);
761 dev_pm_domain_detach(&client->dev, true);
763 dev_pm_clear_wake_irq(&client->dev);
764 device_init_wakeup(&client->dev, false);
769 static void i2c_device_shutdown(struct device *dev)
771 struct i2c_client *client = i2c_verify_client(dev);
772 struct i2c_driver *driver;
774 if (!client || !dev->driver)
776 driver = to_i2c_driver(dev->driver);
777 if (driver->shutdown)
778 driver->shutdown(client);
781 static void i2c_client_dev_release(struct device *dev)
783 kfree(to_i2c_client(dev));
787 show_name(struct device *dev, struct device_attribute *attr, char *buf)
789 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
790 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
792 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
795 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
797 struct i2c_client *client = to_i2c_client(dev);
800 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
804 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
806 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
808 static struct attribute *i2c_dev_attrs[] = {
810 /* modalias helps coldplug: modprobe $(cat .../modalias) */
811 &dev_attr_modalias.attr,
814 ATTRIBUTE_GROUPS(i2c_dev);
816 struct bus_type i2c_bus_type = {
818 .match = i2c_device_match,
819 .probe = i2c_device_probe,
820 .remove = i2c_device_remove,
821 .shutdown = i2c_device_shutdown,
823 EXPORT_SYMBOL_GPL(i2c_bus_type);
825 static struct device_type i2c_client_type = {
826 .groups = i2c_dev_groups,
827 .uevent = i2c_device_uevent,
828 .release = i2c_client_dev_release,
833 * i2c_verify_client - return parameter as i2c_client, or NULL
834 * @dev: device, probably from some driver model iterator
836 * When traversing the driver model tree, perhaps using driver model
837 * iterators like @device_for_each_child(), you can't assume very much
838 * about the nodes you find. Use this function to avoid oopses caused
839 * by wrongly treating some non-I2C device as an i2c_client.
841 struct i2c_client *i2c_verify_client(struct device *dev)
843 return (dev->type == &i2c_client_type)
847 EXPORT_SYMBOL(i2c_verify_client);
850 /* Return a unique address which takes the flags of the client into account */
851 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
853 unsigned short addr = client->addr;
855 /* For some client flags, add an arbitrary offset to avoid collisions */
856 if (client->flags & I2C_CLIENT_TEN)
857 addr |= I2C_ADDR_OFFSET_TEN_BIT;
859 if (client->flags & I2C_CLIENT_SLAVE)
860 addr |= I2C_ADDR_OFFSET_SLAVE;
865 /* This is a permissive address validity check, I2C address map constraints
866 * are purposely not enforced, except for the general call address. */
867 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
869 if (flags & I2C_CLIENT_TEN) {
870 /* 10-bit address, all values are valid */
874 /* 7-bit address, reject the general call address */
875 if (addr == 0x00 || addr > 0x7f)
881 /* And this is a strict address validity check, used when probing. If a
882 * device uses a reserved address, then it shouldn't be probed. 7-bit
883 * addressing is assumed, 10-bit address devices are rare and should be
884 * explicitly enumerated. */
885 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
888 * Reserved addresses per I2C specification:
889 * 0x00 General call address / START byte
891 * 0x02 Reserved for different bus format
892 * 0x03 Reserved for future purposes
893 * 0x04-0x07 Hs-mode master code
894 * 0x78-0x7b 10-bit slave addressing
895 * 0x7c-0x7f Reserved for future purposes
897 if (addr < 0x08 || addr > 0x77)
902 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
904 struct i2c_client *client = i2c_verify_client(dev);
905 int addr = *(int *)addrp;
907 if (client && i2c_encode_flags_to_addr(client) == addr)
912 /* walk up mux tree */
913 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
915 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
918 result = device_for_each_child(&adapter->dev, &addr,
919 __i2c_check_addr_busy);
921 if (!result && parent)
922 result = i2c_check_mux_parents(parent, addr);
927 /* recurse down mux tree */
928 static int i2c_check_mux_children(struct device *dev, void *addrp)
932 if (dev->type == &i2c_adapter_type)
933 result = device_for_each_child(dev, addrp,
934 i2c_check_mux_children);
936 result = __i2c_check_addr_busy(dev, addrp);
941 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
943 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
947 result = i2c_check_mux_parents(parent, addr);
950 result = device_for_each_child(&adapter->dev, &addr,
951 i2c_check_mux_children);
957 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
958 * @adapter: Target I2C bus segment
959 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
960 * locks only this branch in the adapter tree
962 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
965 rt_mutex_lock(&adapter->bus_lock);
969 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
970 * @adapter: Target I2C bus segment
971 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
972 * trylocks only this branch in the adapter tree
974 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
977 return rt_mutex_trylock(&adapter->bus_lock);
981 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
982 * @adapter: Target I2C bus segment
983 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
984 * unlocks only this branch in the adapter tree
986 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
989 rt_mutex_unlock(&adapter->bus_lock);
992 static void i2c_dev_set_name(struct i2c_adapter *adap,
993 struct i2c_client *client)
995 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
998 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1002 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1003 i2c_encode_flags_to_addr(client));
1007 * i2c_new_device - instantiate an i2c device
1008 * @adap: the adapter managing the device
1009 * @info: describes one I2C device; bus_num is ignored
1010 * Context: can sleep
1012 * Create an i2c device. Binding is handled through driver model
1013 * probe()/remove() methods. A driver may be bound to this device when we
1014 * return from this function, or any later moment (e.g. maybe hotplugging will
1015 * load the driver module). This call is not appropriate for use by mainboard
1016 * initialization logic, which usually runs during an arch_initcall() long
1017 * before any i2c_adapter could exist.
1019 * This returns the new i2c client, which may be saved for later use with
1020 * i2c_unregister_device(); or NULL to indicate an error.
1023 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1025 struct i2c_client *client;
1028 client = kzalloc(sizeof *client, GFP_KERNEL);
1032 client->adapter = adap;
1034 client->dev.platform_data = info->platform_data;
1037 client->dev.archdata = *info->archdata;
1039 client->flags = info->flags;
1040 client->addr = info->addr;
1041 client->irq = info->irq;
1043 strlcpy(client->name, info->type, sizeof(client->name));
1045 status = i2c_check_addr_validity(client->addr, client->flags);
1047 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1048 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1049 goto out_err_silent;
1052 /* Check for address business */
1053 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1057 client->dev.parent = &client->adapter->dev;
1058 client->dev.bus = &i2c_bus_type;
1059 client->dev.type = &i2c_client_type;
1060 client->dev.of_node = info->of_node;
1061 client->dev.fwnode = info->fwnode;
1063 i2c_dev_set_name(adap, client);
1064 status = device_register(&client->dev);
1068 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1069 client->name, dev_name(&client->dev));
1074 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1075 "(%d)\n", client->name, client->addr, status);
1080 EXPORT_SYMBOL_GPL(i2c_new_device);
1084 * i2c_unregister_device - reverse effect of i2c_new_device()
1085 * @client: value returned from i2c_new_device()
1086 * Context: can sleep
1088 void i2c_unregister_device(struct i2c_client *client)
1090 if (client->dev.of_node)
1091 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1092 device_unregister(&client->dev);
1094 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1097 static const struct i2c_device_id dummy_id[] = {
1102 static int dummy_probe(struct i2c_client *client,
1103 const struct i2c_device_id *id)
1108 static int dummy_remove(struct i2c_client *client)
1113 static struct i2c_driver dummy_driver = {
1114 .driver.name = "dummy",
1115 .probe = dummy_probe,
1116 .remove = dummy_remove,
1117 .id_table = dummy_id,
1121 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1122 * @adapter: the adapter managing the device
1123 * @address: seven bit address to be used
1124 * Context: can sleep
1126 * This returns an I2C client bound to the "dummy" driver, intended for use
1127 * with devices that consume multiple addresses. Examples of such chips
1128 * include various EEPROMS (like 24c04 and 24c08 models).
1130 * These dummy devices have two main uses. First, most I2C and SMBus calls
1131 * except i2c_transfer() need a client handle; the dummy will be that handle.
1132 * And second, this prevents the specified address from being bound to a
1135 * This returns the new i2c client, which should be saved for later use with
1136 * i2c_unregister_device(); or NULL to indicate an error.
1138 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1140 struct i2c_board_info info = {
1141 I2C_BOARD_INFO("dummy", address),
1144 return i2c_new_device(adapter, &info);
1146 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1148 /* ------------------------------------------------------------------------- */
1150 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1152 static void i2c_adapter_dev_release(struct device *dev)
1154 struct i2c_adapter *adap = to_i2c_adapter(dev);
1155 complete(&adap->dev_released);
1159 * This function is only needed for mutex_lock_nested, so it is never
1160 * called unless locking correctness checking is enabled. Thus we
1161 * make it inline to avoid a compiler warning. That's what gcc ends up
1164 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1166 unsigned int depth = 0;
1168 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1175 * Let users instantiate I2C devices through sysfs. This can be used when
1176 * platform initialization code doesn't contain the proper data for
1177 * whatever reason. Also useful for drivers that do device detection and
1178 * detection fails, either because the device uses an unexpected address,
1179 * or this is a compatible device with different ID register values.
1181 * Parameter checking may look overzealous, but we really don't want
1182 * the user to provide incorrect parameters.
1185 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1186 const char *buf, size_t count)
1188 struct i2c_adapter *adap = to_i2c_adapter(dev);
1189 struct i2c_board_info info;
1190 struct i2c_client *client;
1194 memset(&info, 0, sizeof(struct i2c_board_info));
1196 blank = strchr(buf, ' ');
1198 dev_err(dev, "%s: Missing parameters\n", "new_device");
1201 if (blank - buf > I2C_NAME_SIZE - 1) {
1202 dev_err(dev, "%s: Invalid device name\n", "new_device");
1205 memcpy(info.type, buf, blank - buf);
1207 /* Parse remaining parameters, reject extra parameters */
1208 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1210 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1213 if (res > 1 && end != '\n') {
1214 dev_err(dev, "%s: Extra parameters\n", "new_device");
1218 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1219 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1220 info.flags |= I2C_CLIENT_TEN;
1223 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1224 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1225 info.flags |= I2C_CLIENT_SLAVE;
1228 client = i2c_new_device(adap, &info);
1232 /* Keep track of the added device */
1233 mutex_lock(&adap->userspace_clients_lock);
1234 list_add_tail(&client->detected, &adap->userspace_clients);
1235 mutex_unlock(&adap->userspace_clients_lock);
1236 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1237 info.type, info.addr);
1241 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1244 * And of course let the users delete the devices they instantiated, if
1245 * they got it wrong. This interface can only be used to delete devices
1246 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1247 * don't delete devices to which some kernel code still has references.
1249 * Parameter checking may look overzealous, but we really don't want
1250 * the user to delete the wrong device.
1253 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1254 const char *buf, size_t count)
1256 struct i2c_adapter *adap = to_i2c_adapter(dev);
1257 struct i2c_client *client, *next;
1258 unsigned short addr;
1262 /* Parse parameters, reject extra parameters */
1263 res = sscanf(buf, "%hi%c", &addr, &end);
1265 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1268 if (res > 1 && end != '\n') {
1269 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1273 /* Make sure the device was added through sysfs */
1275 mutex_lock_nested(&adap->userspace_clients_lock,
1276 i2c_adapter_depth(adap));
1277 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1279 if (i2c_encode_flags_to_addr(client) == addr) {
1280 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1281 "delete_device", client->name, client->addr);
1283 list_del(&client->detected);
1284 i2c_unregister_device(client);
1289 mutex_unlock(&adap->userspace_clients_lock);
1292 dev_err(dev, "%s: Can't find device in list\n",
1296 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1297 i2c_sysfs_delete_device);
1299 static struct attribute *i2c_adapter_attrs[] = {
1300 &dev_attr_name.attr,
1301 &dev_attr_new_device.attr,
1302 &dev_attr_delete_device.attr,
1305 ATTRIBUTE_GROUPS(i2c_adapter);
1307 struct device_type i2c_adapter_type = {
1308 .groups = i2c_adapter_groups,
1309 .release = i2c_adapter_dev_release,
1311 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1314 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1315 * @dev: device, probably from some driver model iterator
1317 * When traversing the driver model tree, perhaps using driver model
1318 * iterators like @device_for_each_child(), you can't assume very much
1319 * about the nodes you find. Use this function to avoid oopses caused
1320 * by wrongly treating some non-I2C device as an i2c_adapter.
1322 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1324 return (dev->type == &i2c_adapter_type)
1325 ? to_i2c_adapter(dev)
1328 EXPORT_SYMBOL(i2c_verify_adapter);
1330 #ifdef CONFIG_I2C_COMPAT
1331 static struct class_compat *i2c_adapter_compat_class;
1334 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1336 struct i2c_devinfo *devinfo;
1338 down_read(&__i2c_board_lock);
1339 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1340 if (devinfo->busnum == adapter->nr
1341 && !i2c_new_device(adapter,
1342 &devinfo->board_info))
1343 dev_err(&adapter->dev,
1344 "Can't create device at 0x%02x\n",
1345 devinfo->board_info.addr);
1347 up_read(&__i2c_board_lock);
1350 /* OF support code */
1352 #if IS_ENABLED(CONFIG_OF)
1353 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1354 struct device_node *node)
1356 struct i2c_client *result;
1357 struct i2c_board_info info = {};
1358 struct dev_archdata dev_ad = {};
1359 const __be32 *addr_be;
1363 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1365 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1366 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1368 return ERR_PTR(-EINVAL);
1371 addr_be = of_get_property(node, "reg", &len);
1372 if (!addr_be || (len < sizeof(*addr_be))) {
1373 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1375 return ERR_PTR(-EINVAL);
1378 addr = be32_to_cpup(addr_be);
1379 if (addr & I2C_TEN_BIT_ADDRESS) {
1380 addr &= ~I2C_TEN_BIT_ADDRESS;
1381 info.flags |= I2C_CLIENT_TEN;
1384 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1385 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1386 info.flags |= I2C_CLIENT_SLAVE;
1389 if (i2c_check_addr_validity(addr, info.flags)) {
1390 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1391 info.addr, node->full_name);
1392 return ERR_PTR(-EINVAL);
1396 info.of_node = of_node_get(node);
1397 info.archdata = &dev_ad;
1399 if (of_get_property(node, "wakeup-source", NULL))
1400 info.flags |= I2C_CLIENT_WAKE;
1402 result = i2c_new_device(adap, &info);
1403 if (result == NULL) {
1404 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1407 return ERR_PTR(-EINVAL);
1412 static void of_i2c_register_devices(struct i2c_adapter *adap)
1414 struct device_node *bus, *node;
1416 /* Only register child devices if the adapter has a node pointer set */
1417 if (!adap->dev.of_node)
1420 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1422 bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
1424 bus = of_node_get(adap->dev.of_node);
1426 for_each_available_child_of_node(bus, node) {
1427 if (of_node_test_and_set_flag(node, OF_POPULATED))
1429 of_i2c_register_device(adap, node);
1435 static int of_dev_node_match(struct device *dev, void *data)
1437 return dev->of_node == data;
1440 /* must call put_device() when done with returned i2c_client device */
1441 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1444 struct i2c_client *client;
1446 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1450 client = i2c_verify_client(dev);
1456 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1458 /* must call put_device() when done with returned i2c_adapter device */
1459 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1462 struct i2c_adapter *adapter;
1464 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1468 adapter = i2c_verify_adapter(dev);
1474 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1476 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1477 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1479 struct i2c_adapter *adapter;
1481 adapter = of_find_i2c_adapter_by_node(node);
1485 if (!try_module_get(adapter->owner)) {
1486 put_device(&adapter->dev);
1492 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1494 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1495 #endif /* CONFIG_OF */
1497 static int i2c_do_add_adapter(struct i2c_driver *driver,
1498 struct i2c_adapter *adap)
1500 /* Detect supported devices on that bus, and instantiate them */
1501 i2c_detect(adap, driver);
1503 /* Let legacy drivers scan this bus for matching devices */
1504 if (driver->attach_adapter) {
1505 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1506 driver->driver.name);
1507 dev_warn(&adap->dev, "Please use another way to instantiate "
1508 "your i2c_client\n");
1509 /* We ignore the return code; if it fails, too bad */
1510 driver->attach_adapter(adap);
1515 static int __process_new_adapter(struct device_driver *d, void *data)
1517 return i2c_do_add_adapter(to_i2c_driver(d), data);
1520 static int i2c_register_adapter(struct i2c_adapter *adap)
1524 /* Can't register until after driver model init */
1525 if (WARN_ON(!is_registered)) {
1531 if (unlikely(adap->name[0] == '\0')) {
1532 pr_err("i2c-core: Attempt to register an adapter with "
1536 if (unlikely(!adap->algo)) {
1537 pr_err("i2c-core: Attempt to register adapter '%s' with "
1538 "no algo!\n", adap->name);
1542 if (!adap->lock_bus) {
1543 adap->lock_bus = i2c_adapter_lock_bus;
1544 adap->trylock_bus = i2c_adapter_trylock_bus;
1545 adap->unlock_bus = i2c_adapter_unlock_bus;
1548 rt_mutex_init(&adap->bus_lock);
1549 rt_mutex_init(&adap->mux_lock);
1550 mutex_init(&adap->userspace_clients_lock);
1551 INIT_LIST_HEAD(&adap->userspace_clients);
1553 /* Set default timeout to 1 second if not already set */
1554 if (adap->timeout == 0)
1557 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1558 adap->dev.bus = &i2c_bus_type;
1559 adap->dev.type = &i2c_adapter_type;
1560 res = device_register(&adap->dev);
1564 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1566 pm_runtime_no_callbacks(&adap->dev);
1567 pm_suspend_ignore_children(&adap->dev, true);
1568 pm_runtime_enable(&adap->dev);
1570 #ifdef CONFIG_I2C_COMPAT
1571 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1574 dev_warn(&adap->dev,
1575 "Failed to create compatibility class link\n");
1578 /* bus recovery specific initialization */
1579 if (adap->bus_recovery_info) {
1580 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1582 if (!bri->recover_bus) {
1583 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1584 adap->bus_recovery_info = NULL;
1588 /* Generic GPIO recovery */
1589 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1590 if (!gpio_is_valid(bri->scl_gpio)) {
1591 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1592 adap->bus_recovery_info = NULL;
1596 if (gpio_is_valid(bri->sda_gpio))
1597 bri->get_sda = get_sda_gpio_value;
1599 bri->get_sda = NULL;
1601 bri->get_scl = get_scl_gpio_value;
1602 bri->set_scl = set_scl_gpio_value;
1603 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
1604 /* Generic SCL recovery */
1605 if (!bri->set_scl || !bri->get_scl) {
1606 dev_err(&adap->dev, "No {get|set}_scl() found, not using recovery\n");
1607 adap->bus_recovery_info = NULL;
1613 /* create pre-declared device nodes */
1614 of_i2c_register_devices(adap);
1615 acpi_i2c_register_devices(adap);
1616 acpi_i2c_install_space_handler(adap);
1618 if (adap->nr < __i2c_first_dynamic_bus_num)
1619 i2c_scan_static_board_info(adap);
1621 /* Notify drivers */
1622 mutex_lock(&core_lock);
1623 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1624 mutex_unlock(&core_lock);
1629 mutex_lock(&core_lock);
1630 idr_remove(&i2c_adapter_idr, adap->nr);
1631 mutex_unlock(&core_lock);
1636 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1637 * @adap: the adapter to register (with adap->nr initialized)
1638 * Context: can sleep
1640 * See i2c_add_numbered_adapter() for details.
1642 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1646 mutex_lock(&core_lock);
1647 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1649 mutex_unlock(&core_lock);
1651 return id == -ENOSPC ? -EBUSY : id;
1653 return i2c_register_adapter(adap);
1657 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1658 * @adapter: the adapter to add
1659 * Context: can sleep
1661 * This routine is used to declare an I2C adapter when its bus number
1662 * doesn't matter or when its bus number is specified by an dt alias.
1663 * Examples of bases when the bus number doesn't matter: I2C adapters
1664 * dynamically added by USB links or PCI plugin cards.
1666 * When this returns zero, a new bus number was allocated and stored
1667 * in adap->nr, and the specified adapter became available for clients.
1668 * Otherwise, a negative errno value is returned.
1670 int i2c_add_adapter(struct i2c_adapter *adapter)
1672 struct device *dev = &adapter->dev;
1676 id = of_alias_get_id(dev->of_node, "i2c");
1679 return __i2c_add_numbered_adapter(adapter);
1683 mutex_lock(&core_lock);
1684 id = idr_alloc(&i2c_adapter_idr, adapter,
1685 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1686 mutex_unlock(&core_lock);
1692 return i2c_register_adapter(adapter);
1694 EXPORT_SYMBOL(i2c_add_adapter);
1697 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1698 * @adap: the adapter to register (with adap->nr initialized)
1699 * Context: can sleep
1701 * This routine is used to declare an I2C adapter when its bus number
1702 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1703 * or otherwise built in to the system's mainboard, and where i2c_board_info
1704 * is used to properly configure I2C devices.
1706 * If the requested bus number is set to -1, then this function will behave
1707 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1709 * If no devices have pre-been declared for this bus, then be sure to
1710 * register the adapter before any dynamically allocated ones. Otherwise
1711 * the required bus ID may not be available.
1713 * When this returns zero, the specified adapter became available for
1714 * clients using the bus number provided in adap->nr. Also, the table
1715 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1716 * and the appropriate driver model device nodes are created. Otherwise, a
1717 * negative errno value is returned.
1719 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1721 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1722 return i2c_add_adapter(adap);
1724 return __i2c_add_numbered_adapter(adap);
1726 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1728 static void i2c_do_del_adapter(struct i2c_driver *driver,
1729 struct i2c_adapter *adapter)
1731 struct i2c_client *client, *_n;
1733 /* Remove the devices we created ourselves as the result of hardware
1734 * probing (using a driver's detect method) */
1735 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1736 if (client->adapter == adapter) {
1737 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1738 client->name, client->addr);
1739 list_del(&client->detected);
1740 i2c_unregister_device(client);
1745 static int __unregister_client(struct device *dev, void *dummy)
1747 struct i2c_client *client = i2c_verify_client(dev);
1748 if (client && strcmp(client->name, "dummy"))
1749 i2c_unregister_device(client);
1753 static int __unregister_dummy(struct device *dev, void *dummy)
1755 struct i2c_client *client = i2c_verify_client(dev);
1757 i2c_unregister_device(client);
1761 static int __process_removed_adapter(struct device_driver *d, void *data)
1763 i2c_do_del_adapter(to_i2c_driver(d), data);
1768 * i2c_del_adapter - unregister I2C adapter
1769 * @adap: the adapter being unregistered
1770 * Context: can sleep
1772 * This unregisters an I2C adapter which was previously registered
1773 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1775 void i2c_del_adapter(struct i2c_adapter *adap)
1777 struct i2c_adapter *found;
1778 struct i2c_client *client, *next;
1780 /* First make sure that this adapter was ever added */
1781 mutex_lock(&core_lock);
1782 found = idr_find(&i2c_adapter_idr, adap->nr);
1783 mutex_unlock(&core_lock);
1784 if (found != adap) {
1785 pr_debug("i2c-core: attempting to delete unregistered "
1786 "adapter [%s]\n", adap->name);
1790 acpi_i2c_remove_space_handler(adap);
1791 /* Tell drivers about this removal */
1792 mutex_lock(&core_lock);
1793 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1794 __process_removed_adapter);
1795 mutex_unlock(&core_lock);
1797 /* Remove devices instantiated from sysfs */
1798 mutex_lock_nested(&adap->userspace_clients_lock,
1799 i2c_adapter_depth(adap));
1800 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1802 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1804 list_del(&client->detected);
1805 i2c_unregister_device(client);
1807 mutex_unlock(&adap->userspace_clients_lock);
1809 /* Detach any active clients. This can't fail, thus we do not
1810 * check the returned value. This is a two-pass process, because
1811 * we can't remove the dummy devices during the first pass: they
1812 * could have been instantiated by real devices wishing to clean
1813 * them up properly, so we give them a chance to do that first. */
1814 device_for_each_child(&adap->dev, NULL, __unregister_client);
1815 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1817 #ifdef CONFIG_I2C_COMPAT
1818 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1822 /* device name is gone after device_unregister */
1823 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1825 pm_runtime_disable(&adap->dev);
1827 /* wait until all references to the device are gone
1829 * FIXME: This is old code and should ideally be replaced by an
1830 * alternative which results in decoupling the lifetime of the struct
1831 * device from the i2c_adapter, like spi or netdev do. Any solution
1832 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
1834 init_completion(&adap->dev_released);
1835 device_unregister(&adap->dev);
1836 wait_for_completion(&adap->dev_released);
1839 mutex_lock(&core_lock);
1840 idr_remove(&i2c_adapter_idr, adap->nr);
1841 mutex_unlock(&core_lock);
1843 /* Clear the device structure in case this adapter is ever going to be
1845 memset(&adap->dev, 0, sizeof(adap->dev));
1847 EXPORT_SYMBOL(i2c_del_adapter);
1850 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
1851 * @dev: The device to scan for I2C timing properties
1852 * @t: the i2c_timings struct to be filled with values
1853 * @use_defaults: bool to use sane defaults derived from the I2C specification
1854 * when properties are not found, otherwise use 0
1856 * Scan the device for the generic I2C properties describing timing parameters
1857 * for the signal and fill the given struct with the results. If a property was
1858 * not found and use_defaults was true, then maximum timings are assumed which
1859 * are derived from the I2C specification. If use_defaults is not used, the
1860 * results will be 0, so drivers can apply their own defaults later. The latter
1861 * is mainly intended for avoiding regressions of existing drivers which want
1862 * to switch to this function. New drivers almost always should use the defaults.
1865 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
1869 memset(t, 0, sizeof(*t));
1871 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
1872 if (ret && use_defaults)
1873 t->bus_freq_hz = 100000;
1875 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
1876 if (ret && use_defaults) {
1877 if (t->bus_freq_hz <= 100000)
1878 t->scl_rise_ns = 1000;
1879 else if (t->bus_freq_hz <= 400000)
1880 t->scl_rise_ns = 300;
1882 t->scl_rise_ns = 120;
1885 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
1886 if (ret && use_defaults) {
1887 if (t->bus_freq_hz <= 400000)
1888 t->scl_fall_ns = 300;
1890 t->scl_fall_ns = 120;
1893 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
1895 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
1896 if (ret && use_defaults)
1897 t->sda_fall_ns = t->scl_fall_ns;
1899 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
1901 /* ------------------------------------------------------------------------- */
1903 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1907 mutex_lock(&core_lock);
1908 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1909 mutex_unlock(&core_lock);
1913 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1915 static int __process_new_driver(struct device *dev, void *data)
1917 if (dev->type != &i2c_adapter_type)
1919 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1923 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1924 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1927 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1931 /* Can't register until after driver model init */
1932 if (WARN_ON(!is_registered))
1935 /* add the driver to the list of i2c drivers in the driver core */
1936 driver->driver.owner = owner;
1937 driver->driver.bus = &i2c_bus_type;
1939 /* When registration returns, the driver core
1940 * will have called probe() for all matching-but-unbound devices.
1942 res = driver_register(&driver->driver);
1946 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1948 INIT_LIST_HEAD(&driver->clients);
1949 /* Walk the adapters that are already present */
1950 i2c_for_each_dev(driver, __process_new_driver);
1954 EXPORT_SYMBOL(i2c_register_driver);
1956 static int __process_removed_driver(struct device *dev, void *data)
1958 if (dev->type == &i2c_adapter_type)
1959 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1964 * i2c_del_driver - unregister I2C driver
1965 * @driver: the driver being unregistered
1966 * Context: can sleep
1968 void i2c_del_driver(struct i2c_driver *driver)
1970 i2c_for_each_dev(driver, __process_removed_driver);
1972 driver_unregister(&driver->driver);
1973 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1975 EXPORT_SYMBOL(i2c_del_driver);
1977 /* ------------------------------------------------------------------------- */
1980 * i2c_use_client - increments the reference count of the i2c client structure
1981 * @client: the client being referenced
1983 * Each live reference to a client should be refcounted. The driver model does
1984 * that automatically as part of driver binding, so that most drivers don't
1985 * need to do this explicitly: they hold a reference until they're unbound
1988 * A pointer to the client with the incremented reference counter is returned.
1990 struct i2c_client *i2c_use_client(struct i2c_client *client)
1992 if (client && get_device(&client->dev))
1996 EXPORT_SYMBOL(i2c_use_client);
1999 * i2c_release_client - release a use of the i2c client structure
2000 * @client: the client being no longer referenced
2002 * Must be called when a user of a client is finished with it.
2004 void i2c_release_client(struct i2c_client *client)
2007 put_device(&client->dev);
2009 EXPORT_SYMBOL(i2c_release_client);
2011 struct i2c_cmd_arg {
2016 static int i2c_cmd(struct device *dev, void *_arg)
2018 struct i2c_client *client = i2c_verify_client(dev);
2019 struct i2c_cmd_arg *arg = _arg;
2020 struct i2c_driver *driver;
2022 if (!client || !client->dev.driver)
2025 driver = to_i2c_driver(client->dev.driver);
2026 if (driver->command)
2027 driver->command(client, arg->cmd, arg->arg);
2031 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2033 struct i2c_cmd_arg cmd_arg;
2037 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2039 EXPORT_SYMBOL(i2c_clients_command);
2041 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2042 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2045 struct of_reconfig_data *rd = arg;
2046 struct i2c_adapter *adap;
2047 struct i2c_client *client;
2049 switch (of_reconfig_get_state_change(action, rd)) {
2050 case OF_RECONFIG_CHANGE_ADD:
2051 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2053 return NOTIFY_OK; /* not for us */
2055 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2056 put_device(&adap->dev);
2060 client = of_i2c_register_device(adap, rd->dn);
2061 put_device(&adap->dev);
2063 if (IS_ERR(client)) {
2064 pr_err("%s: failed to create for '%s'\n",
2065 __func__, rd->dn->full_name);
2066 return notifier_from_errno(PTR_ERR(client));
2069 case OF_RECONFIG_CHANGE_REMOVE:
2070 /* already depopulated? */
2071 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2074 /* find our device by node */
2075 client = of_find_i2c_device_by_node(rd->dn);
2077 return NOTIFY_OK; /* no? not meant for us */
2079 /* unregister takes one ref away */
2080 i2c_unregister_device(client);
2082 /* and put the reference of the find */
2083 put_device(&client->dev);
2089 static struct notifier_block i2c_of_notifier = {
2090 .notifier_call = of_i2c_notify,
2093 extern struct notifier_block i2c_of_notifier;
2094 #endif /* CONFIG_OF_DYNAMIC */
2096 static int __init i2c_init(void)
2100 retval = of_alias_get_highest_id("i2c");
2102 down_write(&__i2c_board_lock);
2103 if (retval >= __i2c_first_dynamic_bus_num)
2104 __i2c_first_dynamic_bus_num = retval + 1;
2105 up_write(&__i2c_board_lock);
2107 retval = bus_register(&i2c_bus_type);
2111 is_registered = true;
2113 #ifdef CONFIG_I2C_COMPAT
2114 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2115 if (!i2c_adapter_compat_class) {
2120 retval = i2c_add_driver(&dummy_driver);
2124 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2125 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2130 #ifdef CONFIG_I2C_COMPAT
2131 class_compat_unregister(i2c_adapter_compat_class);
2134 is_registered = false;
2135 bus_unregister(&i2c_bus_type);
2139 static void __exit i2c_exit(void)
2141 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2142 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2143 i2c_del_driver(&dummy_driver);
2144 #ifdef CONFIG_I2C_COMPAT
2145 class_compat_unregister(i2c_adapter_compat_class);
2147 bus_unregister(&i2c_bus_type);
2148 tracepoint_synchronize_unregister();
2151 /* We must initialize early, because some subsystems register i2c drivers
2152 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2154 postcore_initcall(i2c_init);
2155 module_exit(i2c_exit);
2157 /* ----------------------------------------------------
2158 * the functional interface to the i2c busses.
2159 * ----------------------------------------------------
2162 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2163 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2165 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2167 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2168 err_msg, msg->addr, msg->len,
2169 msg->flags & I2C_M_RD ? "read" : "write");
2173 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2175 const struct i2c_adapter_quirks *q = adap->quirks;
2176 int max_num = q->max_num_msgs, i;
2177 bool do_len_check = true;
2179 if (q->flags & I2C_AQ_COMB) {
2182 /* special checks for combined messages */
2184 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2185 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2187 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2188 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2190 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2191 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2193 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2194 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2196 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2197 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2199 do_len_check = false;
2203 if (i2c_quirk_exceeded(num, max_num))
2204 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2206 for (i = 0; i < num; i++) {
2207 u16 len = msgs[i].len;
2209 if (msgs[i].flags & I2C_M_RD) {
2210 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2211 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2213 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2214 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2222 * __i2c_transfer - unlocked flavor of i2c_transfer
2223 * @adap: Handle to I2C bus
2224 * @msgs: One or more messages to execute before STOP is issued to
2225 * terminate the operation; each message begins with a START.
2226 * @num: Number of messages to be executed.
2228 * Returns negative errno, else the number of messages executed.
2230 * Adapter lock must be held when calling this function. No debug logging
2231 * takes place. adap->algo->master_xfer existence isn't checked.
2233 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2235 unsigned long orig_jiffies;
2238 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2241 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2242 * enabled. This is an efficient way of keeping the for-loop from
2243 * being executed when not needed.
2245 if (static_key_false(&i2c_trace_msg)) {
2247 for (i = 0; i < num; i++)
2248 if (msgs[i].flags & I2C_M_RD)
2249 trace_i2c_read(adap, &msgs[i], i);
2251 trace_i2c_write(adap, &msgs[i], i);
2254 /* Retry automatically on arbitration loss */
2255 orig_jiffies = jiffies;
2256 for (ret = 0, try = 0; try <= adap->retries; try++) {
2257 ret = adap->algo->master_xfer(adap, msgs, num);
2260 if (time_after(jiffies, orig_jiffies + adap->timeout))
2264 if (static_key_false(&i2c_trace_msg)) {
2266 for (i = 0; i < ret; i++)
2267 if (msgs[i].flags & I2C_M_RD)
2268 trace_i2c_reply(adap, &msgs[i], i);
2269 trace_i2c_result(adap, i, ret);
2274 EXPORT_SYMBOL(__i2c_transfer);
2277 * i2c_transfer - execute a single or combined I2C message
2278 * @adap: Handle to I2C bus
2279 * @msgs: One or more messages to execute before STOP is issued to
2280 * terminate the operation; each message begins with a START.
2281 * @num: Number of messages to be executed.
2283 * Returns negative errno, else the number of messages executed.
2285 * Note that there is no requirement that each message be sent to
2286 * the same slave address, although that is the most common model.
2288 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2292 /* REVISIT the fault reporting model here is weak:
2294 * - When we get an error after receiving N bytes from a slave,
2295 * there is no way to report "N".
2297 * - When we get a NAK after transmitting N bytes to a slave,
2298 * there is no way to report "N" ... or to let the master
2299 * continue executing the rest of this combined message, if
2300 * that's the appropriate response.
2302 * - When for example "num" is two and we successfully complete
2303 * the first message but get an error part way through the
2304 * second, it's unclear whether that should be reported as
2305 * one (discarding status on the second message) or errno
2306 * (discarding status on the first one).
2309 if (adap->algo->master_xfer) {
2311 for (ret = 0; ret < num; ret++) {
2312 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2313 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2314 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2315 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2319 if (in_atomic() || irqs_disabled()) {
2320 ret = adap->trylock_bus(adap, I2C_LOCK_SEGMENT);
2322 /* I2C activity is ongoing. */
2325 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2328 ret = __i2c_transfer(adap, msgs, num);
2329 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2333 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2337 EXPORT_SYMBOL(i2c_transfer);
2340 * i2c_master_send - issue a single I2C message in master transmit mode
2341 * @client: Handle to slave device
2342 * @buf: Data that will be written to the slave
2343 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2345 * Returns negative errno, or else the number of bytes written.
2347 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2350 struct i2c_adapter *adap = client->adapter;
2353 msg.addr = client->addr;
2354 msg.flags = client->flags & I2C_M_TEN;
2356 msg.buf = (char *)buf;
2358 ret = i2c_transfer(adap, &msg, 1);
2361 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2362 * transmitted, else error code.
2364 return (ret == 1) ? count : ret;
2366 EXPORT_SYMBOL(i2c_master_send);
2369 * i2c_master_recv - issue a single I2C message in master receive mode
2370 * @client: Handle to slave device
2371 * @buf: Where to store data read from slave
2372 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2374 * Returns negative errno, or else the number of bytes read.
2376 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2378 struct i2c_adapter *adap = client->adapter;
2382 msg.addr = client->addr;
2383 msg.flags = client->flags & I2C_M_TEN;
2384 msg.flags |= I2C_M_RD;
2388 ret = i2c_transfer(adap, &msg, 1);
2391 * If everything went ok (i.e. 1 msg received), return #bytes received,
2394 return (ret == 1) ? count : ret;
2396 EXPORT_SYMBOL(i2c_master_recv);
2398 /* ----------------------------------------------------
2399 * the i2c address scanning function
2400 * Will not work for 10-bit addresses!
2401 * ----------------------------------------------------
2405 * Legacy default probe function, mostly relevant for SMBus. The default
2406 * probe method is a quick write, but it is known to corrupt the 24RF08
2407 * EEPROMs due to a state machine bug, and could also irreversibly
2408 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2409 * we use a short byte read instead. Also, some bus drivers don't implement
2410 * quick write, so we fallback to a byte read in that case too.
2411 * On x86, there is another special case for FSC hardware monitoring chips,
2412 * which want regular byte reads (address 0x73.) Fortunately, these are the
2413 * only known chips using this I2C address on PC hardware.
2414 * Returns 1 if probe succeeded, 0 if not.
2416 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2419 union i2c_smbus_data dummy;
2422 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2423 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2424 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2425 I2C_SMBUS_BYTE_DATA, &dummy);
2428 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2429 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2430 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2431 I2C_SMBUS_QUICK, NULL);
2432 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2433 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2434 I2C_SMBUS_BYTE, &dummy);
2436 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2444 static int i2c_detect_address(struct i2c_client *temp_client,
2445 struct i2c_driver *driver)
2447 struct i2c_board_info info;
2448 struct i2c_adapter *adapter = temp_client->adapter;
2449 int addr = temp_client->addr;
2452 /* Make sure the address is valid */
2453 err = i2c_check_7bit_addr_validity_strict(addr);
2455 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2460 /* Skip if already in use (7 bit, no need to encode flags) */
2461 if (i2c_check_addr_busy(adapter, addr))
2464 /* Make sure there is something at this address */
2465 if (!i2c_default_probe(adapter, addr))
2468 /* Finally call the custom detection function */
2469 memset(&info, 0, sizeof(struct i2c_board_info));
2471 err = driver->detect(temp_client, &info);
2473 /* -ENODEV is returned if the detection fails. We catch it
2474 here as this isn't an error. */
2475 return err == -ENODEV ? 0 : err;
2478 /* Consistency check */
2479 if (info.type[0] == '\0') {
2480 dev_err(&adapter->dev, "%s detection function provided "
2481 "no name for 0x%x\n", driver->driver.name,
2484 struct i2c_client *client;
2486 /* Detection succeeded, instantiate the device */
2487 if (adapter->class & I2C_CLASS_DEPRECATED)
2488 dev_warn(&adapter->dev,
2489 "This adapter will soon drop class based instantiation of devices. "
2490 "Please make sure client 0x%02x gets instantiated by other means. "
2491 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2494 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2495 info.type, info.addr);
2496 client = i2c_new_device(adapter, &info);
2498 list_add_tail(&client->detected, &driver->clients);
2500 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2501 info.type, info.addr);
2506 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2508 const unsigned short *address_list;
2509 struct i2c_client *temp_client;
2511 int adap_id = i2c_adapter_id(adapter);
2513 address_list = driver->address_list;
2514 if (!driver->detect || !address_list)
2517 /* Warn that the adapter lost class based instantiation */
2518 if (adapter->class == I2C_CLASS_DEPRECATED) {
2519 dev_dbg(&adapter->dev,
2520 "This adapter dropped support for I2C classes and "
2521 "won't auto-detect %s devices anymore. If you need it, check "
2522 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2523 driver->driver.name);
2527 /* Stop here if the classes do not match */
2528 if (!(adapter->class & driver->class))
2531 /* Set up a temporary client to help detect callback */
2532 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2535 temp_client->adapter = adapter;
2537 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2538 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2539 "addr 0x%02x\n", adap_id, address_list[i]);
2540 temp_client->addr = address_list[i];
2541 err = i2c_detect_address(temp_client, driver);
2550 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2552 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2553 I2C_SMBUS_QUICK, NULL) >= 0;
2555 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2558 i2c_new_probed_device(struct i2c_adapter *adap,
2559 struct i2c_board_info *info,
2560 unsigned short const *addr_list,
2561 int (*probe)(struct i2c_adapter *, unsigned short addr))
2566 probe = i2c_default_probe;
2568 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2569 /* Check address validity */
2570 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2571 dev_warn(&adap->dev, "Invalid 7-bit address "
2572 "0x%02x\n", addr_list[i]);
2576 /* Check address availability (7 bit, no need to encode flags) */
2577 if (i2c_check_addr_busy(adap, addr_list[i])) {
2578 dev_dbg(&adap->dev, "Address 0x%02x already in "
2579 "use, not probing\n", addr_list[i]);
2583 /* Test address responsiveness */
2584 if (probe(adap, addr_list[i]))
2588 if (addr_list[i] == I2C_CLIENT_END) {
2589 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2593 info->addr = addr_list[i];
2594 return i2c_new_device(adap, info);
2596 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2598 struct i2c_adapter *i2c_get_adapter(int nr)
2600 struct i2c_adapter *adapter;
2602 mutex_lock(&core_lock);
2603 adapter = idr_find(&i2c_adapter_idr, nr);
2607 if (try_module_get(adapter->owner))
2608 get_device(&adapter->dev);
2613 mutex_unlock(&core_lock);
2616 EXPORT_SYMBOL(i2c_get_adapter);
2618 void i2c_put_adapter(struct i2c_adapter *adap)
2623 put_device(&adap->dev);
2624 module_put(adap->owner);
2626 EXPORT_SYMBOL(i2c_put_adapter);
2628 /* The SMBus parts */
2630 #define POLY (0x1070U << 3)
2631 static u8 crc8(u16 data)
2635 for (i = 0; i < 8; i++) {
2640 return (u8)(data >> 8);
2643 /* Incremental CRC8 over count bytes in the array pointed to by p */
2644 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2648 for (i = 0; i < count; i++)
2649 crc = crc8((crc ^ p[i]) << 8);
2653 /* Assume a 7-bit address, which is reasonable for SMBus */
2654 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2656 /* The address will be sent first */
2657 u8 addr = i2c_8bit_addr_from_msg(msg);
2658 pec = i2c_smbus_pec(pec, &addr, 1);
2660 /* The data buffer follows */
2661 return i2c_smbus_pec(pec, msg->buf, msg->len);
2664 /* Used for write only transactions */
2665 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2667 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2671 /* Return <0 on CRC error
2672 If there was a write before this read (most cases) we need to take the
2673 partial CRC from the write part into account.
2674 Note that this function does modify the message (we need to decrease the
2675 message length to hide the CRC byte from the caller). */
2676 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2678 u8 rpec = msg->buf[--msg->len];
2679 cpec = i2c_smbus_msg_pec(cpec, msg);
2682 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2690 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2691 * @client: Handle to slave device
2693 * This executes the SMBus "receive byte" protocol, returning negative errno
2694 * else the byte received from the device.
2696 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2698 union i2c_smbus_data data;
2701 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2703 I2C_SMBUS_BYTE, &data);
2704 return (status < 0) ? status : data.byte;
2706 EXPORT_SYMBOL(i2c_smbus_read_byte);
2709 * i2c_smbus_write_byte - SMBus "send byte" protocol
2710 * @client: Handle to slave device
2711 * @value: Byte to be sent
2713 * This executes the SMBus "send byte" protocol, returning negative errno
2714 * else zero on success.
2716 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2718 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2719 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2721 EXPORT_SYMBOL(i2c_smbus_write_byte);
2724 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2725 * @client: Handle to slave device
2726 * @command: Byte interpreted by slave
2728 * This executes the SMBus "read byte" protocol, returning negative errno
2729 * else a data byte received from the device.
2731 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2733 union i2c_smbus_data data;
2736 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2737 I2C_SMBUS_READ, command,
2738 I2C_SMBUS_BYTE_DATA, &data);
2739 return (status < 0) ? status : data.byte;
2741 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2744 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2745 * @client: Handle to slave device
2746 * @command: Byte interpreted by slave
2747 * @value: Byte being written
2749 * This executes the SMBus "write byte" protocol, returning negative errno
2750 * else zero on success.
2752 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2755 union i2c_smbus_data data;
2757 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2758 I2C_SMBUS_WRITE, command,
2759 I2C_SMBUS_BYTE_DATA, &data);
2761 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2764 * i2c_smbus_read_word_data - SMBus "read word" protocol
2765 * @client: Handle to slave device
2766 * @command: Byte interpreted by slave
2768 * This executes the SMBus "read word" protocol, returning negative errno
2769 * else a 16-bit unsigned "word" received from the device.
2771 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2773 union i2c_smbus_data data;
2776 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2777 I2C_SMBUS_READ, command,
2778 I2C_SMBUS_WORD_DATA, &data);
2779 return (status < 0) ? status : data.word;
2781 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2784 * i2c_smbus_write_word_data - SMBus "write word" protocol
2785 * @client: Handle to slave device
2786 * @command: Byte interpreted by slave
2787 * @value: 16-bit "word" being written
2789 * This executes the SMBus "write word" protocol, returning negative errno
2790 * else zero on success.
2792 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2795 union i2c_smbus_data data;
2797 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2798 I2C_SMBUS_WRITE, command,
2799 I2C_SMBUS_WORD_DATA, &data);
2801 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2804 * i2c_smbus_read_block_data - SMBus "block read" protocol
2805 * @client: Handle to slave device
2806 * @command: Byte interpreted by slave
2807 * @values: Byte array into which data will be read; big enough to hold
2808 * the data returned by the slave. SMBus allows at most 32 bytes.
2810 * This executes the SMBus "block read" protocol, returning negative errno
2811 * else the number of data bytes in the slave's response.
2813 * Note that using this function requires that the client's adapter support
2814 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2815 * support this; its emulation through I2C messaging relies on a specific
2816 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2818 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2821 union i2c_smbus_data data;
2824 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2825 I2C_SMBUS_READ, command,
2826 I2C_SMBUS_BLOCK_DATA, &data);
2830 memcpy(values, &data.block[1], data.block[0]);
2831 return data.block[0];
2833 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2836 * i2c_smbus_write_block_data - SMBus "block write" protocol
2837 * @client: Handle to slave device
2838 * @command: Byte interpreted by slave
2839 * @length: Size of data block; SMBus allows at most 32 bytes
2840 * @values: Byte array which will be written.
2842 * This executes the SMBus "block write" protocol, returning negative errno
2843 * else zero on success.
2845 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2846 u8 length, const u8 *values)
2848 union i2c_smbus_data data;
2850 if (length > I2C_SMBUS_BLOCK_MAX)
2851 length = I2C_SMBUS_BLOCK_MAX;
2852 data.block[0] = length;
2853 memcpy(&data.block[1], values, length);
2854 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2855 I2C_SMBUS_WRITE, command,
2856 I2C_SMBUS_BLOCK_DATA, &data);
2858 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2860 /* Returns the number of read bytes */
2861 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2862 u8 length, u8 *values)
2864 union i2c_smbus_data data;
2867 if (length > I2C_SMBUS_BLOCK_MAX)
2868 length = I2C_SMBUS_BLOCK_MAX;
2869 data.block[0] = length;
2870 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2871 I2C_SMBUS_READ, command,
2872 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2876 memcpy(values, &data.block[1], data.block[0]);
2877 return data.block[0];
2879 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2881 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2882 u8 length, const u8 *values)
2884 union i2c_smbus_data data;
2886 if (length > I2C_SMBUS_BLOCK_MAX)
2887 length = I2C_SMBUS_BLOCK_MAX;
2888 data.block[0] = length;
2889 memcpy(data.block + 1, values, length);
2890 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2891 I2C_SMBUS_WRITE, command,
2892 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2894 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2896 /* Simulate a SMBus command using the i2c protocol
2897 No checking of parameters is done! */
2898 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2899 unsigned short flags,
2900 char read_write, u8 command, int size,
2901 union i2c_smbus_data *data)
2903 /* So we need to generate a series of msgs. In the case of writing, we
2904 need to use only one message; when reading, we need two. We initialize
2905 most things with sane defaults, to keep the code below somewhat
2907 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2908 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2909 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2913 struct i2c_msg msg[2] = {
2921 .flags = flags | I2C_M_RD,
2927 msgbuf0[0] = command;
2929 case I2C_SMBUS_QUICK:
2931 /* Special case: The read/write field is used as data */
2932 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2936 case I2C_SMBUS_BYTE:
2937 if (read_write == I2C_SMBUS_READ) {
2938 /* Special case: only a read! */
2939 msg[0].flags = I2C_M_RD | flags;
2943 case I2C_SMBUS_BYTE_DATA:
2944 if (read_write == I2C_SMBUS_READ)
2948 msgbuf0[1] = data->byte;
2951 case I2C_SMBUS_WORD_DATA:
2952 if (read_write == I2C_SMBUS_READ)
2956 msgbuf0[1] = data->word & 0xff;
2957 msgbuf0[2] = data->word >> 8;
2960 case I2C_SMBUS_PROC_CALL:
2961 num = 2; /* Special case */
2962 read_write = I2C_SMBUS_READ;
2965 msgbuf0[1] = data->word & 0xff;
2966 msgbuf0[2] = data->word >> 8;
2968 case I2C_SMBUS_BLOCK_DATA:
2969 if (read_write == I2C_SMBUS_READ) {
2970 msg[1].flags |= I2C_M_RECV_LEN;
2971 msg[1].len = 1; /* block length will be added by
2972 the underlying bus driver */
2974 msg[0].len = data->block[0] + 2;
2975 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2976 dev_err(&adapter->dev,
2977 "Invalid block write size %d\n",
2981 for (i = 1; i < msg[0].len; i++)
2982 msgbuf0[i] = data->block[i-1];
2985 case I2C_SMBUS_BLOCK_PROC_CALL:
2986 num = 2; /* Another special case */
2987 read_write = I2C_SMBUS_READ;
2988 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2989 dev_err(&adapter->dev,
2990 "Invalid block write size %d\n",
2994 msg[0].len = data->block[0] + 2;
2995 for (i = 1; i < msg[0].len; i++)
2996 msgbuf0[i] = data->block[i-1];
2997 msg[1].flags |= I2C_M_RECV_LEN;
2998 msg[1].len = 1; /* block length will be added by
2999 the underlying bus driver */
3001 case I2C_SMBUS_I2C_BLOCK_DATA:
3002 if (read_write == I2C_SMBUS_READ) {
3003 msg[1].len = data->block[0];
3005 msg[0].len = data->block[0] + 1;
3006 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3007 dev_err(&adapter->dev,
3008 "Invalid block write size %d\n",
3012 for (i = 1; i <= data->block[0]; i++)
3013 msgbuf0[i] = data->block[i];
3017 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3021 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3022 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3024 /* Compute PEC if first message is a write */
3025 if (!(msg[0].flags & I2C_M_RD)) {
3026 if (num == 1) /* Write only */
3027 i2c_smbus_add_pec(&msg[0]);
3028 else /* Write followed by read */
3029 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3031 /* Ask for PEC if last message is a read */
3032 if (msg[num-1].flags & I2C_M_RD)
3036 status = i2c_transfer(adapter, msg, num);
3040 /* Check PEC if last message is a read */
3041 if (i && (msg[num-1].flags & I2C_M_RD)) {
3042 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3047 if (read_write == I2C_SMBUS_READ)
3049 case I2C_SMBUS_BYTE:
3050 data->byte = msgbuf0[0];
3052 case I2C_SMBUS_BYTE_DATA:
3053 data->byte = msgbuf1[0];
3055 case I2C_SMBUS_WORD_DATA:
3056 case I2C_SMBUS_PROC_CALL:
3057 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3059 case I2C_SMBUS_I2C_BLOCK_DATA:
3060 for (i = 0; i < data->block[0]; i++)
3061 data->block[i+1] = msgbuf1[i];
3063 case I2C_SMBUS_BLOCK_DATA:
3064 case I2C_SMBUS_BLOCK_PROC_CALL:
3065 for (i = 0; i < msgbuf1[0] + 1; i++)
3066 data->block[i] = msgbuf1[i];
3073 * i2c_smbus_xfer - execute SMBus protocol operations
3074 * @adapter: Handle to I2C bus
3075 * @addr: Address of SMBus slave on that bus
3076 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3077 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3078 * @command: Byte interpreted by slave, for protocols which use such bytes
3079 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3080 * @data: Data to be read or written
3082 * This executes an SMBus protocol operation, and returns a negative
3083 * errno code else zero on success.
3085 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3086 char read_write, u8 command, int protocol,
3087 union i2c_smbus_data *data)
3089 unsigned long orig_jiffies;
3093 /* If enabled, the following two tracepoints are conditional on
3094 * read_write and protocol.
3096 trace_smbus_write(adapter, addr, flags, read_write,
3097 command, protocol, data);
3098 trace_smbus_read(adapter, addr, flags, read_write,
3101 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3103 if (adapter->algo->smbus_xfer) {
3104 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3106 /* Retry automatically on arbitration loss */
3107 orig_jiffies = jiffies;
3108 for (res = 0, try = 0; try <= adapter->retries; try++) {
3109 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3110 read_write, command,
3114 if (time_after(jiffies,
3115 orig_jiffies + adapter->timeout))
3118 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3120 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3123 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3124 * implement native support for the SMBus operation.
3128 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3129 command, protocol, data);
3132 /* If enabled, the reply tracepoint is conditional on read_write. */
3133 trace_smbus_reply(adapter, addr, flags, read_write,
3134 command, protocol, data);
3135 trace_smbus_result(adapter, addr, flags, read_write,
3136 command, protocol, res);
3140 EXPORT_SYMBOL(i2c_smbus_xfer);
3143 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3144 * @client: Handle to slave device
3145 * @command: Byte interpreted by slave
3146 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3147 * @values: Byte array into which data will be read; big enough to hold
3148 * the data returned by the slave. SMBus allows at most
3149 * I2C_SMBUS_BLOCK_MAX bytes.
3151 * This executes the SMBus "block read" protocol if supported by the adapter.
3152 * If block read is not supported, it emulates it using either word or byte
3153 * read protocols depending on availability.
3155 * The addresses of the I2C slave device that are accessed with this function
3156 * must be mapped to a linear region, so that a block read will have the same
3157 * effect as a byte read. Before using this function you must double-check
3158 * if the I2C slave does support exchanging a block transfer with a byte
3161 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3162 u8 command, u8 length, u8 *values)
3167 if (length > I2C_SMBUS_BLOCK_MAX)
3168 length = I2C_SMBUS_BLOCK_MAX;
3170 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3171 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3173 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3176 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3177 while ((i + 2) <= length) {
3178 status = i2c_smbus_read_word_data(client, command + i);
3181 values[i] = status & 0xff;
3182 values[i + 1] = status >> 8;
3187 while (i < length) {
3188 status = i2c_smbus_read_byte_data(client, command + i);
3197 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3199 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3200 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3204 if (!client || !slave_cb) {
3205 WARN(1, "insufficent data\n");
3209 if (!(client->flags & I2C_CLIENT_SLAVE))
3210 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3213 if (!(client->flags & I2C_CLIENT_TEN)) {
3214 /* Enforce stricter address checking */
3215 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3217 dev_err(&client->dev, "%s: invalid address\n", __func__);
3222 if (!client->adapter->algo->reg_slave) {
3223 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3227 client->slave_cb = slave_cb;
3229 i2c_lock_adapter(client->adapter);
3230 ret = client->adapter->algo->reg_slave(client);
3231 i2c_unlock_adapter(client->adapter);
3234 client->slave_cb = NULL;
3235 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3240 EXPORT_SYMBOL_GPL(i2c_slave_register);
3242 int i2c_slave_unregister(struct i2c_client *client)
3246 if (!client->adapter->algo->unreg_slave) {
3247 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3251 i2c_lock_adapter(client->adapter);
3252 ret = client->adapter->algo->unreg_slave(client);
3253 i2c_unlock_adapter(client->adapter);
3256 client->slave_cb = NULL;
3258 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3262 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3265 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3266 MODULE_DESCRIPTION("I2C-Bus main module");
3267 MODULE_LICENSE("GPL");