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 void i2c_init_recovery(struct i2c_adapter *adap)
671 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
677 if (!bri->recover_bus) {
678 err_str = "no recover_bus() found";
682 /* Generic GPIO recovery */
683 if (bri->recover_bus == i2c_generic_gpio_recovery) {
684 if (!gpio_is_valid(bri->scl_gpio)) {
685 err_str = "invalid SCL gpio";
689 if (gpio_is_valid(bri->sda_gpio))
690 bri->get_sda = get_sda_gpio_value;
694 bri->get_scl = get_scl_gpio_value;
695 bri->set_scl = set_scl_gpio_value;
696 } else if (bri->recover_bus == i2c_generic_scl_recovery) {
697 /* Generic SCL recovery */
698 if (!bri->set_scl || !bri->get_scl) {
699 err_str = "no {get|set}_scl() found";
706 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
707 adap->bus_recovery_info = NULL;
710 static int i2c_device_probe(struct device *dev)
712 struct i2c_client *client = i2c_verify_client(dev);
713 struct i2c_driver *driver;
723 irq = of_irq_get_byname(dev->of_node, "irq");
724 if (irq == -EINVAL || irq == -ENODATA)
725 irq = of_irq_get(dev->of_node, 0);
726 } else if (ACPI_COMPANION(dev)) {
727 irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
729 if (irq == -EPROBE_DEFER)
737 driver = to_i2c_driver(dev->driver);
738 if (!driver->probe || !driver->id_table)
741 if (client->flags & I2C_CLIENT_WAKE) {
742 int wakeirq = -ENOENT;
745 wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
746 if (wakeirq == -EPROBE_DEFER)
750 device_init_wakeup(&client->dev, true);
752 if (wakeirq > 0 && wakeirq != client->irq)
753 status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
754 else if (client->irq > 0)
755 status = dev_pm_set_wake_irq(dev, client->irq);
760 dev_warn(&client->dev, "failed to set up wakeup irq");
763 dev_dbg(dev, "probe\n");
765 status = of_clk_set_defaults(dev->of_node, false);
767 goto err_clear_wakeup_irq;
769 status = dev_pm_domain_attach(&client->dev, true);
770 if (status == -EPROBE_DEFER)
771 goto err_clear_wakeup_irq;
773 status = driver->probe(client, i2c_match_id(driver->id_table, client));
775 goto err_detach_pm_domain;
779 err_detach_pm_domain:
780 dev_pm_domain_detach(&client->dev, true);
781 err_clear_wakeup_irq:
782 dev_pm_clear_wake_irq(&client->dev);
783 device_init_wakeup(&client->dev, false);
787 static int i2c_device_remove(struct device *dev)
789 struct i2c_client *client = i2c_verify_client(dev);
790 struct i2c_driver *driver;
793 if (!client || !dev->driver)
796 driver = to_i2c_driver(dev->driver);
797 if (driver->remove) {
798 dev_dbg(dev, "remove\n");
799 status = driver->remove(client);
802 dev_pm_domain_detach(&client->dev, true);
804 dev_pm_clear_wake_irq(&client->dev);
805 device_init_wakeup(&client->dev, false);
810 static void i2c_device_shutdown(struct device *dev)
812 struct i2c_client *client = i2c_verify_client(dev);
813 struct i2c_driver *driver;
815 if (!client || !dev->driver)
817 driver = to_i2c_driver(dev->driver);
818 if (driver->shutdown)
819 driver->shutdown(client);
822 static void i2c_client_dev_release(struct device *dev)
824 kfree(to_i2c_client(dev));
828 show_name(struct device *dev, struct device_attribute *attr, char *buf)
830 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
831 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
833 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
836 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
838 struct i2c_client *client = to_i2c_client(dev);
841 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
845 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
847 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
849 static struct attribute *i2c_dev_attrs[] = {
851 /* modalias helps coldplug: modprobe $(cat .../modalias) */
852 &dev_attr_modalias.attr,
855 ATTRIBUTE_GROUPS(i2c_dev);
857 struct bus_type i2c_bus_type = {
859 .match = i2c_device_match,
860 .probe = i2c_device_probe,
861 .remove = i2c_device_remove,
862 .shutdown = i2c_device_shutdown,
864 EXPORT_SYMBOL_GPL(i2c_bus_type);
866 static struct device_type i2c_client_type = {
867 .groups = i2c_dev_groups,
868 .uevent = i2c_device_uevent,
869 .release = i2c_client_dev_release,
874 * i2c_verify_client - return parameter as i2c_client, or NULL
875 * @dev: device, probably from some driver model iterator
877 * When traversing the driver model tree, perhaps using driver model
878 * iterators like @device_for_each_child(), you can't assume very much
879 * about the nodes you find. Use this function to avoid oopses caused
880 * by wrongly treating some non-I2C device as an i2c_client.
882 struct i2c_client *i2c_verify_client(struct device *dev)
884 return (dev->type == &i2c_client_type)
888 EXPORT_SYMBOL(i2c_verify_client);
891 /* Return a unique address which takes the flags of the client into account */
892 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
894 unsigned short addr = client->addr;
896 /* For some client flags, add an arbitrary offset to avoid collisions */
897 if (client->flags & I2C_CLIENT_TEN)
898 addr |= I2C_ADDR_OFFSET_TEN_BIT;
900 if (client->flags & I2C_CLIENT_SLAVE)
901 addr |= I2C_ADDR_OFFSET_SLAVE;
906 /* This is a permissive address validity check, I2C address map constraints
907 * are purposely not enforced, except for the general call address. */
908 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
910 if (flags & I2C_CLIENT_TEN) {
911 /* 10-bit address, all values are valid */
915 /* 7-bit address, reject the general call address */
916 if (addr == 0x00 || addr > 0x7f)
922 /* And this is a strict address validity check, used when probing. If a
923 * device uses a reserved address, then it shouldn't be probed. 7-bit
924 * addressing is assumed, 10-bit address devices are rare and should be
925 * explicitly enumerated. */
926 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
929 * Reserved addresses per I2C specification:
930 * 0x00 General call address / START byte
932 * 0x02 Reserved for different bus format
933 * 0x03 Reserved for future purposes
934 * 0x04-0x07 Hs-mode master code
935 * 0x78-0x7b 10-bit slave addressing
936 * 0x7c-0x7f Reserved for future purposes
938 if (addr < 0x08 || addr > 0x77)
943 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
945 struct i2c_client *client = i2c_verify_client(dev);
946 int addr = *(int *)addrp;
948 if (client && i2c_encode_flags_to_addr(client) == addr)
953 /* walk up mux tree */
954 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
956 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
959 result = device_for_each_child(&adapter->dev, &addr,
960 __i2c_check_addr_busy);
962 if (!result && parent)
963 result = i2c_check_mux_parents(parent, addr);
968 /* recurse down mux tree */
969 static int i2c_check_mux_children(struct device *dev, void *addrp)
973 if (dev->type == &i2c_adapter_type)
974 result = device_for_each_child(dev, addrp,
975 i2c_check_mux_children);
977 result = __i2c_check_addr_busy(dev, addrp);
982 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
984 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
988 result = i2c_check_mux_parents(parent, addr);
991 result = device_for_each_child(&adapter->dev, &addr,
992 i2c_check_mux_children);
998 * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
999 * @adapter: Target I2C bus segment
1000 * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1001 * locks only this branch in the adapter tree
1003 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1006 rt_mutex_lock(&adapter->bus_lock);
1010 * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1011 * @adapter: Target I2C bus segment
1012 * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1013 * trylocks only this branch in the adapter tree
1015 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1018 return rt_mutex_trylock(&adapter->bus_lock);
1022 * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1023 * @adapter: Target I2C bus segment
1024 * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1025 * unlocks only this branch in the adapter tree
1027 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1030 rt_mutex_unlock(&adapter->bus_lock);
1033 static void i2c_dev_set_name(struct i2c_adapter *adap,
1034 struct i2c_client *client)
1036 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1039 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1043 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1044 i2c_encode_flags_to_addr(client));
1048 * i2c_new_device - instantiate an i2c device
1049 * @adap: the adapter managing the device
1050 * @info: describes one I2C device; bus_num is ignored
1051 * Context: can sleep
1053 * Create an i2c device. Binding is handled through driver model
1054 * probe()/remove() methods. A driver may be bound to this device when we
1055 * return from this function, or any later moment (e.g. maybe hotplugging will
1056 * load the driver module). This call is not appropriate for use by mainboard
1057 * initialization logic, which usually runs during an arch_initcall() long
1058 * before any i2c_adapter could exist.
1060 * This returns the new i2c client, which may be saved for later use with
1061 * i2c_unregister_device(); or NULL to indicate an error.
1064 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1066 struct i2c_client *client;
1069 client = kzalloc(sizeof *client, GFP_KERNEL);
1073 client->adapter = adap;
1075 client->dev.platform_data = info->platform_data;
1078 client->dev.archdata = *info->archdata;
1080 client->flags = info->flags;
1081 client->addr = info->addr;
1082 client->irq = info->irq;
1084 strlcpy(client->name, info->type, sizeof(client->name));
1086 status = i2c_check_addr_validity(client->addr, client->flags);
1088 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1089 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1090 goto out_err_silent;
1093 /* Check for address business */
1094 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1098 client->dev.parent = &client->adapter->dev;
1099 client->dev.bus = &i2c_bus_type;
1100 client->dev.type = &i2c_client_type;
1101 client->dev.of_node = info->of_node;
1102 client->dev.fwnode = info->fwnode;
1104 i2c_dev_set_name(adap, client);
1105 status = device_register(&client->dev);
1109 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1110 client->name, dev_name(&client->dev));
1115 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
1116 "(%d)\n", client->name, client->addr, status);
1121 EXPORT_SYMBOL_GPL(i2c_new_device);
1125 * i2c_unregister_device - reverse effect of i2c_new_device()
1126 * @client: value returned from i2c_new_device()
1127 * Context: can sleep
1129 void i2c_unregister_device(struct i2c_client *client)
1131 if (client->dev.of_node)
1132 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1133 device_unregister(&client->dev);
1135 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1138 static const struct i2c_device_id dummy_id[] = {
1143 static int dummy_probe(struct i2c_client *client,
1144 const struct i2c_device_id *id)
1149 static int dummy_remove(struct i2c_client *client)
1154 static struct i2c_driver dummy_driver = {
1155 .driver.name = "dummy",
1156 .probe = dummy_probe,
1157 .remove = dummy_remove,
1158 .id_table = dummy_id,
1162 * i2c_new_dummy - return a new i2c device bound to a dummy driver
1163 * @adapter: the adapter managing the device
1164 * @address: seven bit address to be used
1165 * Context: can sleep
1167 * This returns an I2C client bound to the "dummy" driver, intended for use
1168 * with devices that consume multiple addresses. Examples of such chips
1169 * include various EEPROMS (like 24c04 and 24c08 models).
1171 * These dummy devices have two main uses. First, most I2C and SMBus calls
1172 * except i2c_transfer() need a client handle; the dummy will be that handle.
1173 * And second, this prevents the specified address from being bound to a
1176 * This returns the new i2c client, which should be saved for later use with
1177 * i2c_unregister_device(); or NULL to indicate an error.
1179 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1181 struct i2c_board_info info = {
1182 I2C_BOARD_INFO("dummy", address),
1185 return i2c_new_device(adapter, &info);
1187 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1190 * i2c_new_secondary_device - Helper to get the instantiated secondary address
1191 * and create the associated device
1192 * @client: Handle to the primary client
1193 * @name: Handle to specify which secondary address to get
1194 * @default_addr: Used as a fallback if no secondary address was specified
1195 * Context: can sleep
1197 * I2C clients can be composed of multiple I2C slaves bound together in a single
1198 * component. The I2C client driver then binds to the master I2C slave and needs
1199 * to create I2C dummy clients to communicate with all the other slaves.
1201 * This function creates and returns an I2C dummy client whose I2C address is
1202 * retrieved from the platform firmware based on the given slave name. If no
1203 * address is specified by the firmware default_addr is used.
1205 * On DT-based platforms the address is retrieved from the "reg" property entry
1206 * cell whose "reg-names" value matches the slave name.
1208 * This returns the new i2c client, which should be saved for later use with
1209 * i2c_unregister_device(); or NULL to indicate an error.
1211 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1215 struct device_node *np = client->dev.of_node;
1216 u32 addr = default_addr;
1220 i = of_property_match_string(np, "reg-names", name);
1222 of_property_read_u32_index(np, "reg", i, &addr);
1225 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1226 return i2c_new_dummy(client->adapter, addr);
1228 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1230 /* ------------------------------------------------------------------------- */
1232 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1234 static void i2c_adapter_dev_release(struct device *dev)
1236 struct i2c_adapter *adap = to_i2c_adapter(dev);
1237 complete(&adap->dev_released);
1241 * This function is only needed for mutex_lock_nested, so it is never
1242 * called unless locking correctness checking is enabled. Thus we
1243 * make it inline to avoid a compiler warning. That's what gcc ends up
1246 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1248 unsigned int depth = 0;
1250 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1257 * Let users instantiate I2C devices through sysfs. This can be used when
1258 * platform initialization code doesn't contain the proper data for
1259 * whatever reason. Also useful for drivers that do device detection and
1260 * detection fails, either because the device uses an unexpected address,
1261 * or this is a compatible device with different ID register values.
1263 * Parameter checking may look overzealous, but we really don't want
1264 * the user to provide incorrect parameters.
1267 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1268 const char *buf, size_t count)
1270 struct i2c_adapter *adap = to_i2c_adapter(dev);
1271 struct i2c_board_info info;
1272 struct i2c_client *client;
1276 memset(&info, 0, sizeof(struct i2c_board_info));
1278 blank = strchr(buf, ' ');
1280 dev_err(dev, "%s: Missing parameters\n", "new_device");
1283 if (blank - buf > I2C_NAME_SIZE - 1) {
1284 dev_err(dev, "%s: Invalid device name\n", "new_device");
1287 memcpy(info.type, buf, blank - buf);
1289 /* Parse remaining parameters, reject extra parameters */
1290 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1292 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1295 if (res > 1 && end != '\n') {
1296 dev_err(dev, "%s: Extra parameters\n", "new_device");
1300 if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1301 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1302 info.flags |= I2C_CLIENT_TEN;
1305 if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1306 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1307 info.flags |= I2C_CLIENT_SLAVE;
1310 client = i2c_new_device(adap, &info);
1314 /* Keep track of the added device */
1315 mutex_lock(&adap->userspace_clients_lock);
1316 list_add_tail(&client->detected, &adap->userspace_clients);
1317 mutex_unlock(&adap->userspace_clients_lock);
1318 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1319 info.type, info.addr);
1323 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1326 * And of course let the users delete the devices they instantiated, if
1327 * they got it wrong. This interface can only be used to delete devices
1328 * instantiated by i2c_sysfs_new_device above. This guarantees that we
1329 * don't delete devices to which some kernel code still has references.
1331 * Parameter checking may look overzealous, but we really don't want
1332 * the user to delete the wrong device.
1335 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1336 const char *buf, size_t count)
1338 struct i2c_adapter *adap = to_i2c_adapter(dev);
1339 struct i2c_client *client, *next;
1340 unsigned short addr;
1344 /* Parse parameters, reject extra parameters */
1345 res = sscanf(buf, "%hi%c", &addr, &end);
1347 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1350 if (res > 1 && end != '\n') {
1351 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1355 /* Make sure the device was added through sysfs */
1357 mutex_lock_nested(&adap->userspace_clients_lock,
1358 i2c_adapter_depth(adap));
1359 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1361 if (i2c_encode_flags_to_addr(client) == addr) {
1362 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1363 "delete_device", client->name, client->addr);
1365 list_del(&client->detected);
1366 i2c_unregister_device(client);
1371 mutex_unlock(&adap->userspace_clients_lock);
1374 dev_err(dev, "%s: Can't find device in list\n",
1378 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1379 i2c_sysfs_delete_device);
1381 static struct attribute *i2c_adapter_attrs[] = {
1382 &dev_attr_name.attr,
1383 &dev_attr_new_device.attr,
1384 &dev_attr_delete_device.attr,
1387 ATTRIBUTE_GROUPS(i2c_adapter);
1389 struct device_type i2c_adapter_type = {
1390 .groups = i2c_adapter_groups,
1391 .release = i2c_adapter_dev_release,
1393 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1396 * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1397 * @dev: device, probably from some driver model iterator
1399 * When traversing the driver model tree, perhaps using driver model
1400 * iterators like @device_for_each_child(), you can't assume very much
1401 * about the nodes you find. Use this function to avoid oopses caused
1402 * by wrongly treating some non-I2C device as an i2c_adapter.
1404 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1406 return (dev->type == &i2c_adapter_type)
1407 ? to_i2c_adapter(dev)
1410 EXPORT_SYMBOL(i2c_verify_adapter);
1412 #ifdef CONFIG_I2C_COMPAT
1413 static struct class_compat *i2c_adapter_compat_class;
1416 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1418 struct i2c_devinfo *devinfo;
1420 down_read(&__i2c_board_lock);
1421 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1422 if (devinfo->busnum == adapter->nr
1423 && !i2c_new_device(adapter,
1424 &devinfo->board_info))
1425 dev_err(&adapter->dev,
1426 "Can't create device at 0x%02x\n",
1427 devinfo->board_info.addr);
1429 up_read(&__i2c_board_lock);
1432 /* OF support code */
1434 #if IS_ENABLED(CONFIG_OF)
1435 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1436 struct device_node *node)
1438 struct i2c_client *result;
1439 struct i2c_board_info info = {};
1440 struct dev_archdata dev_ad = {};
1441 const __be32 *addr_be;
1445 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1447 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1448 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1450 return ERR_PTR(-EINVAL);
1453 addr_be = of_get_property(node, "reg", &len);
1454 if (!addr_be || (len < sizeof(*addr_be))) {
1455 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1457 return ERR_PTR(-EINVAL);
1460 addr = be32_to_cpup(addr_be);
1461 if (addr & I2C_TEN_BIT_ADDRESS) {
1462 addr &= ~I2C_TEN_BIT_ADDRESS;
1463 info.flags |= I2C_CLIENT_TEN;
1466 if (addr & I2C_OWN_SLAVE_ADDRESS) {
1467 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1468 info.flags |= I2C_CLIENT_SLAVE;
1471 if (i2c_check_addr_validity(addr, info.flags)) {
1472 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1473 info.addr, node->full_name);
1474 return ERR_PTR(-EINVAL);
1478 info.of_node = of_node_get(node);
1479 info.archdata = &dev_ad;
1481 if (of_get_property(node, "wakeup-source", NULL))
1482 info.flags |= I2C_CLIENT_WAKE;
1484 result = i2c_new_device(adap, &info);
1485 if (result == NULL) {
1486 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1489 return ERR_PTR(-EINVAL);
1494 static void of_i2c_register_devices(struct i2c_adapter *adap)
1496 struct device_node *node;
1498 /* Only register child devices if the adapter has a node pointer set */
1499 if (!adap->dev.of_node)
1502 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1504 for_each_available_child_of_node(adap->dev.of_node, node) {
1505 if (of_node_test_and_set_flag(node, OF_POPULATED))
1507 of_i2c_register_device(adap, node);
1511 static int of_dev_node_match(struct device *dev, void *data)
1513 return dev->of_node == data;
1516 /* must call put_device() when done with returned i2c_client device */
1517 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1520 struct i2c_client *client;
1522 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1526 client = i2c_verify_client(dev);
1532 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1534 /* must call put_device() when done with returned i2c_adapter device */
1535 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1538 struct i2c_adapter *adapter;
1540 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1544 adapter = i2c_verify_adapter(dev);
1550 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1552 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1553 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1555 struct i2c_adapter *adapter;
1557 adapter = of_find_i2c_adapter_by_node(node);
1561 if (!try_module_get(adapter->owner)) {
1562 put_device(&adapter->dev);
1568 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1570 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1571 #endif /* CONFIG_OF */
1573 static int i2c_do_add_adapter(struct i2c_driver *driver,
1574 struct i2c_adapter *adap)
1576 /* Detect supported devices on that bus, and instantiate them */
1577 i2c_detect(adap, driver);
1579 /* Let legacy drivers scan this bus for matching devices */
1580 if (driver->attach_adapter) {
1581 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1582 driver->driver.name);
1583 dev_warn(&adap->dev, "Please use another way to instantiate "
1584 "your i2c_client\n");
1585 /* We ignore the return code; if it fails, too bad */
1586 driver->attach_adapter(adap);
1591 static int __process_new_adapter(struct device_driver *d, void *data)
1593 return i2c_do_add_adapter(to_i2c_driver(d), data);
1596 static int i2c_register_adapter(struct i2c_adapter *adap)
1600 /* Can't register until after driver model init */
1601 if (WARN_ON(!is_registered)) {
1607 if (WARN(!adap->name[0], "i2c adapter has no name"))
1611 pr_err("i2c-core: adapter '%s': no algo supplied!\n", adap->name);
1615 if (!adap->lock_bus) {
1616 adap->lock_bus = i2c_adapter_lock_bus;
1617 adap->trylock_bus = i2c_adapter_trylock_bus;
1618 adap->unlock_bus = i2c_adapter_unlock_bus;
1621 rt_mutex_init(&adap->bus_lock);
1622 rt_mutex_init(&adap->mux_lock);
1623 mutex_init(&adap->userspace_clients_lock);
1624 INIT_LIST_HEAD(&adap->userspace_clients);
1626 /* Set default timeout to 1 second if not already set */
1627 if (adap->timeout == 0)
1630 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1631 adap->dev.bus = &i2c_bus_type;
1632 adap->dev.type = &i2c_adapter_type;
1633 res = device_register(&adap->dev);
1635 pr_err("i2c-core: adapter '%s': can't register device (%d)\n",
1640 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1642 pm_runtime_no_callbacks(&adap->dev);
1643 pm_suspend_ignore_children(&adap->dev, true);
1644 pm_runtime_enable(&adap->dev);
1646 #ifdef CONFIG_I2C_COMPAT
1647 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1650 dev_warn(&adap->dev,
1651 "Failed to create compatibility class link\n");
1654 i2c_init_recovery(adap);
1656 /* create pre-declared device nodes */
1657 of_i2c_register_devices(adap);
1658 acpi_i2c_register_devices(adap);
1659 acpi_i2c_install_space_handler(adap);
1661 if (adap->nr < __i2c_first_dynamic_bus_num)
1662 i2c_scan_static_board_info(adap);
1664 /* Notify drivers */
1665 mutex_lock(&core_lock);
1666 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1667 mutex_unlock(&core_lock);
1672 mutex_lock(&core_lock);
1673 idr_remove(&i2c_adapter_idr, adap->nr);
1674 mutex_unlock(&core_lock);
1679 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1680 * @adap: the adapter to register (with adap->nr initialized)
1681 * Context: can sleep
1683 * See i2c_add_numbered_adapter() for details.
1685 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1689 mutex_lock(&core_lock);
1690 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1692 mutex_unlock(&core_lock);
1694 return id == -ENOSPC ? -EBUSY : id;
1696 return i2c_register_adapter(adap);
1700 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1701 * @adapter: the adapter to add
1702 * Context: can sleep
1704 * This routine is used to declare an I2C adapter when its bus number
1705 * doesn't matter or when its bus number is specified by an dt alias.
1706 * Examples of bases when the bus number doesn't matter: I2C adapters
1707 * dynamically added by USB links or PCI plugin cards.
1709 * When this returns zero, a new bus number was allocated and stored
1710 * in adap->nr, and the specified adapter became available for clients.
1711 * Otherwise, a negative errno value is returned.
1713 int i2c_add_adapter(struct i2c_adapter *adapter)
1715 struct device *dev = &adapter->dev;
1719 id = of_alias_get_id(dev->of_node, "i2c");
1722 return __i2c_add_numbered_adapter(adapter);
1726 mutex_lock(&core_lock);
1727 id = idr_alloc(&i2c_adapter_idr, adapter,
1728 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1729 mutex_unlock(&core_lock);
1735 return i2c_register_adapter(adapter);
1737 EXPORT_SYMBOL(i2c_add_adapter);
1740 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1741 * @adap: the adapter to register (with adap->nr initialized)
1742 * Context: can sleep
1744 * This routine is used to declare an I2C adapter when its bus number
1745 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1746 * or otherwise built in to the system's mainboard, and where i2c_board_info
1747 * is used to properly configure I2C devices.
1749 * If the requested bus number is set to -1, then this function will behave
1750 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1752 * If no devices have pre-been declared for this bus, then be sure to
1753 * register the adapter before any dynamically allocated ones. Otherwise
1754 * the required bus ID may not be available.
1756 * When this returns zero, the specified adapter became available for
1757 * clients using the bus number provided in adap->nr. Also, the table
1758 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1759 * and the appropriate driver model device nodes are created. Otherwise, a
1760 * negative errno value is returned.
1762 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1764 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1765 return i2c_add_adapter(adap);
1767 return __i2c_add_numbered_adapter(adap);
1769 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1771 static void i2c_do_del_adapter(struct i2c_driver *driver,
1772 struct i2c_adapter *adapter)
1774 struct i2c_client *client, *_n;
1776 /* Remove the devices we created ourselves as the result of hardware
1777 * probing (using a driver's detect method) */
1778 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1779 if (client->adapter == adapter) {
1780 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1781 client->name, client->addr);
1782 list_del(&client->detected);
1783 i2c_unregister_device(client);
1788 static int __unregister_client(struct device *dev, void *dummy)
1790 struct i2c_client *client = i2c_verify_client(dev);
1791 if (client && strcmp(client->name, "dummy"))
1792 i2c_unregister_device(client);
1796 static int __unregister_dummy(struct device *dev, void *dummy)
1798 struct i2c_client *client = i2c_verify_client(dev);
1800 i2c_unregister_device(client);
1804 static int __process_removed_adapter(struct device_driver *d, void *data)
1806 i2c_do_del_adapter(to_i2c_driver(d), data);
1811 * i2c_del_adapter - unregister I2C adapter
1812 * @adap: the adapter being unregistered
1813 * Context: can sleep
1815 * This unregisters an I2C adapter which was previously registered
1816 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1818 void i2c_del_adapter(struct i2c_adapter *adap)
1820 struct i2c_adapter *found;
1821 struct i2c_client *client, *next;
1823 /* First make sure that this adapter was ever added */
1824 mutex_lock(&core_lock);
1825 found = idr_find(&i2c_adapter_idr, adap->nr);
1826 mutex_unlock(&core_lock);
1827 if (found != adap) {
1828 pr_debug("i2c-core: attempting to delete unregistered "
1829 "adapter [%s]\n", adap->name);
1833 acpi_i2c_remove_space_handler(adap);
1834 /* Tell drivers about this removal */
1835 mutex_lock(&core_lock);
1836 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1837 __process_removed_adapter);
1838 mutex_unlock(&core_lock);
1840 /* Remove devices instantiated from sysfs */
1841 mutex_lock_nested(&adap->userspace_clients_lock,
1842 i2c_adapter_depth(adap));
1843 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1845 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1847 list_del(&client->detected);
1848 i2c_unregister_device(client);
1850 mutex_unlock(&adap->userspace_clients_lock);
1852 /* Detach any active clients. This can't fail, thus we do not
1853 * check the returned value. This is a two-pass process, because
1854 * we can't remove the dummy devices during the first pass: they
1855 * could have been instantiated by real devices wishing to clean
1856 * them up properly, so we give them a chance to do that first. */
1857 device_for_each_child(&adap->dev, NULL, __unregister_client);
1858 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1860 #ifdef CONFIG_I2C_COMPAT
1861 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1865 /* device name is gone after device_unregister */
1866 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1868 pm_runtime_disable(&adap->dev);
1870 /* wait until all references to the device are gone
1872 * FIXME: This is old code and should ideally be replaced by an
1873 * alternative which results in decoupling the lifetime of the struct
1874 * device from the i2c_adapter, like spi or netdev do. Any solution
1875 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
1877 init_completion(&adap->dev_released);
1878 device_unregister(&adap->dev);
1879 wait_for_completion(&adap->dev_released);
1882 mutex_lock(&core_lock);
1883 idr_remove(&i2c_adapter_idr, adap->nr);
1884 mutex_unlock(&core_lock);
1886 /* Clear the device structure in case this adapter is ever going to be
1888 memset(&adap->dev, 0, sizeof(adap->dev));
1890 EXPORT_SYMBOL(i2c_del_adapter);
1893 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
1894 * @dev: The device to scan for I2C timing properties
1895 * @t: the i2c_timings struct to be filled with values
1896 * @use_defaults: bool to use sane defaults derived from the I2C specification
1897 * when properties are not found, otherwise use 0
1899 * Scan the device for the generic I2C properties describing timing parameters
1900 * for the signal and fill the given struct with the results. If a property was
1901 * not found and use_defaults was true, then maximum timings are assumed which
1902 * are derived from the I2C specification. If use_defaults is not used, the
1903 * results will be 0, so drivers can apply their own defaults later. The latter
1904 * is mainly intended for avoiding regressions of existing drivers which want
1905 * to switch to this function. New drivers almost always should use the defaults.
1908 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
1912 memset(t, 0, sizeof(*t));
1914 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
1915 if (ret && use_defaults)
1916 t->bus_freq_hz = 100000;
1918 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
1919 if (ret && use_defaults) {
1920 if (t->bus_freq_hz <= 100000)
1921 t->scl_rise_ns = 1000;
1922 else if (t->bus_freq_hz <= 400000)
1923 t->scl_rise_ns = 300;
1925 t->scl_rise_ns = 120;
1928 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
1929 if (ret && use_defaults) {
1930 if (t->bus_freq_hz <= 400000)
1931 t->scl_fall_ns = 300;
1933 t->scl_fall_ns = 120;
1936 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
1938 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
1939 if (ret && use_defaults)
1940 t->sda_fall_ns = t->scl_fall_ns;
1942 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
1944 /* ------------------------------------------------------------------------- */
1946 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1950 mutex_lock(&core_lock);
1951 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1952 mutex_unlock(&core_lock);
1956 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1958 static int __process_new_driver(struct device *dev, void *data)
1960 if (dev->type != &i2c_adapter_type)
1962 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1966 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1967 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1970 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1974 /* Can't register until after driver model init */
1975 if (WARN_ON(!is_registered))
1978 /* add the driver to the list of i2c drivers in the driver core */
1979 driver->driver.owner = owner;
1980 driver->driver.bus = &i2c_bus_type;
1982 /* When registration returns, the driver core
1983 * will have called probe() for all matching-but-unbound devices.
1985 res = driver_register(&driver->driver);
1989 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1991 INIT_LIST_HEAD(&driver->clients);
1992 /* Walk the adapters that are already present */
1993 i2c_for_each_dev(driver, __process_new_driver);
1997 EXPORT_SYMBOL(i2c_register_driver);
1999 static int __process_removed_driver(struct device *dev, void *data)
2001 if (dev->type == &i2c_adapter_type)
2002 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2007 * i2c_del_driver - unregister I2C driver
2008 * @driver: the driver being unregistered
2009 * Context: can sleep
2011 void i2c_del_driver(struct i2c_driver *driver)
2013 i2c_for_each_dev(driver, __process_removed_driver);
2015 driver_unregister(&driver->driver);
2016 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
2018 EXPORT_SYMBOL(i2c_del_driver);
2020 /* ------------------------------------------------------------------------- */
2023 * i2c_use_client - increments the reference count of the i2c client structure
2024 * @client: the client being referenced
2026 * Each live reference to a client should be refcounted. The driver model does
2027 * that automatically as part of driver binding, so that most drivers don't
2028 * need to do this explicitly: they hold a reference until they're unbound
2031 * A pointer to the client with the incremented reference counter is returned.
2033 struct i2c_client *i2c_use_client(struct i2c_client *client)
2035 if (client && get_device(&client->dev))
2039 EXPORT_SYMBOL(i2c_use_client);
2042 * i2c_release_client - release a use of the i2c client structure
2043 * @client: the client being no longer referenced
2045 * Must be called when a user of a client is finished with it.
2047 void i2c_release_client(struct i2c_client *client)
2050 put_device(&client->dev);
2052 EXPORT_SYMBOL(i2c_release_client);
2054 struct i2c_cmd_arg {
2059 static int i2c_cmd(struct device *dev, void *_arg)
2061 struct i2c_client *client = i2c_verify_client(dev);
2062 struct i2c_cmd_arg *arg = _arg;
2063 struct i2c_driver *driver;
2065 if (!client || !client->dev.driver)
2068 driver = to_i2c_driver(client->dev.driver);
2069 if (driver->command)
2070 driver->command(client, arg->cmd, arg->arg);
2074 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2076 struct i2c_cmd_arg cmd_arg;
2080 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2082 EXPORT_SYMBOL(i2c_clients_command);
2084 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2085 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2088 struct of_reconfig_data *rd = arg;
2089 struct i2c_adapter *adap;
2090 struct i2c_client *client;
2092 switch (of_reconfig_get_state_change(action, rd)) {
2093 case OF_RECONFIG_CHANGE_ADD:
2094 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2096 return NOTIFY_OK; /* not for us */
2098 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2099 put_device(&adap->dev);
2103 client = of_i2c_register_device(adap, rd->dn);
2104 put_device(&adap->dev);
2106 if (IS_ERR(client)) {
2107 pr_err("%s: failed to create for '%s'\n",
2108 __func__, rd->dn->full_name);
2109 return notifier_from_errno(PTR_ERR(client));
2112 case OF_RECONFIG_CHANGE_REMOVE:
2113 /* already depopulated? */
2114 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2117 /* find our device by node */
2118 client = of_find_i2c_device_by_node(rd->dn);
2120 return NOTIFY_OK; /* no? not meant for us */
2122 /* unregister takes one ref away */
2123 i2c_unregister_device(client);
2125 /* and put the reference of the find */
2126 put_device(&client->dev);
2132 static struct notifier_block i2c_of_notifier = {
2133 .notifier_call = of_i2c_notify,
2136 extern struct notifier_block i2c_of_notifier;
2137 #endif /* CONFIG_OF_DYNAMIC */
2139 static int __init i2c_init(void)
2143 retval = of_alias_get_highest_id("i2c");
2145 down_write(&__i2c_board_lock);
2146 if (retval >= __i2c_first_dynamic_bus_num)
2147 __i2c_first_dynamic_bus_num = retval + 1;
2148 up_write(&__i2c_board_lock);
2150 retval = bus_register(&i2c_bus_type);
2154 is_registered = true;
2156 #ifdef CONFIG_I2C_COMPAT
2157 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2158 if (!i2c_adapter_compat_class) {
2163 retval = i2c_add_driver(&dummy_driver);
2167 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2168 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2173 #ifdef CONFIG_I2C_COMPAT
2174 class_compat_unregister(i2c_adapter_compat_class);
2177 is_registered = false;
2178 bus_unregister(&i2c_bus_type);
2182 static void __exit i2c_exit(void)
2184 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2185 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2186 i2c_del_driver(&dummy_driver);
2187 #ifdef CONFIG_I2C_COMPAT
2188 class_compat_unregister(i2c_adapter_compat_class);
2190 bus_unregister(&i2c_bus_type);
2191 tracepoint_synchronize_unregister();
2194 /* We must initialize early, because some subsystems register i2c drivers
2195 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2197 postcore_initcall(i2c_init);
2198 module_exit(i2c_exit);
2200 /* ----------------------------------------------------
2201 * the functional interface to the i2c busses.
2202 * ----------------------------------------------------
2205 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2206 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2208 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2210 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2211 err_msg, msg->addr, msg->len,
2212 msg->flags & I2C_M_RD ? "read" : "write");
2216 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2218 const struct i2c_adapter_quirks *q = adap->quirks;
2219 int max_num = q->max_num_msgs, i;
2220 bool do_len_check = true;
2222 if (q->flags & I2C_AQ_COMB) {
2225 /* special checks for combined messages */
2227 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2228 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2230 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2231 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2233 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2234 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2236 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2237 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2239 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2240 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2242 do_len_check = false;
2246 if (i2c_quirk_exceeded(num, max_num))
2247 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2249 for (i = 0; i < num; i++) {
2250 u16 len = msgs[i].len;
2252 if (msgs[i].flags & I2C_M_RD) {
2253 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2254 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2256 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2257 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2265 * __i2c_transfer - unlocked flavor of i2c_transfer
2266 * @adap: Handle to I2C bus
2267 * @msgs: One or more messages to execute before STOP is issued to
2268 * terminate the operation; each message begins with a START.
2269 * @num: Number of messages to be executed.
2271 * Returns negative errno, else the number of messages executed.
2273 * Adapter lock must be held when calling this function. No debug logging
2274 * takes place. adap->algo->master_xfer existence isn't checked.
2276 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2278 unsigned long orig_jiffies;
2281 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2284 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2285 * enabled. This is an efficient way of keeping the for-loop from
2286 * being executed when not needed.
2288 if (static_key_false(&i2c_trace_msg)) {
2290 for (i = 0; i < num; i++)
2291 if (msgs[i].flags & I2C_M_RD)
2292 trace_i2c_read(adap, &msgs[i], i);
2294 trace_i2c_write(adap, &msgs[i], i);
2297 /* Retry automatically on arbitration loss */
2298 orig_jiffies = jiffies;
2299 for (ret = 0, try = 0; try <= adap->retries; try++) {
2300 ret = adap->algo->master_xfer(adap, msgs, num);
2303 if (time_after(jiffies, orig_jiffies + adap->timeout))
2307 if (static_key_false(&i2c_trace_msg)) {
2309 for (i = 0; i < ret; i++)
2310 if (msgs[i].flags & I2C_M_RD)
2311 trace_i2c_reply(adap, &msgs[i], i);
2312 trace_i2c_result(adap, i, ret);
2317 EXPORT_SYMBOL(__i2c_transfer);
2320 * i2c_transfer - execute a single or combined I2C message
2321 * @adap: Handle to I2C bus
2322 * @msgs: One or more messages to execute before STOP is issued to
2323 * terminate the operation; each message begins with a START.
2324 * @num: Number of messages to be executed.
2326 * Returns negative errno, else the number of messages executed.
2328 * Note that there is no requirement that each message be sent to
2329 * the same slave address, although that is the most common model.
2331 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2335 /* REVISIT the fault reporting model here is weak:
2337 * - When we get an error after receiving N bytes from a slave,
2338 * there is no way to report "N".
2340 * - When we get a NAK after transmitting N bytes to a slave,
2341 * there is no way to report "N" ... or to let the master
2342 * continue executing the rest of this combined message, if
2343 * that's the appropriate response.
2345 * - When for example "num" is two and we successfully complete
2346 * the first message but get an error part way through the
2347 * second, it's unclear whether that should be reported as
2348 * one (discarding status on the second message) or errno
2349 * (discarding status on the first one).
2352 if (adap->algo->master_xfer) {
2354 for (ret = 0; ret < num; ret++) {
2355 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2356 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2357 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2358 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2362 if (in_atomic() || irqs_disabled()) {
2363 ret = adap->trylock_bus(adap, I2C_LOCK_SEGMENT);
2365 /* I2C activity is ongoing. */
2368 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2371 ret = __i2c_transfer(adap, msgs, num);
2372 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2376 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2380 EXPORT_SYMBOL(i2c_transfer);
2383 * i2c_master_send - issue a single I2C message in master transmit mode
2384 * @client: Handle to slave device
2385 * @buf: Data that will be written to the slave
2386 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2388 * Returns negative errno, or else the number of bytes written.
2390 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2393 struct i2c_adapter *adap = client->adapter;
2396 msg.addr = client->addr;
2397 msg.flags = client->flags & I2C_M_TEN;
2399 msg.buf = (char *)buf;
2401 ret = i2c_transfer(adap, &msg, 1);
2404 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2405 * transmitted, else error code.
2407 return (ret == 1) ? count : ret;
2409 EXPORT_SYMBOL(i2c_master_send);
2412 * i2c_master_recv - issue a single I2C message in master receive mode
2413 * @client: Handle to slave device
2414 * @buf: Where to store data read from slave
2415 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2417 * Returns negative errno, or else the number of bytes read.
2419 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2421 struct i2c_adapter *adap = client->adapter;
2425 msg.addr = client->addr;
2426 msg.flags = client->flags & I2C_M_TEN;
2427 msg.flags |= I2C_M_RD;
2431 ret = i2c_transfer(adap, &msg, 1);
2434 * If everything went ok (i.e. 1 msg received), return #bytes received,
2437 return (ret == 1) ? count : ret;
2439 EXPORT_SYMBOL(i2c_master_recv);
2441 /* ----------------------------------------------------
2442 * the i2c address scanning function
2443 * Will not work for 10-bit addresses!
2444 * ----------------------------------------------------
2448 * Legacy default probe function, mostly relevant for SMBus. The default
2449 * probe method is a quick write, but it is known to corrupt the 24RF08
2450 * EEPROMs due to a state machine bug, and could also irreversibly
2451 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2452 * we use a short byte read instead. Also, some bus drivers don't implement
2453 * quick write, so we fallback to a byte read in that case too.
2454 * On x86, there is another special case for FSC hardware monitoring chips,
2455 * which want regular byte reads (address 0x73.) Fortunately, these are the
2456 * only known chips using this I2C address on PC hardware.
2457 * Returns 1 if probe succeeded, 0 if not.
2459 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2462 union i2c_smbus_data dummy;
2465 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2466 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2467 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2468 I2C_SMBUS_BYTE_DATA, &dummy);
2471 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2472 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2473 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2474 I2C_SMBUS_QUICK, NULL);
2475 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2476 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2477 I2C_SMBUS_BYTE, &dummy);
2479 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2487 static int i2c_detect_address(struct i2c_client *temp_client,
2488 struct i2c_driver *driver)
2490 struct i2c_board_info info;
2491 struct i2c_adapter *adapter = temp_client->adapter;
2492 int addr = temp_client->addr;
2495 /* Make sure the address is valid */
2496 err = i2c_check_7bit_addr_validity_strict(addr);
2498 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2503 /* Skip if already in use (7 bit, no need to encode flags) */
2504 if (i2c_check_addr_busy(adapter, addr))
2507 /* Make sure there is something at this address */
2508 if (!i2c_default_probe(adapter, addr))
2511 /* Finally call the custom detection function */
2512 memset(&info, 0, sizeof(struct i2c_board_info));
2514 err = driver->detect(temp_client, &info);
2516 /* -ENODEV is returned if the detection fails. We catch it
2517 here as this isn't an error. */
2518 return err == -ENODEV ? 0 : err;
2521 /* Consistency check */
2522 if (info.type[0] == '\0') {
2523 dev_err(&adapter->dev, "%s detection function provided "
2524 "no name for 0x%x\n", driver->driver.name,
2527 struct i2c_client *client;
2529 /* Detection succeeded, instantiate the device */
2530 if (adapter->class & I2C_CLASS_DEPRECATED)
2531 dev_warn(&adapter->dev,
2532 "This adapter will soon drop class based instantiation of devices. "
2533 "Please make sure client 0x%02x gets instantiated by other means. "
2534 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2537 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2538 info.type, info.addr);
2539 client = i2c_new_device(adapter, &info);
2541 list_add_tail(&client->detected, &driver->clients);
2543 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2544 info.type, info.addr);
2549 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2551 const unsigned short *address_list;
2552 struct i2c_client *temp_client;
2554 int adap_id = i2c_adapter_id(adapter);
2556 address_list = driver->address_list;
2557 if (!driver->detect || !address_list)
2560 /* Warn that the adapter lost class based instantiation */
2561 if (adapter->class == I2C_CLASS_DEPRECATED) {
2562 dev_dbg(&adapter->dev,
2563 "This adapter dropped support for I2C classes and "
2564 "won't auto-detect %s devices anymore. If you need it, check "
2565 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2566 driver->driver.name);
2570 /* Stop here if the classes do not match */
2571 if (!(adapter->class & driver->class))
2574 /* Set up a temporary client to help detect callback */
2575 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2578 temp_client->adapter = adapter;
2580 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2581 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2582 "addr 0x%02x\n", adap_id, address_list[i]);
2583 temp_client->addr = address_list[i];
2584 err = i2c_detect_address(temp_client, driver);
2593 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2595 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2596 I2C_SMBUS_QUICK, NULL) >= 0;
2598 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2601 i2c_new_probed_device(struct i2c_adapter *adap,
2602 struct i2c_board_info *info,
2603 unsigned short const *addr_list,
2604 int (*probe)(struct i2c_adapter *, unsigned short addr))
2609 probe = i2c_default_probe;
2611 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2612 /* Check address validity */
2613 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2614 dev_warn(&adap->dev, "Invalid 7-bit address "
2615 "0x%02x\n", addr_list[i]);
2619 /* Check address availability (7 bit, no need to encode flags) */
2620 if (i2c_check_addr_busy(adap, addr_list[i])) {
2621 dev_dbg(&adap->dev, "Address 0x%02x already in "
2622 "use, not probing\n", addr_list[i]);
2626 /* Test address responsiveness */
2627 if (probe(adap, addr_list[i]))
2631 if (addr_list[i] == I2C_CLIENT_END) {
2632 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2636 info->addr = addr_list[i];
2637 return i2c_new_device(adap, info);
2639 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2641 struct i2c_adapter *i2c_get_adapter(int nr)
2643 struct i2c_adapter *adapter;
2645 mutex_lock(&core_lock);
2646 adapter = idr_find(&i2c_adapter_idr, nr);
2650 if (try_module_get(adapter->owner))
2651 get_device(&adapter->dev);
2656 mutex_unlock(&core_lock);
2659 EXPORT_SYMBOL(i2c_get_adapter);
2661 void i2c_put_adapter(struct i2c_adapter *adap)
2666 put_device(&adap->dev);
2667 module_put(adap->owner);
2669 EXPORT_SYMBOL(i2c_put_adapter);
2671 /* The SMBus parts */
2673 #define POLY (0x1070U << 3)
2674 static u8 crc8(u16 data)
2678 for (i = 0; i < 8; i++) {
2683 return (u8)(data >> 8);
2686 /* Incremental CRC8 over count bytes in the array pointed to by p */
2687 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2691 for (i = 0; i < count; i++)
2692 crc = crc8((crc ^ p[i]) << 8);
2696 /* Assume a 7-bit address, which is reasonable for SMBus */
2697 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2699 /* The address will be sent first */
2700 u8 addr = i2c_8bit_addr_from_msg(msg);
2701 pec = i2c_smbus_pec(pec, &addr, 1);
2703 /* The data buffer follows */
2704 return i2c_smbus_pec(pec, msg->buf, msg->len);
2707 /* Used for write only transactions */
2708 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2710 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2714 /* Return <0 on CRC error
2715 If there was a write before this read (most cases) we need to take the
2716 partial CRC from the write part into account.
2717 Note that this function does modify the message (we need to decrease the
2718 message length to hide the CRC byte from the caller). */
2719 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2721 u8 rpec = msg->buf[--msg->len];
2722 cpec = i2c_smbus_msg_pec(cpec, msg);
2725 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2733 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2734 * @client: Handle to slave device
2736 * This executes the SMBus "receive byte" protocol, returning negative errno
2737 * else the byte received from the device.
2739 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2741 union i2c_smbus_data data;
2744 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2746 I2C_SMBUS_BYTE, &data);
2747 return (status < 0) ? status : data.byte;
2749 EXPORT_SYMBOL(i2c_smbus_read_byte);
2752 * i2c_smbus_write_byte - SMBus "send byte" protocol
2753 * @client: Handle to slave device
2754 * @value: Byte to be sent
2756 * This executes the SMBus "send byte" protocol, returning negative errno
2757 * else zero on success.
2759 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2761 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2762 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2764 EXPORT_SYMBOL(i2c_smbus_write_byte);
2767 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2768 * @client: Handle to slave device
2769 * @command: Byte interpreted by slave
2771 * This executes the SMBus "read byte" protocol, returning negative errno
2772 * else a data byte received from the device.
2774 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2776 union i2c_smbus_data data;
2779 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2780 I2C_SMBUS_READ, command,
2781 I2C_SMBUS_BYTE_DATA, &data);
2782 return (status < 0) ? status : data.byte;
2784 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2787 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2788 * @client: Handle to slave device
2789 * @command: Byte interpreted by slave
2790 * @value: Byte being written
2792 * This executes the SMBus "write byte" protocol, returning negative errno
2793 * else zero on success.
2795 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2798 union i2c_smbus_data data;
2800 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2801 I2C_SMBUS_WRITE, command,
2802 I2C_SMBUS_BYTE_DATA, &data);
2804 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2807 * i2c_smbus_read_word_data - SMBus "read word" protocol
2808 * @client: Handle to slave device
2809 * @command: Byte interpreted by slave
2811 * This executes the SMBus "read word" protocol, returning negative errno
2812 * else a 16-bit unsigned "word" received from the device.
2814 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2816 union i2c_smbus_data data;
2819 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2820 I2C_SMBUS_READ, command,
2821 I2C_SMBUS_WORD_DATA, &data);
2822 return (status < 0) ? status : data.word;
2824 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2827 * i2c_smbus_write_word_data - SMBus "write word" protocol
2828 * @client: Handle to slave device
2829 * @command: Byte interpreted by slave
2830 * @value: 16-bit "word" being written
2832 * This executes the SMBus "write word" protocol, returning negative errno
2833 * else zero on success.
2835 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2838 union i2c_smbus_data data;
2840 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2841 I2C_SMBUS_WRITE, command,
2842 I2C_SMBUS_WORD_DATA, &data);
2844 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2847 * i2c_smbus_read_block_data - SMBus "block read" protocol
2848 * @client: Handle to slave device
2849 * @command: Byte interpreted by slave
2850 * @values: Byte array into which data will be read; big enough to hold
2851 * the data returned by the slave. SMBus allows at most 32 bytes.
2853 * This executes the SMBus "block read" protocol, returning negative errno
2854 * else the number of data bytes in the slave's response.
2856 * Note that using this function requires that the client's adapter support
2857 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2858 * support this; its emulation through I2C messaging relies on a specific
2859 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2861 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2864 union i2c_smbus_data data;
2867 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2868 I2C_SMBUS_READ, command,
2869 I2C_SMBUS_BLOCK_DATA, &data);
2873 memcpy(values, &data.block[1], data.block[0]);
2874 return data.block[0];
2876 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2879 * i2c_smbus_write_block_data - SMBus "block write" protocol
2880 * @client: Handle to slave device
2881 * @command: Byte interpreted by slave
2882 * @length: Size of data block; SMBus allows at most 32 bytes
2883 * @values: Byte array which will be written.
2885 * This executes the SMBus "block write" protocol, returning negative errno
2886 * else zero on success.
2888 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2889 u8 length, const u8 *values)
2891 union i2c_smbus_data data;
2893 if (length > I2C_SMBUS_BLOCK_MAX)
2894 length = I2C_SMBUS_BLOCK_MAX;
2895 data.block[0] = length;
2896 memcpy(&data.block[1], values, length);
2897 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2898 I2C_SMBUS_WRITE, command,
2899 I2C_SMBUS_BLOCK_DATA, &data);
2901 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2903 /* Returns the number of read bytes */
2904 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2905 u8 length, u8 *values)
2907 union i2c_smbus_data data;
2910 if (length > I2C_SMBUS_BLOCK_MAX)
2911 length = I2C_SMBUS_BLOCK_MAX;
2912 data.block[0] = length;
2913 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2914 I2C_SMBUS_READ, command,
2915 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2919 memcpy(values, &data.block[1], data.block[0]);
2920 return data.block[0];
2922 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2924 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2925 u8 length, const u8 *values)
2927 union i2c_smbus_data data;
2929 if (length > I2C_SMBUS_BLOCK_MAX)
2930 length = I2C_SMBUS_BLOCK_MAX;
2931 data.block[0] = length;
2932 memcpy(data.block + 1, values, length);
2933 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2934 I2C_SMBUS_WRITE, command,
2935 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2937 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2939 /* Simulate a SMBus command using the i2c protocol
2940 No checking of parameters is done! */
2941 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2942 unsigned short flags,
2943 char read_write, u8 command, int size,
2944 union i2c_smbus_data *data)
2946 /* So we need to generate a series of msgs. In the case of writing, we
2947 need to use only one message; when reading, we need two. We initialize
2948 most things with sane defaults, to keep the code below somewhat
2950 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2951 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2952 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2956 struct i2c_msg msg[2] = {
2964 .flags = flags | I2C_M_RD,
2970 msgbuf0[0] = command;
2972 case I2C_SMBUS_QUICK:
2974 /* Special case: The read/write field is used as data */
2975 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2979 case I2C_SMBUS_BYTE:
2980 if (read_write == I2C_SMBUS_READ) {
2981 /* Special case: only a read! */
2982 msg[0].flags = I2C_M_RD | flags;
2986 case I2C_SMBUS_BYTE_DATA:
2987 if (read_write == I2C_SMBUS_READ)
2991 msgbuf0[1] = data->byte;
2994 case I2C_SMBUS_WORD_DATA:
2995 if (read_write == I2C_SMBUS_READ)
2999 msgbuf0[1] = data->word & 0xff;
3000 msgbuf0[2] = data->word >> 8;
3003 case I2C_SMBUS_PROC_CALL:
3004 num = 2; /* Special case */
3005 read_write = I2C_SMBUS_READ;
3008 msgbuf0[1] = data->word & 0xff;
3009 msgbuf0[2] = data->word >> 8;
3011 case I2C_SMBUS_BLOCK_DATA:
3012 if (read_write == I2C_SMBUS_READ) {
3013 msg[1].flags |= I2C_M_RECV_LEN;
3014 msg[1].len = 1; /* block length will be added by
3015 the underlying bus driver */
3017 msg[0].len = data->block[0] + 2;
3018 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3019 dev_err(&adapter->dev,
3020 "Invalid block write size %d\n",
3024 for (i = 1; i < msg[0].len; i++)
3025 msgbuf0[i] = data->block[i-1];
3028 case I2C_SMBUS_BLOCK_PROC_CALL:
3029 num = 2; /* Another special case */
3030 read_write = I2C_SMBUS_READ;
3031 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3032 dev_err(&adapter->dev,
3033 "Invalid block write size %d\n",
3037 msg[0].len = data->block[0] + 2;
3038 for (i = 1; i < msg[0].len; i++)
3039 msgbuf0[i] = data->block[i-1];
3040 msg[1].flags |= I2C_M_RECV_LEN;
3041 msg[1].len = 1; /* block length will be added by
3042 the underlying bus driver */
3044 case I2C_SMBUS_I2C_BLOCK_DATA:
3045 if (read_write == I2C_SMBUS_READ) {
3046 msg[1].len = data->block[0];
3048 msg[0].len = data->block[0] + 1;
3049 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3050 dev_err(&adapter->dev,
3051 "Invalid block write size %d\n",
3055 for (i = 1; i <= data->block[0]; i++)
3056 msgbuf0[i] = data->block[i];
3060 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3064 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3065 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3067 /* Compute PEC if first message is a write */
3068 if (!(msg[0].flags & I2C_M_RD)) {
3069 if (num == 1) /* Write only */
3070 i2c_smbus_add_pec(&msg[0]);
3071 else /* Write followed by read */
3072 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3074 /* Ask for PEC if last message is a read */
3075 if (msg[num-1].flags & I2C_M_RD)
3079 status = i2c_transfer(adapter, msg, num);
3083 /* Check PEC if last message is a read */
3084 if (i && (msg[num-1].flags & I2C_M_RD)) {
3085 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3090 if (read_write == I2C_SMBUS_READ)
3092 case I2C_SMBUS_BYTE:
3093 data->byte = msgbuf0[0];
3095 case I2C_SMBUS_BYTE_DATA:
3096 data->byte = msgbuf1[0];
3098 case I2C_SMBUS_WORD_DATA:
3099 case I2C_SMBUS_PROC_CALL:
3100 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3102 case I2C_SMBUS_I2C_BLOCK_DATA:
3103 for (i = 0; i < data->block[0]; i++)
3104 data->block[i+1] = msgbuf1[i];
3106 case I2C_SMBUS_BLOCK_DATA:
3107 case I2C_SMBUS_BLOCK_PROC_CALL:
3108 for (i = 0; i < msgbuf1[0] + 1; i++)
3109 data->block[i] = msgbuf1[i];
3116 * i2c_smbus_xfer - execute SMBus protocol operations
3117 * @adapter: Handle to I2C bus
3118 * @addr: Address of SMBus slave on that bus
3119 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3120 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3121 * @command: Byte interpreted by slave, for protocols which use such bytes
3122 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3123 * @data: Data to be read or written
3125 * This executes an SMBus protocol operation, and returns a negative
3126 * errno code else zero on success.
3128 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3129 char read_write, u8 command, int protocol,
3130 union i2c_smbus_data *data)
3132 unsigned long orig_jiffies;
3136 /* If enabled, the following two tracepoints are conditional on
3137 * read_write and protocol.
3139 trace_smbus_write(adapter, addr, flags, read_write,
3140 command, protocol, data);
3141 trace_smbus_read(adapter, addr, flags, read_write,
3144 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3146 if (adapter->algo->smbus_xfer) {
3147 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3149 /* Retry automatically on arbitration loss */
3150 orig_jiffies = jiffies;
3151 for (res = 0, try = 0; try <= adapter->retries; try++) {
3152 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3153 read_write, command,
3157 if (time_after(jiffies,
3158 orig_jiffies + adapter->timeout))
3161 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3163 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3166 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3167 * implement native support for the SMBus operation.
3171 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3172 command, protocol, data);
3175 /* If enabled, the reply tracepoint is conditional on read_write. */
3176 trace_smbus_reply(adapter, addr, flags, read_write,
3177 command, protocol, data);
3178 trace_smbus_result(adapter, addr, flags, read_write,
3179 command, protocol, res);
3183 EXPORT_SYMBOL(i2c_smbus_xfer);
3186 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3187 * @client: Handle to slave device
3188 * @command: Byte interpreted by slave
3189 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3190 * @values: Byte array into which data will be read; big enough to hold
3191 * the data returned by the slave. SMBus allows at most
3192 * I2C_SMBUS_BLOCK_MAX bytes.
3194 * This executes the SMBus "block read" protocol if supported by the adapter.
3195 * If block read is not supported, it emulates it using either word or byte
3196 * read protocols depending on availability.
3198 * The addresses of the I2C slave device that are accessed with this function
3199 * must be mapped to a linear region, so that a block read will have the same
3200 * effect as a byte read. Before using this function you must double-check
3201 * if the I2C slave does support exchanging a block transfer with a byte
3204 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3205 u8 command, u8 length, u8 *values)
3210 if (length > I2C_SMBUS_BLOCK_MAX)
3211 length = I2C_SMBUS_BLOCK_MAX;
3213 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3214 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3216 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3219 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3220 while ((i + 2) <= length) {
3221 status = i2c_smbus_read_word_data(client, command + i);
3224 values[i] = status & 0xff;
3225 values[i + 1] = status >> 8;
3230 while (i < length) {
3231 status = i2c_smbus_read_byte_data(client, command + i);
3240 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3242 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3243 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3247 if (!client || !slave_cb) {
3248 WARN(1, "insufficent data\n");
3252 if (!(client->flags & I2C_CLIENT_SLAVE))
3253 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3256 if (!(client->flags & I2C_CLIENT_TEN)) {
3257 /* Enforce stricter address checking */
3258 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3260 dev_err(&client->dev, "%s: invalid address\n", __func__);
3265 if (!client->adapter->algo->reg_slave) {
3266 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3270 client->slave_cb = slave_cb;
3272 i2c_lock_adapter(client->adapter);
3273 ret = client->adapter->algo->reg_slave(client);
3274 i2c_unlock_adapter(client->adapter);
3277 client->slave_cb = NULL;
3278 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3283 EXPORT_SYMBOL_GPL(i2c_slave_register);
3285 int i2c_slave_unregister(struct i2c_client *client)
3289 if (!client->adapter->algo->unreg_slave) {
3290 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3294 i2c_lock_adapter(client->adapter);
3295 ret = client->adapter->algo->unreg_slave(client);
3296 i2c_unlock_adapter(client->adapter);
3299 client->slave_cb = NULL;
3301 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3305 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3308 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3309 MODULE_DESCRIPTION("I2C-Bus main module");
3310 MODULE_LICENSE("GPL");