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, GFP_KERNEL);
1691 mutex_unlock(&core_lock);
1692 if (WARN(id < 0, "couldn't get idr"))
1693 return id == -ENOSPC ? -EBUSY : id;
1695 return i2c_register_adapter(adap);
1699 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1700 * @adapter: the adapter to add
1701 * Context: can sleep
1703 * This routine is used to declare an I2C adapter when its bus number
1704 * doesn't matter or when its bus number is specified by an dt alias.
1705 * Examples of bases when the bus number doesn't matter: I2C adapters
1706 * dynamically added by USB links or PCI plugin cards.
1708 * When this returns zero, a new bus number was allocated and stored
1709 * in adap->nr, and the specified adapter became available for clients.
1710 * Otherwise, a negative errno value is returned.
1712 int i2c_add_adapter(struct i2c_adapter *adapter)
1714 struct device *dev = &adapter->dev;
1718 id = of_alias_get_id(dev->of_node, "i2c");
1721 return __i2c_add_numbered_adapter(adapter);
1725 mutex_lock(&core_lock);
1726 id = idr_alloc(&i2c_adapter_idr, adapter,
1727 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1728 mutex_unlock(&core_lock);
1729 if (WARN(id < 0, "couldn't get idr"))
1734 return i2c_register_adapter(adapter);
1736 EXPORT_SYMBOL(i2c_add_adapter);
1739 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1740 * @adap: the adapter to register (with adap->nr initialized)
1741 * Context: can sleep
1743 * This routine is used to declare an I2C adapter when its bus number
1744 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1745 * or otherwise built in to the system's mainboard, and where i2c_board_info
1746 * is used to properly configure I2C devices.
1748 * If the requested bus number is set to -1, then this function will behave
1749 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1751 * If no devices have pre-been declared for this bus, then be sure to
1752 * register the adapter before any dynamically allocated ones. Otherwise
1753 * the required bus ID may not be available.
1755 * When this returns zero, the specified adapter became available for
1756 * clients using the bus number provided in adap->nr. Also, the table
1757 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1758 * and the appropriate driver model device nodes are created. Otherwise, a
1759 * negative errno value is returned.
1761 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1763 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1764 return i2c_add_adapter(adap);
1766 return __i2c_add_numbered_adapter(adap);
1768 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1770 static void i2c_do_del_adapter(struct i2c_driver *driver,
1771 struct i2c_adapter *adapter)
1773 struct i2c_client *client, *_n;
1775 /* Remove the devices we created ourselves as the result of hardware
1776 * probing (using a driver's detect method) */
1777 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1778 if (client->adapter == adapter) {
1779 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1780 client->name, client->addr);
1781 list_del(&client->detected);
1782 i2c_unregister_device(client);
1787 static int __unregister_client(struct device *dev, void *dummy)
1789 struct i2c_client *client = i2c_verify_client(dev);
1790 if (client && strcmp(client->name, "dummy"))
1791 i2c_unregister_device(client);
1795 static int __unregister_dummy(struct device *dev, void *dummy)
1797 struct i2c_client *client = i2c_verify_client(dev);
1799 i2c_unregister_device(client);
1803 static int __process_removed_adapter(struct device_driver *d, void *data)
1805 i2c_do_del_adapter(to_i2c_driver(d), data);
1810 * i2c_del_adapter - unregister I2C adapter
1811 * @adap: the adapter being unregistered
1812 * Context: can sleep
1814 * This unregisters an I2C adapter which was previously registered
1815 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1817 void i2c_del_adapter(struct i2c_adapter *adap)
1819 struct i2c_adapter *found;
1820 struct i2c_client *client, *next;
1822 /* First make sure that this adapter was ever added */
1823 mutex_lock(&core_lock);
1824 found = idr_find(&i2c_adapter_idr, adap->nr);
1825 mutex_unlock(&core_lock);
1826 if (found != adap) {
1827 pr_debug("i2c-core: attempting to delete unregistered "
1828 "adapter [%s]\n", adap->name);
1832 acpi_i2c_remove_space_handler(adap);
1833 /* Tell drivers about this removal */
1834 mutex_lock(&core_lock);
1835 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1836 __process_removed_adapter);
1837 mutex_unlock(&core_lock);
1839 /* Remove devices instantiated from sysfs */
1840 mutex_lock_nested(&adap->userspace_clients_lock,
1841 i2c_adapter_depth(adap));
1842 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1844 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1846 list_del(&client->detected);
1847 i2c_unregister_device(client);
1849 mutex_unlock(&adap->userspace_clients_lock);
1851 /* Detach any active clients. This can't fail, thus we do not
1852 * check the returned value. This is a two-pass process, because
1853 * we can't remove the dummy devices during the first pass: they
1854 * could have been instantiated by real devices wishing to clean
1855 * them up properly, so we give them a chance to do that first. */
1856 device_for_each_child(&adap->dev, NULL, __unregister_client);
1857 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1859 #ifdef CONFIG_I2C_COMPAT
1860 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1864 /* device name is gone after device_unregister */
1865 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1867 pm_runtime_disable(&adap->dev);
1869 /* wait until all references to the device are gone
1871 * FIXME: This is old code and should ideally be replaced by an
1872 * alternative which results in decoupling the lifetime of the struct
1873 * device from the i2c_adapter, like spi or netdev do. Any solution
1874 * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
1876 init_completion(&adap->dev_released);
1877 device_unregister(&adap->dev);
1878 wait_for_completion(&adap->dev_released);
1881 mutex_lock(&core_lock);
1882 idr_remove(&i2c_adapter_idr, adap->nr);
1883 mutex_unlock(&core_lock);
1885 /* Clear the device structure in case this adapter is ever going to be
1887 memset(&adap->dev, 0, sizeof(adap->dev));
1889 EXPORT_SYMBOL(i2c_del_adapter);
1892 * i2c_parse_fw_timings - get I2C related timing parameters from firmware
1893 * @dev: The device to scan for I2C timing properties
1894 * @t: the i2c_timings struct to be filled with values
1895 * @use_defaults: bool to use sane defaults derived from the I2C specification
1896 * when properties are not found, otherwise use 0
1898 * Scan the device for the generic I2C properties describing timing parameters
1899 * for the signal and fill the given struct with the results. If a property was
1900 * not found and use_defaults was true, then maximum timings are assumed which
1901 * are derived from the I2C specification. If use_defaults is not used, the
1902 * results will be 0, so drivers can apply their own defaults later. The latter
1903 * is mainly intended for avoiding regressions of existing drivers which want
1904 * to switch to this function. New drivers almost always should use the defaults.
1907 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
1911 memset(t, 0, sizeof(*t));
1913 ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
1914 if (ret && use_defaults)
1915 t->bus_freq_hz = 100000;
1917 ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
1918 if (ret && use_defaults) {
1919 if (t->bus_freq_hz <= 100000)
1920 t->scl_rise_ns = 1000;
1921 else if (t->bus_freq_hz <= 400000)
1922 t->scl_rise_ns = 300;
1924 t->scl_rise_ns = 120;
1927 ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
1928 if (ret && use_defaults) {
1929 if (t->bus_freq_hz <= 400000)
1930 t->scl_fall_ns = 300;
1932 t->scl_fall_ns = 120;
1935 device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
1937 ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
1938 if (ret && use_defaults)
1939 t->sda_fall_ns = t->scl_fall_ns;
1941 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
1943 /* ------------------------------------------------------------------------- */
1945 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1949 mutex_lock(&core_lock);
1950 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1951 mutex_unlock(&core_lock);
1955 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1957 static int __process_new_driver(struct device *dev, void *data)
1959 if (dev->type != &i2c_adapter_type)
1961 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1965 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1966 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1969 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1973 /* Can't register until after driver model init */
1974 if (WARN_ON(!is_registered))
1977 /* add the driver to the list of i2c drivers in the driver core */
1978 driver->driver.owner = owner;
1979 driver->driver.bus = &i2c_bus_type;
1981 /* When registration returns, the driver core
1982 * will have called probe() for all matching-but-unbound devices.
1984 res = driver_register(&driver->driver);
1988 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1990 INIT_LIST_HEAD(&driver->clients);
1991 /* Walk the adapters that are already present */
1992 i2c_for_each_dev(driver, __process_new_driver);
1996 EXPORT_SYMBOL(i2c_register_driver);
1998 static int __process_removed_driver(struct device *dev, void *data)
2000 if (dev->type == &i2c_adapter_type)
2001 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2006 * i2c_del_driver - unregister I2C driver
2007 * @driver: the driver being unregistered
2008 * Context: can sleep
2010 void i2c_del_driver(struct i2c_driver *driver)
2012 i2c_for_each_dev(driver, __process_removed_driver);
2014 driver_unregister(&driver->driver);
2015 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
2017 EXPORT_SYMBOL(i2c_del_driver);
2019 /* ------------------------------------------------------------------------- */
2022 * i2c_use_client - increments the reference count of the i2c client structure
2023 * @client: the client being referenced
2025 * Each live reference to a client should be refcounted. The driver model does
2026 * that automatically as part of driver binding, so that most drivers don't
2027 * need to do this explicitly: they hold a reference until they're unbound
2030 * A pointer to the client with the incremented reference counter is returned.
2032 struct i2c_client *i2c_use_client(struct i2c_client *client)
2034 if (client && get_device(&client->dev))
2038 EXPORT_SYMBOL(i2c_use_client);
2041 * i2c_release_client - release a use of the i2c client structure
2042 * @client: the client being no longer referenced
2044 * Must be called when a user of a client is finished with it.
2046 void i2c_release_client(struct i2c_client *client)
2049 put_device(&client->dev);
2051 EXPORT_SYMBOL(i2c_release_client);
2053 struct i2c_cmd_arg {
2058 static int i2c_cmd(struct device *dev, void *_arg)
2060 struct i2c_client *client = i2c_verify_client(dev);
2061 struct i2c_cmd_arg *arg = _arg;
2062 struct i2c_driver *driver;
2064 if (!client || !client->dev.driver)
2067 driver = to_i2c_driver(client->dev.driver);
2068 if (driver->command)
2069 driver->command(client, arg->cmd, arg->arg);
2073 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2075 struct i2c_cmd_arg cmd_arg;
2079 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2081 EXPORT_SYMBOL(i2c_clients_command);
2083 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2084 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2087 struct of_reconfig_data *rd = arg;
2088 struct i2c_adapter *adap;
2089 struct i2c_client *client;
2091 switch (of_reconfig_get_state_change(action, rd)) {
2092 case OF_RECONFIG_CHANGE_ADD:
2093 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2095 return NOTIFY_OK; /* not for us */
2097 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2098 put_device(&adap->dev);
2102 client = of_i2c_register_device(adap, rd->dn);
2103 put_device(&adap->dev);
2105 if (IS_ERR(client)) {
2106 dev_err(&adap->dev, "failed to create client for '%s'\n",
2108 return notifier_from_errno(PTR_ERR(client));
2111 case OF_RECONFIG_CHANGE_REMOVE:
2112 /* already depopulated? */
2113 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2116 /* find our device by node */
2117 client = of_find_i2c_device_by_node(rd->dn);
2119 return NOTIFY_OK; /* no? not meant for us */
2121 /* unregister takes one ref away */
2122 i2c_unregister_device(client);
2124 /* and put the reference of the find */
2125 put_device(&client->dev);
2131 static struct notifier_block i2c_of_notifier = {
2132 .notifier_call = of_i2c_notify,
2135 extern struct notifier_block i2c_of_notifier;
2136 #endif /* CONFIG_OF_DYNAMIC */
2138 static int __init i2c_init(void)
2142 retval = of_alias_get_highest_id("i2c");
2144 down_write(&__i2c_board_lock);
2145 if (retval >= __i2c_first_dynamic_bus_num)
2146 __i2c_first_dynamic_bus_num = retval + 1;
2147 up_write(&__i2c_board_lock);
2149 retval = bus_register(&i2c_bus_type);
2153 is_registered = true;
2155 #ifdef CONFIG_I2C_COMPAT
2156 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2157 if (!i2c_adapter_compat_class) {
2162 retval = i2c_add_driver(&dummy_driver);
2166 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2167 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2172 #ifdef CONFIG_I2C_COMPAT
2173 class_compat_unregister(i2c_adapter_compat_class);
2176 is_registered = false;
2177 bus_unregister(&i2c_bus_type);
2181 static void __exit i2c_exit(void)
2183 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2184 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2185 i2c_del_driver(&dummy_driver);
2186 #ifdef CONFIG_I2C_COMPAT
2187 class_compat_unregister(i2c_adapter_compat_class);
2189 bus_unregister(&i2c_bus_type);
2190 tracepoint_synchronize_unregister();
2193 /* We must initialize early, because some subsystems register i2c drivers
2194 * in subsys_initcall() code, but are linked (and initialized) before i2c.
2196 postcore_initcall(i2c_init);
2197 module_exit(i2c_exit);
2199 /* ----------------------------------------------------
2200 * the functional interface to the i2c busses.
2201 * ----------------------------------------------------
2204 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2205 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2207 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2209 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2210 err_msg, msg->addr, msg->len,
2211 msg->flags & I2C_M_RD ? "read" : "write");
2215 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2217 const struct i2c_adapter_quirks *q = adap->quirks;
2218 int max_num = q->max_num_msgs, i;
2219 bool do_len_check = true;
2221 if (q->flags & I2C_AQ_COMB) {
2224 /* special checks for combined messages */
2226 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2227 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2229 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2230 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2232 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2233 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2235 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2236 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2238 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2239 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2241 do_len_check = false;
2245 if (i2c_quirk_exceeded(num, max_num))
2246 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2248 for (i = 0; i < num; i++) {
2249 u16 len = msgs[i].len;
2251 if (msgs[i].flags & I2C_M_RD) {
2252 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2253 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2255 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2256 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2264 * __i2c_transfer - unlocked flavor of i2c_transfer
2265 * @adap: Handle to I2C bus
2266 * @msgs: One or more messages to execute before STOP is issued to
2267 * terminate the operation; each message begins with a START.
2268 * @num: Number of messages to be executed.
2270 * Returns negative errno, else the number of messages executed.
2272 * Adapter lock must be held when calling this function. No debug logging
2273 * takes place. adap->algo->master_xfer existence isn't checked.
2275 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2277 unsigned long orig_jiffies;
2280 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2283 /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2284 * enabled. This is an efficient way of keeping the for-loop from
2285 * being executed when not needed.
2287 if (static_key_false(&i2c_trace_msg)) {
2289 for (i = 0; i < num; i++)
2290 if (msgs[i].flags & I2C_M_RD)
2291 trace_i2c_read(adap, &msgs[i], i);
2293 trace_i2c_write(adap, &msgs[i], i);
2296 /* Retry automatically on arbitration loss */
2297 orig_jiffies = jiffies;
2298 for (ret = 0, try = 0; try <= adap->retries; try++) {
2299 ret = adap->algo->master_xfer(adap, msgs, num);
2302 if (time_after(jiffies, orig_jiffies + adap->timeout))
2306 if (static_key_false(&i2c_trace_msg)) {
2308 for (i = 0; i < ret; i++)
2309 if (msgs[i].flags & I2C_M_RD)
2310 trace_i2c_reply(adap, &msgs[i], i);
2311 trace_i2c_result(adap, i, ret);
2316 EXPORT_SYMBOL(__i2c_transfer);
2319 * i2c_transfer - execute a single or combined I2C message
2320 * @adap: Handle to I2C bus
2321 * @msgs: One or more messages to execute before STOP is issued to
2322 * terminate the operation; each message begins with a START.
2323 * @num: Number of messages to be executed.
2325 * Returns negative errno, else the number of messages executed.
2327 * Note that there is no requirement that each message be sent to
2328 * the same slave address, although that is the most common model.
2330 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2334 /* REVISIT the fault reporting model here is weak:
2336 * - When we get an error after receiving N bytes from a slave,
2337 * there is no way to report "N".
2339 * - When we get a NAK after transmitting N bytes to a slave,
2340 * there is no way to report "N" ... or to let the master
2341 * continue executing the rest of this combined message, if
2342 * that's the appropriate response.
2344 * - When for example "num" is two and we successfully complete
2345 * the first message but get an error part way through the
2346 * second, it's unclear whether that should be reported as
2347 * one (discarding status on the second message) or errno
2348 * (discarding status on the first one).
2351 if (adap->algo->master_xfer) {
2353 for (ret = 0; ret < num; ret++) {
2354 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2355 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2356 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2357 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2361 if (in_atomic() || irqs_disabled()) {
2362 ret = adap->trylock_bus(adap, I2C_LOCK_SEGMENT);
2364 /* I2C activity is ongoing. */
2367 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2370 ret = __i2c_transfer(adap, msgs, num);
2371 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2375 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2379 EXPORT_SYMBOL(i2c_transfer);
2382 * i2c_master_send - issue a single I2C message in master transmit mode
2383 * @client: Handle to slave device
2384 * @buf: Data that will be written to the slave
2385 * @count: How many bytes to write, must be less than 64k since msg.len is u16
2387 * Returns negative errno, or else the number of bytes written.
2389 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2392 struct i2c_adapter *adap = client->adapter;
2395 msg.addr = client->addr;
2396 msg.flags = client->flags & I2C_M_TEN;
2398 msg.buf = (char *)buf;
2400 ret = i2c_transfer(adap, &msg, 1);
2403 * If everything went ok (i.e. 1 msg transmitted), return #bytes
2404 * transmitted, else error code.
2406 return (ret == 1) ? count : ret;
2408 EXPORT_SYMBOL(i2c_master_send);
2411 * i2c_master_recv - issue a single I2C message in master receive mode
2412 * @client: Handle to slave device
2413 * @buf: Where to store data read from slave
2414 * @count: How many bytes to read, must be less than 64k since msg.len is u16
2416 * Returns negative errno, or else the number of bytes read.
2418 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2420 struct i2c_adapter *adap = client->adapter;
2424 msg.addr = client->addr;
2425 msg.flags = client->flags & I2C_M_TEN;
2426 msg.flags |= I2C_M_RD;
2430 ret = i2c_transfer(adap, &msg, 1);
2433 * If everything went ok (i.e. 1 msg received), return #bytes received,
2436 return (ret == 1) ? count : ret;
2438 EXPORT_SYMBOL(i2c_master_recv);
2440 /* ----------------------------------------------------
2441 * the i2c address scanning function
2442 * Will not work for 10-bit addresses!
2443 * ----------------------------------------------------
2447 * Legacy default probe function, mostly relevant for SMBus. The default
2448 * probe method is a quick write, but it is known to corrupt the 24RF08
2449 * EEPROMs due to a state machine bug, and could also irreversibly
2450 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2451 * we use a short byte read instead. Also, some bus drivers don't implement
2452 * quick write, so we fallback to a byte read in that case too.
2453 * On x86, there is another special case for FSC hardware monitoring chips,
2454 * which want regular byte reads (address 0x73.) Fortunately, these are the
2455 * only known chips using this I2C address on PC hardware.
2456 * Returns 1 if probe succeeded, 0 if not.
2458 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2461 union i2c_smbus_data dummy;
2464 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2465 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2466 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2467 I2C_SMBUS_BYTE_DATA, &dummy);
2470 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2471 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2472 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2473 I2C_SMBUS_QUICK, NULL);
2474 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2475 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2476 I2C_SMBUS_BYTE, &dummy);
2478 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2486 static int i2c_detect_address(struct i2c_client *temp_client,
2487 struct i2c_driver *driver)
2489 struct i2c_board_info info;
2490 struct i2c_adapter *adapter = temp_client->adapter;
2491 int addr = temp_client->addr;
2494 /* Make sure the address is valid */
2495 err = i2c_check_7bit_addr_validity_strict(addr);
2497 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2502 /* Skip if already in use (7 bit, no need to encode flags) */
2503 if (i2c_check_addr_busy(adapter, addr))
2506 /* Make sure there is something at this address */
2507 if (!i2c_default_probe(adapter, addr))
2510 /* Finally call the custom detection function */
2511 memset(&info, 0, sizeof(struct i2c_board_info));
2513 err = driver->detect(temp_client, &info);
2515 /* -ENODEV is returned if the detection fails. We catch it
2516 here as this isn't an error. */
2517 return err == -ENODEV ? 0 : err;
2520 /* Consistency check */
2521 if (info.type[0] == '\0') {
2522 dev_err(&adapter->dev, "%s detection function provided "
2523 "no name for 0x%x\n", driver->driver.name,
2526 struct i2c_client *client;
2528 /* Detection succeeded, instantiate the device */
2529 if (adapter->class & I2C_CLASS_DEPRECATED)
2530 dev_warn(&adapter->dev,
2531 "This adapter will soon drop class based instantiation of devices. "
2532 "Please make sure client 0x%02x gets instantiated by other means. "
2533 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2536 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2537 info.type, info.addr);
2538 client = i2c_new_device(adapter, &info);
2540 list_add_tail(&client->detected, &driver->clients);
2542 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2543 info.type, info.addr);
2548 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2550 const unsigned short *address_list;
2551 struct i2c_client *temp_client;
2553 int adap_id = i2c_adapter_id(adapter);
2555 address_list = driver->address_list;
2556 if (!driver->detect || !address_list)
2559 /* Warn that the adapter lost class based instantiation */
2560 if (adapter->class == I2C_CLASS_DEPRECATED) {
2561 dev_dbg(&adapter->dev,
2562 "This adapter dropped support for I2C classes and "
2563 "won't auto-detect %s devices anymore. If you need it, check "
2564 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2565 driver->driver.name);
2569 /* Stop here if the classes do not match */
2570 if (!(adapter->class & driver->class))
2573 /* Set up a temporary client to help detect callback */
2574 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2577 temp_client->adapter = adapter;
2579 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2580 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2581 "addr 0x%02x\n", adap_id, address_list[i]);
2582 temp_client->addr = address_list[i];
2583 err = i2c_detect_address(temp_client, driver);
2592 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2594 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2595 I2C_SMBUS_QUICK, NULL) >= 0;
2597 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2600 i2c_new_probed_device(struct i2c_adapter *adap,
2601 struct i2c_board_info *info,
2602 unsigned short const *addr_list,
2603 int (*probe)(struct i2c_adapter *, unsigned short addr))
2608 probe = i2c_default_probe;
2610 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2611 /* Check address validity */
2612 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2613 dev_warn(&adap->dev, "Invalid 7-bit address "
2614 "0x%02x\n", addr_list[i]);
2618 /* Check address availability (7 bit, no need to encode flags) */
2619 if (i2c_check_addr_busy(adap, addr_list[i])) {
2620 dev_dbg(&adap->dev, "Address 0x%02x already in "
2621 "use, not probing\n", addr_list[i]);
2625 /* Test address responsiveness */
2626 if (probe(adap, addr_list[i]))
2630 if (addr_list[i] == I2C_CLIENT_END) {
2631 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2635 info->addr = addr_list[i];
2636 return i2c_new_device(adap, info);
2638 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2640 struct i2c_adapter *i2c_get_adapter(int nr)
2642 struct i2c_adapter *adapter;
2644 mutex_lock(&core_lock);
2645 adapter = idr_find(&i2c_adapter_idr, nr);
2649 if (try_module_get(adapter->owner))
2650 get_device(&adapter->dev);
2655 mutex_unlock(&core_lock);
2658 EXPORT_SYMBOL(i2c_get_adapter);
2660 void i2c_put_adapter(struct i2c_adapter *adap)
2665 put_device(&adap->dev);
2666 module_put(adap->owner);
2668 EXPORT_SYMBOL(i2c_put_adapter);
2670 /* The SMBus parts */
2672 #define POLY (0x1070U << 3)
2673 static u8 crc8(u16 data)
2677 for (i = 0; i < 8; i++) {
2682 return (u8)(data >> 8);
2685 /* Incremental CRC8 over count bytes in the array pointed to by p */
2686 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2690 for (i = 0; i < count; i++)
2691 crc = crc8((crc ^ p[i]) << 8);
2695 /* Assume a 7-bit address, which is reasonable for SMBus */
2696 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2698 /* The address will be sent first */
2699 u8 addr = i2c_8bit_addr_from_msg(msg);
2700 pec = i2c_smbus_pec(pec, &addr, 1);
2702 /* The data buffer follows */
2703 return i2c_smbus_pec(pec, msg->buf, msg->len);
2706 /* Used for write only transactions */
2707 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2709 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2713 /* Return <0 on CRC error
2714 If there was a write before this read (most cases) we need to take the
2715 partial CRC from the write part into account.
2716 Note that this function does modify the message (we need to decrease the
2717 message length to hide the CRC byte from the caller). */
2718 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2720 u8 rpec = msg->buf[--msg->len];
2721 cpec = i2c_smbus_msg_pec(cpec, msg);
2724 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2732 * i2c_smbus_read_byte - SMBus "receive byte" protocol
2733 * @client: Handle to slave device
2735 * This executes the SMBus "receive byte" protocol, returning negative errno
2736 * else the byte received from the device.
2738 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2740 union i2c_smbus_data data;
2743 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2745 I2C_SMBUS_BYTE, &data);
2746 return (status < 0) ? status : data.byte;
2748 EXPORT_SYMBOL(i2c_smbus_read_byte);
2751 * i2c_smbus_write_byte - SMBus "send byte" protocol
2752 * @client: Handle to slave device
2753 * @value: Byte to be sent
2755 * This executes the SMBus "send byte" protocol, returning negative errno
2756 * else zero on success.
2758 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2760 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2761 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2763 EXPORT_SYMBOL(i2c_smbus_write_byte);
2766 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2767 * @client: Handle to slave device
2768 * @command: Byte interpreted by slave
2770 * This executes the SMBus "read byte" protocol, returning negative errno
2771 * else a data byte received from the device.
2773 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2775 union i2c_smbus_data data;
2778 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2779 I2C_SMBUS_READ, command,
2780 I2C_SMBUS_BYTE_DATA, &data);
2781 return (status < 0) ? status : data.byte;
2783 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2786 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2787 * @client: Handle to slave device
2788 * @command: Byte interpreted by slave
2789 * @value: Byte being written
2791 * This executes the SMBus "write byte" protocol, returning negative errno
2792 * else zero on success.
2794 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2797 union i2c_smbus_data data;
2799 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2800 I2C_SMBUS_WRITE, command,
2801 I2C_SMBUS_BYTE_DATA, &data);
2803 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2806 * i2c_smbus_read_word_data - SMBus "read word" protocol
2807 * @client: Handle to slave device
2808 * @command: Byte interpreted by slave
2810 * This executes the SMBus "read word" protocol, returning negative errno
2811 * else a 16-bit unsigned "word" received from the device.
2813 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2815 union i2c_smbus_data data;
2818 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2819 I2C_SMBUS_READ, command,
2820 I2C_SMBUS_WORD_DATA, &data);
2821 return (status < 0) ? status : data.word;
2823 EXPORT_SYMBOL(i2c_smbus_read_word_data);
2826 * i2c_smbus_write_word_data - SMBus "write word" protocol
2827 * @client: Handle to slave device
2828 * @command: Byte interpreted by slave
2829 * @value: 16-bit "word" being written
2831 * This executes the SMBus "write word" protocol, returning negative errno
2832 * else zero on success.
2834 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2837 union i2c_smbus_data data;
2839 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2840 I2C_SMBUS_WRITE, command,
2841 I2C_SMBUS_WORD_DATA, &data);
2843 EXPORT_SYMBOL(i2c_smbus_write_word_data);
2846 * i2c_smbus_read_block_data - SMBus "block read" protocol
2847 * @client: Handle to slave device
2848 * @command: Byte interpreted by slave
2849 * @values: Byte array into which data will be read; big enough to hold
2850 * the data returned by the slave. SMBus allows at most 32 bytes.
2852 * This executes the SMBus "block read" protocol, returning negative errno
2853 * else the number of data bytes in the slave's response.
2855 * Note that using this function requires that the client's adapter support
2856 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
2857 * support this; its emulation through I2C messaging relies on a specific
2858 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
2860 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2863 union i2c_smbus_data data;
2866 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2867 I2C_SMBUS_READ, command,
2868 I2C_SMBUS_BLOCK_DATA, &data);
2872 memcpy(values, &data.block[1], data.block[0]);
2873 return data.block[0];
2875 EXPORT_SYMBOL(i2c_smbus_read_block_data);
2878 * i2c_smbus_write_block_data - SMBus "block write" protocol
2879 * @client: Handle to slave device
2880 * @command: Byte interpreted by slave
2881 * @length: Size of data block; SMBus allows at most 32 bytes
2882 * @values: Byte array which will be written.
2884 * This executes the SMBus "block write" protocol, returning negative errno
2885 * else zero on success.
2887 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2888 u8 length, const u8 *values)
2890 union i2c_smbus_data data;
2892 if (length > I2C_SMBUS_BLOCK_MAX)
2893 length = I2C_SMBUS_BLOCK_MAX;
2894 data.block[0] = length;
2895 memcpy(&data.block[1], values, length);
2896 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2897 I2C_SMBUS_WRITE, command,
2898 I2C_SMBUS_BLOCK_DATA, &data);
2900 EXPORT_SYMBOL(i2c_smbus_write_block_data);
2902 /* Returns the number of read bytes */
2903 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2904 u8 length, u8 *values)
2906 union i2c_smbus_data data;
2909 if (length > I2C_SMBUS_BLOCK_MAX)
2910 length = I2C_SMBUS_BLOCK_MAX;
2911 data.block[0] = length;
2912 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2913 I2C_SMBUS_READ, command,
2914 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2918 memcpy(values, &data.block[1], data.block[0]);
2919 return data.block[0];
2921 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2923 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2924 u8 length, const u8 *values)
2926 union i2c_smbus_data data;
2928 if (length > I2C_SMBUS_BLOCK_MAX)
2929 length = I2C_SMBUS_BLOCK_MAX;
2930 data.block[0] = length;
2931 memcpy(data.block + 1, values, length);
2932 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2933 I2C_SMBUS_WRITE, command,
2934 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2936 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2938 /* Simulate a SMBus command using the i2c protocol
2939 No checking of parameters is done! */
2940 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2941 unsigned short flags,
2942 char read_write, u8 command, int size,
2943 union i2c_smbus_data *data)
2945 /* So we need to generate a series of msgs. In the case of writing, we
2946 need to use only one message; when reading, we need two. We initialize
2947 most things with sane defaults, to keep the code below somewhat
2949 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2950 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2951 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2955 struct i2c_msg msg[2] = {
2963 .flags = flags | I2C_M_RD,
2969 msgbuf0[0] = command;
2971 case I2C_SMBUS_QUICK:
2973 /* Special case: The read/write field is used as data */
2974 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2978 case I2C_SMBUS_BYTE:
2979 if (read_write == I2C_SMBUS_READ) {
2980 /* Special case: only a read! */
2981 msg[0].flags = I2C_M_RD | flags;
2985 case I2C_SMBUS_BYTE_DATA:
2986 if (read_write == I2C_SMBUS_READ)
2990 msgbuf0[1] = data->byte;
2993 case I2C_SMBUS_WORD_DATA:
2994 if (read_write == I2C_SMBUS_READ)
2998 msgbuf0[1] = data->word & 0xff;
2999 msgbuf0[2] = data->word >> 8;
3002 case I2C_SMBUS_PROC_CALL:
3003 num = 2; /* Special case */
3004 read_write = I2C_SMBUS_READ;
3007 msgbuf0[1] = data->word & 0xff;
3008 msgbuf0[2] = data->word >> 8;
3010 case I2C_SMBUS_BLOCK_DATA:
3011 if (read_write == I2C_SMBUS_READ) {
3012 msg[1].flags |= I2C_M_RECV_LEN;
3013 msg[1].len = 1; /* block length will be added by
3014 the underlying bus driver */
3016 msg[0].len = data->block[0] + 2;
3017 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3018 dev_err(&adapter->dev,
3019 "Invalid block write size %d\n",
3023 for (i = 1; i < msg[0].len; i++)
3024 msgbuf0[i] = data->block[i-1];
3027 case I2C_SMBUS_BLOCK_PROC_CALL:
3028 num = 2; /* Another special case */
3029 read_write = I2C_SMBUS_READ;
3030 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3031 dev_err(&adapter->dev,
3032 "Invalid block write size %d\n",
3036 msg[0].len = data->block[0] + 2;
3037 for (i = 1; i < msg[0].len; i++)
3038 msgbuf0[i] = data->block[i-1];
3039 msg[1].flags |= I2C_M_RECV_LEN;
3040 msg[1].len = 1; /* block length will be added by
3041 the underlying bus driver */
3043 case I2C_SMBUS_I2C_BLOCK_DATA:
3044 if (read_write == I2C_SMBUS_READ) {
3045 msg[1].len = data->block[0];
3047 msg[0].len = data->block[0] + 1;
3048 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3049 dev_err(&adapter->dev,
3050 "Invalid block write size %d\n",
3054 for (i = 1; i <= data->block[0]; i++)
3055 msgbuf0[i] = data->block[i];
3059 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3063 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3064 && size != I2C_SMBUS_I2C_BLOCK_DATA);
3066 /* Compute PEC if first message is a write */
3067 if (!(msg[0].flags & I2C_M_RD)) {
3068 if (num == 1) /* Write only */
3069 i2c_smbus_add_pec(&msg[0]);
3070 else /* Write followed by read */
3071 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3073 /* Ask for PEC if last message is a read */
3074 if (msg[num-1].flags & I2C_M_RD)
3078 status = i2c_transfer(adapter, msg, num);
3082 /* Check PEC if last message is a read */
3083 if (i && (msg[num-1].flags & I2C_M_RD)) {
3084 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3089 if (read_write == I2C_SMBUS_READ)
3091 case I2C_SMBUS_BYTE:
3092 data->byte = msgbuf0[0];
3094 case I2C_SMBUS_BYTE_DATA:
3095 data->byte = msgbuf1[0];
3097 case I2C_SMBUS_WORD_DATA:
3098 case I2C_SMBUS_PROC_CALL:
3099 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3101 case I2C_SMBUS_I2C_BLOCK_DATA:
3102 for (i = 0; i < data->block[0]; i++)
3103 data->block[i+1] = msgbuf1[i];
3105 case I2C_SMBUS_BLOCK_DATA:
3106 case I2C_SMBUS_BLOCK_PROC_CALL:
3107 for (i = 0; i < msgbuf1[0] + 1; i++)
3108 data->block[i] = msgbuf1[i];
3115 * i2c_smbus_xfer - execute SMBus protocol operations
3116 * @adapter: Handle to I2C bus
3117 * @addr: Address of SMBus slave on that bus
3118 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3119 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3120 * @command: Byte interpreted by slave, for protocols which use such bytes
3121 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3122 * @data: Data to be read or written
3124 * This executes an SMBus protocol operation, and returns a negative
3125 * errno code else zero on success.
3127 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3128 char read_write, u8 command, int protocol,
3129 union i2c_smbus_data *data)
3131 unsigned long orig_jiffies;
3135 /* If enabled, the following two tracepoints are conditional on
3136 * read_write and protocol.
3138 trace_smbus_write(adapter, addr, flags, read_write,
3139 command, protocol, data);
3140 trace_smbus_read(adapter, addr, flags, read_write,
3143 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3145 if (adapter->algo->smbus_xfer) {
3146 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3148 /* Retry automatically on arbitration loss */
3149 orig_jiffies = jiffies;
3150 for (res = 0, try = 0; try <= adapter->retries; try++) {
3151 res = adapter->algo->smbus_xfer(adapter, addr, flags,
3152 read_write, command,
3156 if (time_after(jiffies,
3157 orig_jiffies + adapter->timeout))
3160 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3162 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3165 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3166 * implement native support for the SMBus operation.
3170 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3171 command, protocol, data);
3174 /* If enabled, the reply tracepoint is conditional on read_write. */
3175 trace_smbus_reply(adapter, addr, flags, read_write,
3176 command, protocol, data);
3177 trace_smbus_result(adapter, addr, flags, read_write,
3178 command, protocol, res);
3182 EXPORT_SYMBOL(i2c_smbus_xfer);
3185 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3186 * @client: Handle to slave device
3187 * @command: Byte interpreted by slave
3188 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3189 * @values: Byte array into which data will be read; big enough to hold
3190 * the data returned by the slave. SMBus allows at most
3191 * I2C_SMBUS_BLOCK_MAX bytes.
3193 * This executes the SMBus "block read" protocol if supported by the adapter.
3194 * If block read is not supported, it emulates it using either word or byte
3195 * read protocols depending on availability.
3197 * The addresses of the I2C slave device that are accessed with this function
3198 * must be mapped to a linear region, so that a block read will have the same
3199 * effect as a byte read. Before using this function you must double-check
3200 * if the I2C slave does support exchanging a block transfer with a byte
3203 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3204 u8 command, u8 length, u8 *values)
3209 if (length > I2C_SMBUS_BLOCK_MAX)
3210 length = I2C_SMBUS_BLOCK_MAX;
3212 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3213 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3215 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3218 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3219 while ((i + 2) <= length) {
3220 status = i2c_smbus_read_word_data(client, command + i);
3223 values[i] = status & 0xff;
3224 values[i + 1] = status >> 8;
3229 while (i < length) {
3230 status = i2c_smbus_read_byte_data(client, command + i);
3239 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3241 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3242 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3246 if (!client || !slave_cb) {
3247 WARN(1, "insufficent data\n");
3251 if (!(client->flags & I2C_CLIENT_SLAVE))
3252 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3255 if (!(client->flags & I2C_CLIENT_TEN)) {
3256 /* Enforce stricter address checking */
3257 ret = i2c_check_7bit_addr_validity_strict(client->addr);
3259 dev_err(&client->dev, "%s: invalid address\n", __func__);
3264 if (!client->adapter->algo->reg_slave) {
3265 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3269 client->slave_cb = slave_cb;
3271 i2c_lock_adapter(client->adapter);
3272 ret = client->adapter->algo->reg_slave(client);
3273 i2c_unlock_adapter(client->adapter);
3276 client->slave_cb = NULL;
3277 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3282 EXPORT_SYMBOL_GPL(i2c_slave_register);
3284 int i2c_slave_unregister(struct i2c_client *client)
3288 if (!client->adapter->algo->unreg_slave) {
3289 dev_err(&client->dev, "%s: not supported by adapter\n", __func__);
3293 i2c_lock_adapter(client->adapter);
3294 ret = client->adapter->algo->unreg_slave(client);
3295 i2c_unlock_adapter(client->adapter);
3298 client->slave_cb = NULL;
3300 dev_err(&client->dev, "%s: adapter returned error %d\n", __func__, ret);
3304 EXPORT_SYMBOL_GPL(i2c_slave_unregister);
3307 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
3308 MODULE_DESCRIPTION("I2C-Bus main module");
3309 MODULE_LICENSE("GPL");